Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Initial build

  • Loading branch information...
commit c5e260c322b6ecd99f3306846f3b27fcae8b4a45 0 parents
Daniel Holden authored
8 .gitignore
@@ -0,0 +1,8 @@
+*~
+*.exe
+obj*
+demos/demo_convert
+demos/demo_embed
+demos/demo_func
+demos/demo_struct
+liblua_autoc.so
26 LICENSE.md
@@ -0,0 +1,26 @@
+Copyright (c) 2012, Daniel Holden
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are those
+of the authors and should not be interpreted as representing official policies,
+either expressed or implied, of the FreeBSD Project.
36 Makefile
@@ -0,0 +1,36 @@
+CC=gcc
+
+C_FILES= $(wildcard src/*.c)
+OBJ_FILES= $(addprefix obj/,$(notdir $(C_FILES:.c=.o)))
+
+PLATFORM = $(shell uname)
+
+ifeq ($(findstring Linux,$(PLATFORM)),Linux)
+ OUT= liblua_autoc.so
+ INCS= -I ./include -I/usr/include/lua52
+ CFLAGS= $(INCS) -std=gnu99 -Wall -Werror -Wno-unused -O3 -g -fPIC
+ LFLAGS= -llua5.2
+ DISTUTIL=
+endif
+
+ifeq ($(findstring MINGW,$(PLATFORM)),MINGW)
+ OUT= lua_autoc.dll
+ INCS= -I ./include -I./lua52/include
+ CFLAGS= $(INCS) -std=gnu99 -Wall -Werror -Wno-unused -O3 -g
+ LFLAGS= -g -L./lua52 -L./ -llua52 -lmingw32
+ DISTUTIL= -c mingw32
+endif
+
+all: library
+
+library: $(OBJ_FILES)
+ $(CC) $(OBJ_FILES) $(LFLAGS) -shared -o $(OUT)
+
+obj/%.o: src/%.c | obj
+ $(CC) $< -c $(CFLAGS) -o $@
+
+obj:
+ mkdir obj
+
+clean:
+ rm $(OBJ_FILES)
43 autogen.py
@@ -0,0 +1,43 @@
+import sys
+import re
+
+if len(sys.argv) != 2:
+ print "Usage: python autogen.py <header.h>"
+
+f = open(sys.argv[1])
+text = f.read()
+text = text.replace("\r","").replace("\n","")
+f.close()
+
+typedefs = re.findall(r"typedef struct \{.*?\} \w+;", text)
+funcdefs = re.findall(r"[\w\*]+ \w+\(.*?\);", text)
+
+print ""
+
+for typedef in typedefs:
+ match = re.search(r"typedef struct \{(.*)\} (\w+);", typedef);
+ inner, ctype = match.groups()
+ decl = inner.split(";")
+ pairs = []
+ for d in decl:
+ in_match = re.search(r"\s*([\w\*]+)\s*(\w+)\s*", d)
+ if in_match is not None: pairs.append(in_match.groups())
+ print "lua_autostruct_add(%s);" % ctype
+ for p in pairs: print "lua_autostruct_addmember(%s, %s, %s);" % (ctype, p[1], p[0])
+ print ""
+
+for funcdef in funcdefs:
+ match = re.search("([\w\*]+) (\w+)\((.*?)\);", funcdef);
+ ctype, fname, args = match.groups()
+ pairs = []
+ for a in args.split(","):
+ in_match = re.search(r"\s*([\w\*]+)\s*(\w+)\s*", a)
+ if in_match is not None: pairs.append(in_match.groups())
+ voidstring = ""
+ if ctype == "void": voidstring = "_void"
+ fstring = "lua_autofunc_add_args%i%s(%s, %s" % (len(pairs), voidstring, fname, ctype)
+ for p in pairs: fstring += ", %s" % p[0]
+ fstring += ");"
+ print fstring
+
+print ""
12 include/lua_autoc.h
@@ -0,0 +1,12 @@
+#ifndef lua_autoc_h
+#define lua_autoc_h
+
+#include "lua_autotype.h"
+#include "lua_autostack.h"
+#include "lua_autostruct.h"
+#include "lua_autocall.h"
+
+void lua_autoc_open(void);
+void lua_autoc_close(void);
+
+#endif
42 include/lua_autocall.h
@@ -0,0 +1,42 @@
+#ifndef lua_autocall_h
+#define lua_autocall_h
+
+#include "lua.h"
+#include "lua_autotype.h"
+#include "lua_autocall_macros.h"
+
+void lua_autocall_open(void);
+void lua_autocall_close(void);
+
+#define lua_autocall(L, func) lua_autocall_name(L, #func)
+void lua_autocall_name(lua_State* L, char* func_name);
+
+#define lua_autofunc_add_args0(L, func, ret_t) lua_autofunc_add_args0_macro(L, func, ret_t)
+#define lua_autofunc_add_args0_void(L, func, ret_t) lua_autofunc_add_args0_void_macro(L, func, ret_t)
+#define lua_autofunc_add_args1(L, func, ret_t, arg0_t) lua_autofunc_add_args1_macro(L, func, ret_t, arg0_t)
+#define lua_autofunc_add_args1_void(L, func, ret_t, arg0_t) lua_autofunc_add_args1_void_macro(L, func, ret_t, arg0_t)
+#define lua_autofunc_add_args2(L, func, ret_t, arg0_t, arg1_t) lua_autofunc_add_args2_macro(L, func, ret_t, arg0_t, arg1_t)
+#define lua_autofunc_add_args2_void(L, func, ret_t, arg0_t, arg1_t) lua_autofunc_add_args2_void_macro(L, func, ret_t, arg0_t, arg1_t)
+#define lua_autofunc_add_args3(L, func, ret_t, arg0_t, arg1_t, arg2_t) lua_autofunc_add_args3_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t)
+#define lua_autofunc_add_args3_void(L, func, ret_t, arg0_t, arg1_t, arg2_t) lua_autofunc_add_args3_void_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t)
+#define lua_autofunc_add_args4(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t) lua_autofunc_add_args4_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t)
+#define lua_autofunc_add_args4_void(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t) lua_autofunc_add_args4_void_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t)
+#define lua_autofunc_add_args5(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t) lua_autofunc_add_args5_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t)
+#define lua_autofunc_add_args5_void(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t) lua_autofunc_add_args5_void_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t)
+#define lua_autofunc_add_args6(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t) lua_autofunc_add_args6_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t)
+#define lua_autofunc_add_args6_void(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t) lua_autofunc_add_args6_void_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t)
+#define lua_autofunc_add_args7(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t) lua_autofunc_add_args7_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t)
+#define lua_autofunc_add_args7_void(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t) lua_autofunc_add_args7_void_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t)
+#define lua_autofunc_add_args8(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t) lua_autofunc_add_args8_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t)
+#define lua_autofunc_add_args8_void(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t) lua_autofunc_add_args8_void_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t)
+#define lua_autofunc_add_args9(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t, arg8_t) lua_autofunc_add_args9_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t, arg8_t)
+#define lua_autofunc_add_args9_void(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t, arg8_t) lua_autofunc_add_args9_void_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t, arg8_t)
+#define lua_autofunc_add_args10(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t, arg8_t, arg9_t) lua_autofunc_add_args10_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t, arg8_t, arg9_t)
+#define lua_autofunc_add_args10_void(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t, arg8_t, arg9_t) lua_autofunc_add_args10_void_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t, arg8_t, arg9_t)
+
+typedef void (*lua_autofunc)(void*,void*);
+
+void lua_autofunc_add_typeid(lua_State* L, lua_autofunc ac_func, char* name, lua_autotype ret_tid, int num_args, ...);
+
+
+#endif
224 include/lua_autocall_macros.h
@@ -0,0 +1,224 @@
+#ifndef lua_autocall_macros_h
+#define lua_autocall_macros_h
+
+#define lua_autofunc_add_args0_macro(L, func, ret_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ *(ret_t*)out = func(); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 0)
+
+#define lua_autofunc_add_args0_void_macro(L, func, ret_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ func(); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 0)
+
+#define lua_autofunc_add_args1_macro(L, func, ret_t, arg0_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ *(ret_t*)out = func(a0); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 1, lua_typeid(arg0_t))
+
+#define lua_autofunc_add_args1_void_macro(L, func, ret_t, arg0_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ func(a0); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 1, lua_typeid(arg0_t))
+
+#define lua_autofunc_add_args2_macro(L, func, ret_t, arg0_t, arg1_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ *(ret_t*)out = func(a0, a1); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 2, lua_typeid(arg0_t), lua_typeid(arg1_t))
+
+#define lua_autofunc_add_args2_void_macro(L, func, ret_t, arg0_t, arg1_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ func(a0, a1); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 2, lua_typeid(arg0_t), lua_typeid(arg1_t))
+
+#define lua_autofunc_add_args3_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ arg2_t a2 = *(arg2_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)); \
+ *(ret_t*)out = func(a0, a1, a2); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 3, lua_typeid(arg0_t), lua_typeid(arg1_t), lua_typeid(arg2_t))
+
+#define lua_autofunc_add_args3_void_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ arg2_t a2 = *(arg2_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)); \
+ func(a0, a1, a2); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 3, lua_typeid(arg0_t), lua_typeid(arg1_t), lua_typeid(arg2_t))
+
+#define lua_autofunc_add_args4_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ arg2_t a2 = *(arg2_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)); \
+ arg3_t a3 = *(arg3_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)); \
+ *(ret_t*)out = func(a0, a1, a2, a3); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 4, lua_typeid(arg0_t), lua_typeid(arg1_t), lua_typeid(arg2_t), lua_typeid(arg3_t))
+
+#define lua_autofunc_add_args4_void_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ arg2_t a2 = *(arg2_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)); \
+ arg3_t a3 = *(arg3_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)); \
+ func(a0, a1, a2, a3); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 4, lua_typeid(arg0_t), lua_typeid(arg1_t), lua_typeid(arg2_t), lua_typeid(arg3_t))
+
+#define lua_autofunc_add_args5_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ arg2_t a2 = *(arg2_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)); \
+ arg3_t a3 = *(arg3_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)); \
+ arg4_t a4 = *(arg4_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)); \
+ *(ret_t*)out = func(a0, a1, a2, a3, a4); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 5, lua_typeid(arg0_t), lua_typeid(arg1_t), lua_typeid(arg2_t), lua_typeid(arg3_t), lua_typeid(arg4_t))
+
+#define lua_autofunc_add_args5_void_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ arg2_t a2 = *(arg2_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)); \
+ arg3_t a3 = *(arg3_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)); \
+ arg4_t a4 = *(arg4_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)); \
+ func(a0, a1, a2, a3, a4); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 5, lua_typeid(arg0_t), lua_typeid(arg1_t), lua_typeid(arg2_t), lua_typeid(arg3_t), lua_typeid(arg4_t))
+
+#define lua_autofunc_add_args6_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ arg2_t a2 = *(arg2_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)); \
+ arg3_t a3 = *(arg3_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)); \
+ arg4_t a4 = *(arg4_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)); \
+ arg5_t a5 = *(arg5_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)); \
+ *(ret_t*)out = func(a0, a1, a2, a3, a4, a5); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 6, lua_typeid(arg0_t), lua_typeid(arg1_t), lua_typeid(arg2_t), lua_typeid(arg3_t), lua_typeid(arg4_t), lua_typeid(arg5_t))
+
+#define lua_autofunc_add_args6_void_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ arg2_t a2 = *(arg2_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)); \
+ arg3_t a3 = *(arg3_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)); \
+ arg4_t a4 = *(arg4_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)); \
+ arg5_t a5 = *(arg5_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)); \
+ func(a0, a1, a2, a3, a4, a5); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 6, lua_typeid(arg0_t), lua_typeid(arg1_t), lua_typeid(arg2_t), lua_typeid(arg3_t), lua_typeid(arg4_t), lua_typeid(arg5_t))
+
+#define lua_autofunc_add_args7_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ arg2_t a2 = *(arg2_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)); \
+ arg3_t a3 = *(arg3_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)); \
+ arg4_t a4 = *(arg4_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)); \
+ arg5_t a5 = *(arg5_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)); \
+ arg6_t a6 = *(arg6_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)); \
+ *(ret_t*)out = func(a0, a1, a2, a3, a4, a5, a6); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 7, lua_typeid(arg0_t), lua_typeid(arg1_t), lua_typeid(arg2_t), lua_typeid(arg3_t), lua_typeid(arg4_t), lua_typeid(arg5_t), lua_typeid(arg6_t))
+
+#define lua_autofunc_add_args7_void_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ arg2_t a2 = *(arg2_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)); \
+ arg3_t a3 = *(arg3_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)); \
+ arg4_t a4 = *(arg4_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)); \
+ arg5_t a5 = *(arg5_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)); \
+ arg6_t a6 = *(arg6_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)); \
+ func(a0, a1, a2, a3, a4, a5, a6); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 7, lua_typeid(arg0_t), lua_typeid(arg1_t), lua_typeid(arg2_t), lua_typeid(arg3_t), lua_typeid(arg4_t), lua_typeid(arg5_t), lua_typeid(arg6_t))
+
+#define lua_autofunc_add_args8_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ arg2_t a2 = *(arg2_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)); \
+ arg3_t a3 = *(arg3_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)); \
+ arg4_t a4 = *(arg4_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)); \
+ arg5_t a5 = *(arg5_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)); \
+ arg6_t a6 = *(arg6_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)); \
+ arg7_t a7 = *(arg7_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)+sizeof(arg6_t)); \
+ *(ret_t*)out = func(a0, a1, a2, a3, a4, a5, a6, a7); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 8, lua_typeid(arg0_t), lua_typeid(arg1_t), lua_typeid(arg2_t), lua_typeid(arg3_t), lua_typeid(arg4_t), lua_typeid(arg5_t), lua_typeid(arg6_t), lua_typeid(arg7_t))
+
+#define lua_autofunc_add_args8_void_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ arg2_t a2 = *(arg2_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)); \
+ arg3_t a3 = *(arg3_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)); \
+ arg4_t a4 = *(arg4_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)); \
+ arg5_t a5 = *(arg5_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)); \
+ arg6_t a6 = *(arg6_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)); \
+ arg7_t a7 = *(arg7_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)+sizeof(arg6_t)); \
+ func(a0, a1, a2, a3, a4, a5, a6, a7); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 8, lua_typeid(arg0_t), lua_typeid(arg1_t), lua_typeid(arg2_t), lua_typeid(arg3_t), lua_typeid(arg4_t), lua_typeid(arg5_t), lua_typeid(arg6_t), lua_typeid(arg7_t))
+
+#define lua_autofunc_add_args9_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t, arg8_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ arg2_t a2 = *(arg2_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)); \
+ arg3_t a3 = *(arg3_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)); \
+ arg4_t a4 = *(arg4_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)); \
+ arg5_t a5 = *(arg5_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)); \
+ arg6_t a6 = *(arg6_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)); \
+ arg7_t a7 = *(arg7_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)+sizeof(arg6_t)); \
+ arg8_t a8 = *(arg8_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)+sizeof(arg6_t)+sizeof(arg7_t)); \
+ *(ret_t*)out = func(a0, a1, a2, a3, a4, a5, a6, a7, a8); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 9, lua_typeid(arg0_t), lua_typeid(arg1_t), lua_typeid(arg2_t), lua_typeid(arg3_t), lua_typeid(arg4_t), lua_typeid(arg5_t), lua_typeid(arg6_t), lua_typeid(arg7_t), lua_typeid(arg8_t))
+
+#define lua_autofunc_add_args9_void_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t, arg8_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ arg2_t a2 = *(arg2_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)); \
+ arg3_t a3 = *(arg3_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)); \
+ arg4_t a4 = *(arg4_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)); \
+ arg5_t a5 = *(arg5_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)); \
+ arg6_t a6 = *(arg6_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)); \
+ arg7_t a7 = *(arg7_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)+sizeof(arg6_t)); \
+ arg8_t a8 = *(arg8_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)+sizeof(arg6_t)+sizeof(arg7_t)); \
+ func(a0, a1, a2, a3, a4, a5, a6, a7, a8); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 9, lua_typeid(arg0_t), lua_typeid(arg1_t), lua_typeid(arg2_t), lua_typeid(arg3_t), lua_typeid(arg4_t), lua_typeid(arg5_t), lua_typeid(arg6_t), lua_typeid(arg7_t), lua_typeid(arg8_t))
+
+#define lua_autofunc_add_args10_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t, arg8_t, arg9_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ arg2_t a2 = *(arg2_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)); \
+ arg3_t a3 = *(arg3_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)); \
+ arg4_t a4 = *(arg4_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)); \
+ arg5_t a5 = *(arg5_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)); \
+ arg6_t a6 = *(arg6_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)); \
+ arg7_t a7 = *(arg7_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)+sizeof(arg6_t)); \
+ arg8_t a8 = *(arg8_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)+sizeof(arg6_t)+sizeof(arg7_t)); \
+ arg9_t a9 = *(arg9_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)+sizeof(arg6_t)+sizeof(arg7_t)+sizeof(arg8_t)); \
+ *(ret_t*)out = func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 10, lua_typeid(arg0_t), lua_typeid(arg1_t), lua_typeid(arg2_t), lua_typeid(arg3_t), lua_typeid(arg4_t), lua_typeid(arg5_t), lua_typeid(arg6_t), lua_typeid(arg7_t), lua_typeid(arg8_t), lua_typeid(arg9_t))
+
+#define lua_autofunc_add_args10_void_macro(L, func, ret_t, arg0_t, arg1_t, arg2_t, arg3_t, arg4_t, arg5_t, arg6_t, arg7_t, arg8_t, arg9_t) \
+void __lua_autoc_##func(void* out, void* args) { \
+ arg0_t a0 = *(arg0_t*)args; \
+ arg1_t a1 = *(arg1_t*)(args+sizeof(arg0_t)); \
+ arg2_t a2 = *(arg2_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)); \
+ arg3_t a3 = *(arg3_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)); \
+ arg4_t a4 = *(arg4_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)); \
+ arg5_t a5 = *(arg5_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)); \
+ arg6_t a6 = *(arg6_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)); \
+ arg7_t a7 = *(arg7_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)+sizeof(arg6_t)); \
+ arg8_t a8 = *(arg8_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)+sizeof(arg6_t)+sizeof(arg7_t)); \
+ arg9_t a9 = *(arg9_t*)(args+sizeof(arg0_t)+sizeof(arg1_t)+sizeof(arg2_t)+sizeof(arg3_t)+sizeof(arg4_t)+sizeof(arg5_t)+sizeof(arg6_t)+sizeof(arg7_t)+sizeof(arg8_t)); \
+ func(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); }; \
+lua_autofunc_add_typeid(L, __lua_autoc_##func, #func, lua_typeid(ret_t), 10, lua_typeid(arg0_t), lua_typeid(arg1_t), lua_typeid(arg2_t), lua_typeid(arg3_t), lua_typeid(arg4_t), lua_typeid(arg5_t), lua_typeid(arg6_t), lua_typeid(arg7_t), lua_typeid(arg8_t), lua_typeid(arg9_t))
+
+#endif
29 include/lua_autohashtable.h
@@ -0,0 +1,29 @@
+#ifndef lua_autohashtable_h
+#define lua_autohashtable_h
+
+typedef struct lua_autobucket {
+ void* item;
+ char* string;
+ struct lua_autobucket* next;
+ struct lua_autobucket* prev;
+} lua_autobucket;
+
+
+typedef struct {
+ lua_autobucket** buckets;
+ int size;
+} lua_autohashtable;
+
+
+lua_autohashtable* lua_autohashtable_new(int table_size);
+void lua_autohashtable_delete(lua_autohashtable* ht);
+
+int lua_autohashtable_contains(lua_autohashtable* ht, char* string);
+void* lua_autohashtable_get(lua_autohashtable* ht, char* string);
+void lua_autohashtable_set(lua_autohashtable* ht, char* string, void* item);
+
+char* lua_autohashtable_find(lua_autohashtable* ht, void* item);
+
+void lua_autohashtable_map(lua_autohashtable* ht, void (*func)(void*));
+
+#endif
66 include/lua_autostack.h
@@ -0,0 +1,66 @@
+#ifndef lua_autostack_h
+#define lua_autostack_h
+
+#include "lua.h"
+#include "lua_autotype.h"
+
+void lua_autostack_open(void);
+void lua_autostack_close(void);
+
+#define lua_autopush(L, type, c_val) lua_autopush_typeid(L, lua_typeid(type), c_in)
+void lua_autopush_typeid(lua_State* L, lua_autotype type_id, void* c_in);
+
+#define lua_autopop(L, type, py_val, c_out) lua_autopop_typeid(L, lua_typeid(type), c_out)
+void lua_autopop_typeid(lua_State* L, lua_autotype type_id, void* c_out);
+
+typedef void (*lua_autopush_func)(lua_State*, void*);
+typedef void (*lua_autopop_func)(lua_State*, void*);
+
+#define lua_autostack_func(type, push_func, pop_func) lua_autostack_func_typeid(lua_typeid(type), push_func, pop_func);
+void lua_autostack_func_typeid(lua_autotype type_id, lua_autopush_func push_func, lua_autopop_func pop_func);
+
+#define lua_autostack_push_func(type, func) lua_autostack_push_func_typeid(lua_typeid(type), func)
+void lua_autostack_push_func_typeid(lua_autotype type_id, lua_autopush_func func);
+
+#define lua_autostack_pop_func(type, func) lua_autostack_pop_func_typeid(lua_typeid(type), func)
+void lua_autostack_pop_func_typeid(lua_autotype type_id, lua_autopop_func func);
+
+
+void lua_autopush_prim_char(lua_State* L, void* c_in);
+void lua_autopop_prim_char(lua_State* L, void* c_out);
+void lua_autopush_prim_signed_char(lua_State* L, void* c_in);
+void lua_autopop_prim_signed_char(lua_State* L, void* c_out);
+void lua_autopush_prim_unsigned_char(lua_State* L, void* c_in);
+void lua_autopop_prim_unsigned_char(lua_State* L, void* c_out);
+void lua_autopush_prim_short(lua_State* L, void* c_in);
+void lua_autopop_prim_short(lua_State* L, void* c_out);
+void lua_autopush_prim_unsigned_short(lua_State* L, void* c_in);
+void lua_autopop_prim_unsigned_short(lua_State* L, void* c_out);
+void lua_autopush_prim_int(lua_State* L, void* c_in);
+void lua_autopop_prim_int(lua_State* L, void* c_out);
+void lua_autopush_prim_unsigned_int(lua_State* L, void* c_in);
+void lua_autopop_prim_unsigned_int(lua_State* L, void* c_out);
+void lua_autopush_prim_long(lua_State* L, void* c_in);
+void lua_autopop_prim_long(lua_State* L, void* c_out);
+void lua_autopush_prim_unsigned_long(lua_State* L, void* c_in);
+void lua_autopop_prim_unsigned_long(lua_State* L, void* c_out);
+void lua_autopush_prim_long_long(lua_State* L, void* c_in);
+void lua_autopop_prim_long_long(lua_State* L, void* c_out);
+void lua_autopush_prim_unsigned_long_long(lua_State* L, void* c_in);
+void lua_autopop_prim_unsigned_long_long(lua_State* L, void* c_out);
+void lua_autopush_prim_float(lua_State* L, void* c_in);
+void lua_autopop_prim_float(lua_State* L, void* c_out);
+void lua_autopush_prim_double(lua_State* L, void* c_in);
+void lua_autopop_prim_double(lua_State* L, void* c_out);
+void lua_autopush_prim_long_double(lua_State* L, void* c_in);
+void lua_autopop_prim_long_double(lua_State* L, void* c_out);
+
+/* These return a copy of a string which the user is responsible for freeing */
+void lua_autopush_prim_char_ptr(lua_State* L, void* c_in);
+void lua_autopop_prim_char_ptr(lua_State* L, void* c_out);
+void lua_autopush_prim_const_char_ptr(lua_State* L, void* c_in);
+void lua_autopop_prim_const_char_ptr(lua_State* L, void* c_out);
+
+void lua_autopush_prim_void(lua_State* L, void* c_in);
+
+#endif
33 include/lua_autostruct.h
@@ -0,0 +1,33 @@
+#ifndef lua_autostruct_h
+#define lua_autostruct_h
+
+#include "lua_autotype.h"
+
+void lua_autostruct_open(void);
+void lua_autostruct_close(void);
+
+#define lua_autostruct_push_member(L, type, cstruct, member) lua_autostruct_push_member_typeid(L, lua_typeid(type), cstruct, member)
+void lua_autostruct_push_member_typeid(lua_State* L, lua_autotype type, void* cstruct, char* member);
+
+#define lua_autostruct_pop_member(L, type, cstruct, member) lua_autostruct_pop_member_typeid(L, lua_typeid(type), cstruct, member)
+void lua_autostruct_pop_member_typeid(lua_State* L, lua_autotype type, void* cstruct, char* member);
+
+#define lua_autostruct_has_member(L, type, member) lua_autostruct_has_member_typeid(L, lua_typeid(type), member)
+int lua_autostruct_has_member_typeid(lua_State* L, lua_autotype type, char* member);
+
+#define lua_autostruct_add(L, type) lua_autostruct_add_typid(L, lua_typeid(type))
+void lua_autostruct_add_typid(lua_State* L, lua_autotype type);
+
+#define lua_autostruct_addmember(L, type, member, member_type) lua_autostruct_addmember_typeid(L, lua_typeid(type), #member, lua_typeid(member_type), ((long)&(((type*)0)->member)))
+void lua_autostruct_addmember_typeid(lua_State* L, lua_autotype type, char* member, lua_autotype member_type, int offset);
+
+#define lua_autostruct_added(L, type) lua_autostruct_added_typeid(L, lua_typeid(type))
+int lua_autostruct_added_typeid(lua_State* L, lua_autotype type);
+
+#define lua_autostruct_push(L, type, c_in) lua_autostruct_push_typeid(L, lua_typeid(type), c_in)
+void lua_autostruct_push_typeid(lua_State* L, lua_autotype type, void* c_in);
+
+#define lua_autostruct_pop(L, type, c_out) lua_autostruct_pop_typeid(L, lua_typeid(type), pyobj, c_out)
+void lua_autostruct_pop_typeid(lua_State* L, lua_autotype type, void* c_out);
+
+#endif
17 include/lua_autotype.h
@@ -0,0 +1,17 @@
+#ifndef lua_autotype_h
+#define lua_autotype_h
+
+void lua_autotype_open(void);
+void lua_autotype_close(void);
+
+typedef int lua_autotype;
+
+#define lua_typeid(type) lua_autotype_push(#type, sizeof(type))
+
+lua_autotype lua_autotype_push(char* type, int size);
+lua_autotype lua_autotype_find(char* type);
+
+char* lua_autotype_name(lua_autotype id);
+int lua_autotype_size(lua_autotype id);
+
+#endif
BIN  lua52.dll
Binary file not shown
212 lua52/include/lauxlib.h
@@ -0,0 +1,212 @@
+/*
+** $Id: lauxlib.h,v 1.120 2011/11/29 15:55:08 roberto Exp $
+** Auxiliary functions for building Lua libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lauxlib_h
+#define lauxlib_h
+
+
+#include <stddef.h>
+#include <stdio.h>
+
+#include "lua.h"
+
+
+
+/* extra error code for `luaL_load' */
+#define LUA_ERRFILE (LUA_ERRERR+1)
+
+
+typedef struct luaL_Reg {
+ const char *name;
+ lua_CFunction func;
+} luaL_Reg;
+
+
+LUALIB_API void (luaL_checkversion_) (lua_State *L, lua_Number ver);
+#define luaL_checkversion(L) luaL_checkversion_(L, LUA_VERSION_NUM)
+
+LUALIB_API int (luaL_getmetafield) (lua_State *L, int obj, const char *e);
+LUALIB_API int (luaL_callmeta) (lua_State *L, int obj, const char *e);
+LUALIB_API const char *(luaL_tolstring) (lua_State *L, int idx, size_t *len);
+LUALIB_API int (luaL_argerror) (lua_State *L, int numarg, const char *extramsg);
+LUALIB_API const char *(luaL_checklstring) (lua_State *L, int numArg,
+ size_t *l);
+LUALIB_API const char *(luaL_optlstring) (lua_State *L, int numArg,
+ const char *def, size_t *l);
+LUALIB_API lua_Number (luaL_checknumber) (lua_State *L, int numArg);
+LUALIB_API lua_Number (luaL_optnumber) (lua_State *L, int nArg, lua_Number def);
+
+LUALIB_API lua_Integer (luaL_checkinteger) (lua_State *L, int numArg);
+LUALIB_API lua_Integer (luaL_optinteger) (lua_State *L, int nArg,
+ lua_Integer def);
+LUALIB_API lua_Unsigned (luaL_checkunsigned) (lua_State *L, int numArg);
+LUALIB_API lua_Unsigned (luaL_optunsigned) (lua_State *L, int numArg,
+ lua_Unsigned def);
+
+LUALIB_API void (luaL_checkstack) (lua_State *L, int sz, const char *msg);
+LUALIB_API void (luaL_checktype) (lua_State *L, int narg, int t);
+LUALIB_API void (luaL_checkany) (lua_State *L, int narg);
+
+LUALIB_API int (luaL_newmetatable) (lua_State *L, const char *tname);
+LUALIB_API void (luaL_setmetatable) (lua_State *L, const char *tname);
+LUALIB_API void *(luaL_testudata) (lua_State *L, int ud, const char *tname);
+LUALIB_API void *(luaL_checkudata) (lua_State *L, int ud, const char *tname);
+
+LUALIB_API void (luaL_where) (lua_State *L, int lvl);
+LUALIB_API int (luaL_error) (lua_State *L, const char *fmt, ...);
+
+LUALIB_API int (luaL_checkoption) (lua_State *L, int narg, const char *def,
+ const char *const lst[]);
+
+LUALIB_API int (luaL_fileresult) (lua_State *L, int stat, const char *fname);
+LUALIB_API int (luaL_execresult) (lua_State *L, int stat);
+
+/* pre-defined references */
+#define LUA_NOREF (-2)
+#define LUA_REFNIL (-1)
+
+LUALIB_API int (luaL_ref) (lua_State *L, int t);
+LUALIB_API void (luaL_unref) (lua_State *L, int t, int ref);
+
+LUALIB_API int (luaL_loadfilex) (lua_State *L, const char *filename,
+ const char *mode);
+
+#define luaL_loadfile(L,f) luaL_loadfilex(L,f,NULL)
+
+LUALIB_API int (luaL_loadbufferx) (lua_State *L, const char *buff, size_t sz,
+ const char *name, const char *mode);
+LUALIB_API int (luaL_loadstring) (lua_State *L, const char *s);
+
+LUALIB_API lua_State *(luaL_newstate) (void);
+
+LUALIB_API int (luaL_len) (lua_State *L, int idx);
+
+LUALIB_API const char *(luaL_gsub) (lua_State *L, const char *s, const char *p,
+ const char *r);
+
+LUALIB_API void (luaL_setfuncs) (lua_State *L, const luaL_Reg *l, int nup);
+
+LUALIB_API int (luaL_getsubtable) (lua_State *L, int idx, const char *fname);
+
+LUALIB_API void (luaL_traceback) (lua_State *L, lua_State *L1,
+ const char *msg, int level);
+
+LUALIB_API void (luaL_requiref) (lua_State *L, const char *modname,
+ lua_CFunction openf, int glb);
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+
+#define luaL_newlibtable(L,l) \
+ lua_createtable(L, 0, sizeof(l)/sizeof((l)[0]) - 1)
+
+#define luaL_newlib(L,l) (luaL_newlibtable(L,l), luaL_setfuncs(L,l,0))
+
+#define luaL_argcheck(L, cond,numarg,extramsg) \
+ ((void)((cond) || luaL_argerror(L, (numarg), (extramsg))))
+#define luaL_checkstring(L,n) (luaL_checklstring(L, (n), NULL))
+#define luaL_optstring(L,n,d) (luaL_optlstring(L, (n), (d), NULL))
+#define luaL_checkint(L,n) ((int)luaL_checkinteger(L, (n)))
+#define luaL_optint(L,n,d) ((int)luaL_optinteger(L, (n), (d)))
+#define luaL_checklong(L,n) ((long)luaL_checkinteger(L, (n)))
+#define luaL_optlong(L,n,d) ((long)luaL_optinteger(L, (n), (d)))
+
+#define luaL_typename(L,i) lua_typename(L, lua_type(L,(i)))
+
+#define luaL_dofile(L, fn) \
+ (luaL_loadfile(L, fn) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_dostring(L, s) \
+ (luaL_loadstring(L, s) || lua_pcall(L, 0, LUA_MULTRET, 0))
+
+#define luaL_getmetatable(L,n) (lua_getfield(L, LUA_REGISTRYINDEX, (n)))
+
+#define luaL_opt(L,f,n,d) (lua_isnoneornil(L,(n)) ? (d) : f(L,(n)))
+
+#define luaL_loadbuffer(L,s,sz,n) luaL_loadbufferx(L,s,sz,n,NULL)
+
+
+/*
+** {======================================================
+** Generic Buffer manipulation
+** =======================================================
+*/
+
+typedef struct luaL_Buffer {
+ char *b; /* buffer address */
+ size_t size; /* buffer size */
+ size_t n; /* number of characters in buffer */
+ lua_State *L;
+ char initb[LUAL_BUFFERSIZE]; /* initial buffer */
+} luaL_Buffer;
+
+
+#define luaL_addchar(B,c) \
+ ((void)((B)->n < (B)->size || luaL_prepbuffsize((B), 1)), \
+ ((B)->b[(B)->n++] = (c)))
+
+#define luaL_addsize(B,s) ((B)->n += (s))
+
+LUALIB_API void (luaL_buffinit) (lua_State *L, luaL_Buffer *B);
+LUALIB_API char *(luaL_prepbuffsize) (luaL_Buffer *B, size_t sz);
+LUALIB_API void (luaL_addlstring) (luaL_Buffer *B, const char *s, size_t l);
+LUALIB_API void (luaL_addstring) (luaL_Buffer *B, const char *s);
+LUALIB_API void (luaL_addvalue) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresult) (luaL_Buffer *B);
+LUALIB_API void (luaL_pushresultsize) (luaL_Buffer *B, size_t sz);
+LUALIB_API char *(luaL_buffinitsize) (lua_State *L, luaL_Buffer *B, size_t sz);
+
+#define luaL_prepbuffer(B) luaL_prepbuffsize(B, LUAL_BUFFERSIZE)
+
+/* }====================================================== */
+
+
+
+/*
+** {======================================================
+** File handles for IO library
+** =======================================================
+*/
+
+/*
+** A file handle is a userdata with metatable 'LUA_FILEHANDLE' and
+** initial structure 'luaL_Stream' (it may contain other fields
+** after that initial structure).
+*/
+
+#define LUA_FILEHANDLE "FILE*"
+
+
+typedef struct luaL_Stream {
+ FILE *f; /* stream (NULL for incompletely created streams) */
+ lua_CFunction closef; /* to close stream (NULL for closed streams) */
+} luaL_Stream;
+
+/* }====================================================== */
+
+
+
+/* compatibility with old module system */
+#if defined(LUA_COMPAT_MODULE)
+
+LUALIB_API void (luaL_pushmodule) (lua_State *L, const char *modname,
+ int sizehint);
+LUALIB_API void (luaL_openlib) (lua_State *L, const char *libname,
+ const luaL_Reg *l, int nup);
+
+#define luaL_register(L,n,l) (luaL_openlib(L,(n),(l),0))
+
+#endif
+
+
+#endif
+
+
439 lua52/include/lua.h
@@ -0,0 +1,439 @@
+/*
+** $Id: lua.h,v 1.282 2011/11/29 15:55:08 roberto Exp $
+** Lua - A Scripting Language
+** Lua.org, PUC-Rio, Brazil (http://www.lua.org)
+** See Copyright Notice at the end of this file
+*/
+
+
+#ifndef lua_h
+#define lua_h
+
+#include <stdarg.h>
+#include <stddef.h>
+
+
+#include "luaconf.h"
+
+
+#define LUA_VERSION_MAJOR "5"
+#define LUA_VERSION_MINOR "2"
+#define LUA_VERSION_NUM 502
+#define LUA_VERSION_RELEASE "0"
+
+#define LUA_VERSION "Lua " LUA_VERSION_MAJOR "." LUA_VERSION_MINOR
+#define LUA_RELEASE LUA_VERSION "." LUA_VERSION_RELEASE
+#define LUA_COPYRIGHT LUA_RELEASE " Copyright (C) 1994-2011 Lua.org, PUC-Rio"
+#define LUA_AUTHORS "R. Ierusalimschy, L. H. de Figueiredo, W. Celes"
+
+
+/* mark for precompiled code ('<esc>Lua') */
+#define LUA_SIGNATURE "\033Lua"
+
+/* option for multiple returns in 'lua_pcall' and 'lua_call' */
+#define LUA_MULTRET (-1)
+
+
+/*
+** pseudo-indices
+*/
+#define LUA_REGISTRYINDEX LUAI_FIRSTPSEUDOIDX
+#define lua_upvalueindex(i) (LUA_REGISTRYINDEX - (i))
+
+
+/* thread status */
+#define LUA_OK 0
+#define LUA_YIELD 1
+#define LUA_ERRRUN 2
+#define LUA_ERRSYNTAX 3
+#define LUA_ERRMEM 4
+#define LUA_ERRGCMM 5
+#define LUA_ERRERR 6
+
+
+typedef struct lua_State lua_State;
+
+typedef int (*lua_CFunction) (lua_State *L);
+
+
+/*
+** functions that read/write blocks when loading/dumping Lua chunks
+*/
+typedef const char * (*lua_Reader) (lua_State *L, void *ud, size_t *sz);
+
+typedef int (*lua_Writer) (lua_State *L, const void* p, size_t sz, void* ud);
+
+
+/*
+** prototype for memory-allocation functions
+*/
+typedef void * (*lua_Alloc) (void *ud, void *ptr, size_t osize, size_t nsize);
+
+
+/*
+** basic types
+*/
+#define LUA_TNONE (-1)
+
+#define LUA_TNIL 0
+#define LUA_TBOOLEAN 1
+#define LUA_TLIGHTUSERDATA 2
+#define LUA_TNUMBER 3
+#define LUA_TSTRING 4
+#define LUA_TTABLE 5
+#define LUA_TFUNCTION 6
+#define LUA_TUSERDATA 7
+#define LUA_TTHREAD 8
+
+#define LUA_NUMTAGS 9
+
+
+
+/* minimum Lua stack available to a C function */
+#define LUA_MINSTACK 20
+
+
+/* predefined values in the registry */
+#define LUA_RIDX_MAINTHREAD 1
+#define LUA_RIDX_GLOBALS 2
+#define LUA_RIDX_LAST LUA_RIDX_GLOBALS
+
+
+/* type of numbers in Lua */
+typedef LUA_NUMBER lua_Number;
+
+
+/* type for integer functions */
+typedef LUA_INTEGER lua_Integer;
+
+/* unsigned integer type */
+typedef LUA_UNSIGNED lua_Unsigned;
+
+
+
+/*
+** generic extra include file
+*/
+#if defined(LUA_USER_H)
+#include LUA_USER_H
+#endif
+
+
+
+/*
+** state manipulation
+*/
+LUA_API lua_State *(lua_newstate) (lua_Alloc f, void *ud);
+LUA_API void (lua_close) (lua_State *L);
+LUA_API lua_State *(lua_newthread) (lua_State *L);
+
+LUA_API lua_CFunction (lua_atpanic) (lua_State *L, lua_CFunction panicf);
+
+
+LUA_API const lua_Number *(lua_version) (lua_State *L);
+
+
+/*
+** basic stack manipulation
+*/
+LUA_API int (lua_absindex) (lua_State *L, int idx);
+LUA_API int (lua_gettop) (lua_State *L);
+LUA_API void (lua_settop) (lua_State *L, int idx);
+LUA_API void (lua_pushvalue) (lua_State *L, int idx);
+LUA_API void (lua_remove) (lua_State *L, int idx);
+LUA_API void (lua_insert) (lua_State *L, int idx);
+LUA_API void (lua_replace) (lua_State *L, int idx);
+LUA_API void (lua_copy) (lua_State *L, int fromidx, int toidx);
+LUA_API int (lua_checkstack) (lua_State *L, int sz);
+
+LUA_API void (lua_xmove) (lua_State *from, lua_State *to, int n);
+
+
+/*
+** access functions (stack -> C)
+*/
+
+LUA_API int (lua_isnumber) (lua_State *L, int idx);
+LUA_API int (lua_isstring) (lua_State *L, int idx);
+LUA_API int (lua_iscfunction) (lua_State *L, int idx);
+LUA_API int (lua_isuserdata) (lua_State *L, int idx);
+LUA_API int (lua_type) (lua_State *L, int idx);
+LUA_API const char *(lua_typename) (lua_State *L, int tp);
+
+LUA_API lua_Number (lua_tonumberx) (lua_State *L, int idx, int *isnum);
+LUA_API lua_Integer (lua_tointegerx) (lua_State *L, int idx, int *isnum);
+LUA_API lua_Unsigned (lua_tounsignedx) (lua_State *L, int idx, int *isnum);
+LUA_API int (lua_toboolean) (lua_State *L, int idx);
+LUA_API const char *(lua_tolstring) (lua_State *L, int idx, size_t *len);
+LUA_API size_t (lua_rawlen) (lua_State *L, int idx);
+LUA_API lua_CFunction (lua_tocfunction) (lua_State *L, int idx);
+LUA_API void *(lua_touserdata) (lua_State *L, int idx);
+LUA_API lua_State *(lua_tothread) (lua_State *L, int idx);
+LUA_API const void *(lua_topointer) (lua_State *L, int idx);
+
+
+/*
+** Comparison and arithmetic functions
+*/
+
+#define LUA_OPADD 0 /* ORDER TM */
+#define LUA_OPSUB 1
+#define LUA_OPMUL 2
+#define LUA_OPDIV 3
+#define LUA_OPMOD 4
+#define LUA_OPPOW 5
+#define LUA_OPUNM 6
+
+LUA_API void (lua_arith) (lua_State *L, int op);
+
+#define LUA_OPEQ 0
+#define LUA_OPLT 1
+#define LUA_OPLE 2
+
+LUA_API int (lua_rawequal) (lua_State *L, int idx1, int idx2);
+LUA_API int (lua_compare) (lua_State *L, int idx1, int idx2, int op);
+
+
+/*
+** push functions (C -> stack)
+*/
+LUA_API void (lua_pushnil) (lua_State *L);
+LUA_API void (lua_pushnumber) (lua_State *L, lua_Number n);
+LUA_API void (lua_pushinteger) (lua_State *L, lua_Integer n);
+LUA_API void (lua_pushunsigned) (lua_State *L, lua_Unsigned n);
+LUA_API const char *(lua_pushlstring) (lua_State *L, const char *s, size_t l);
+LUA_API const char *(lua_pushstring) (lua_State *L, const char *s);
+LUA_API const char *(lua_pushvfstring) (lua_State *L, const char *fmt,
+ va_list argp);
+LUA_API const char *(lua_pushfstring) (lua_State *L, const char *fmt, ...);
+LUA_API void (lua_pushcclosure) (lua_State *L, lua_CFunction fn, int n);
+LUA_API void (lua_pushboolean) (lua_State *L, int b);
+LUA_API void (lua_pushlightuserdata) (lua_State *L, void *p);
+LUA_API int (lua_pushthread) (lua_State *L);
+
+
+/*
+** get functions (Lua -> stack)
+*/
+LUA_API void (lua_getglobal) (lua_State *L, const char *var);
+LUA_API void (lua_gettable) (lua_State *L, int idx);
+LUA_API void (lua_getfield) (lua_State *L, int idx, const char *k);
+LUA_API void (lua_rawget) (lua_State *L, int idx);
+LUA_API void (lua_rawgeti) (lua_State *L, int idx, int n);
+LUA_API void (lua_rawgetp) (lua_State *L, int idx, const void *p);
+LUA_API void (lua_createtable) (lua_State *L, int narr, int nrec);
+LUA_API void *(lua_newuserdata) (lua_State *L, size_t sz);
+LUA_API int (lua_getmetatable) (lua_State *L, int objindex);
+LUA_API void (lua_getuservalue) (lua_State *L, int idx);
+
+
+/*
+** set functions (stack -> Lua)
+*/
+LUA_API void (lua_setglobal) (lua_State *L, const char *var);
+LUA_API void (lua_settable) (lua_State *L, int idx);
+LUA_API void (lua_setfield) (lua_State *L, int idx, const char *k);
+LUA_API void (lua_rawset) (lua_State *L, int idx);
+LUA_API void (lua_rawseti) (lua_State *L, int idx, int n);
+LUA_API void (lua_rawsetp) (lua_State *L, int idx, const void *p);
+LUA_API int (lua_setmetatable) (lua_State *L, int objindex);
+LUA_API void (lua_setuservalue) (lua_State *L, int idx);
+
+
+/*
+** 'load' and 'call' functions (load and run Lua code)
+*/
+LUA_API void (lua_callk) (lua_State *L, int nargs, int nresults, int ctx,
+ lua_CFunction k);
+#define lua_call(L,n,r) lua_callk(L, (n), (r), 0, NULL)
+
+LUA_API int (lua_getctx) (lua_State *L, int *ctx);
+
+LUA_API int (lua_pcallk) (lua_State *L, int nargs, int nresults, int errfunc,
+ int ctx, lua_CFunction k);
+#define lua_pcall(L,n,r,f) lua_pcallk(L, (n), (r), (f), 0, NULL)
+
+LUA_API int (lua_load) (lua_State *L, lua_Reader reader, void *dt,
+ const char *chunkname,
+ const char *mode);
+
+LUA_API int (lua_dump) (lua_State *L, lua_Writer writer, void *data);
+
+
+/*
+** coroutine functions
+*/
+LUA_API int (lua_yieldk) (lua_State *L, int nresults, int ctx,
+ lua_CFunction k);
+#define lua_yield(L,n) lua_yieldk(L, (n), 0, NULL)
+LUA_API int (lua_resume) (lua_State *L, lua_State *from, int narg);
+LUA_API int (lua_status) (lua_State *L);
+
+/*
+** garbage-collection function and options
+*/
+
+#define LUA_GCSTOP 0
+#define LUA_GCRESTART 1
+#define LUA_GCCOLLECT 2
+#define LUA_GCCOUNT 3
+#define LUA_GCCOUNTB 4
+#define LUA_GCSTEP 5
+#define LUA_GCSETPAUSE 6
+#define LUA_GCSETSTEPMUL 7
+#define LUA_GCSETMAJORINC 8
+#define LUA_GCISRUNNING 9
+#define LUA_GCGEN 10
+#define LUA_GCINC 11
+
+LUA_API int (lua_gc) (lua_State *L, int what, int data);
+
+
+/*
+** miscellaneous functions
+*/
+
+LUA_API int (lua_error) (lua_State *L);
+
+LUA_API int (lua_next) (lua_State *L, int idx);
+
+LUA_API void (lua_concat) (lua_State *L, int n);
+LUA_API void (lua_len) (lua_State *L, int idx);
+
+LUA_API lua_Alloc (lua_getallocf) (lua_State *L, void **ud);
+LUA_API void (lua_setallocf) (lua_State *L, lua_Alloc f, void *ud);
+
+
+
+/*
+** ===============================================================
+** some useful macros
+** ===============================================================
+*/
+
+#define lua_tonumber(L,i) lua_tonumberx(L,i,NULL)
+#define lua_tointeger(L,i) lua_tointegerx(L,i,NULL)
+#define lua_tounsigned(L,i) lua_tounsignedx(L,i,NULL)
+
+#define lua_pop(L,n) lua_settop(L, -(n)-1)
+
+#define lua_newtable(L) lua_createtable(L, 0, 0)
+
+#define lua_register(L,n,f) (lua_pushcfunction(L, (f)), lua_setglobal(L, (n)))
+
+#define lua_pushcfunction(L,f) lua_pushcclosure(L, (f), 0)
+
+#define lua_isfunction(L,n) (lua_type(L, (n)) == LUA_TFUNCTION)
+#define lua_istable(L,n) (lua_type(L, (n)) == LUA_TTABLE)
+#define lua_islightuserdata(L,n) (lua_type(L, (n)) == LUA_TLIGHTUSERDATA)
+#define lua_isnil(L,n) (lua_type(L, (n)) == LUA_TNIL)
+#define lua_isboolean(L,n) (lua_type(L, (n)) == LUA_TBOOLEAN)
+#define lua_isthread(L,n) (lua_type(L, (n)) == LUA_TTHREAD)
+#define lua_isnone(L,n) (lua_type(L, (n)) == LUA_TNONE)
+#define lua_isnoneornil(L, n) (lua_type(L, (n)) <= 0)
+
+#define lua_pushliteral(L, s) \
+ lua_pushlstring(L, "" s, (sizeof(s)/sizeof(char))-1)
+
+#define lua_pushglobaltable(L) \
+ lua_rawgeti(L, LUA_REGISTRYINDEX, LUA_RIDX_GLOBALS)
+
+#define lua_tostring(L,i) lua_tolstring(L, (i), NULL)
+
+
+
+/*
+** {======================================================================
+** Debug API
+** =======================================================================
+*/
+
+
+/*
+** Event codes
+*/
+#define LUA_HOOKCALL 0
+#define LUA_HOOKRET 1
+#define LUA_HOOKLINE 2
+#define LUA_HOOKCOUNT 3
+#define LUA_HOOKTAILCALL 4
+
+
+/*
+** Event masks
+*/
+#define LUA_MASKCALL (1 << LUA_HOOKCALL)
+#define LUA_MASKRET (1 << LUA_HOOKRET)
+#define LUA_MASKLINE (1 << LUA_HOOKLINE)
+#define LUA_MASKCOUNT (1 << LUA_HOOKCOUNT)
+
+typedef struct lua_Debug lua_Debug; /* activation record */
+
+
+/* Functions to be called by the debugger in specific events */
+typedef void (*lua_Hook) (lua_State *L, lua_Debug *ar);
+
+
+LUA_API int (lua_getstack) (lua_State *L, int level, lua_Debug *ar);
+LUA_API int (lua_getinfo) (lua_State *L, const char *what, lua_Debug *ar);
+LUA_API const char *(lua_getlocal) (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *(lua_setlocal) (lua_State *L, const lua_Debug *ar, int n);
+LUA_API const char *(lua_getupvalue) (lua_State *L, int funcindex, int n);
+LUA_API const char *(lua_setupvalue) (lua_State *L, int funcindex, int n);
+
+LUA_API void *(lua_upvalueid) (lua_State *L, int fidx, int n);
+LUA_API void (lua_upvaluejoin) (lua_State *L, int fidx1, int n1,
+ int fidx2, int n2);
+
+LUA_API int (lua_sethook) (lua_State *L, lua_Hook func, int mask, int count);
+LUA_API lua_Hook (lua_gethook) (lua_State *L);
+LUA_API int (lua_gethookmask) (lua_State *L);
+LUA_API int (lua_gethookcount) (lua_State *L);
+
+
+struct lua_Debug {
+ int event;
+ const char *name; /* (n) */
+ const char *namewhat; /* (n) 'global', 'local', 'field', 'method' */
+ const char *what; /* (S) 'Lua', 'C', 'main', 'tail' */
+ const char *source; /* (S) */
+ int currentline; /* (l) */
+ int linedefined; /* (S) */
+ int lastlinedefined; /* (S) */
+ unsigned char nups; /* (u) number of upvalues */
+ unsigned char nparams;/* (u) number of parameters */
+ char isvararg; /* (u) */
+ char istailcall; /* (t) */
+ char short_src[LUA_IDSIZE]; /* (S) */
+ /* private part */
+ struct CallInfo *i_ci; /* active function */
+};
+
+/* }====================================================================== */
+
+
+/******************************************************************************
+* Copyright (C) 1994-2011 Lua.org, PUC-Rio. All rights reserved.
+*
+* Permission is hereby granted, free of charge, to any person obtaining
+* a copy of this software and associated documentation files (the
+* "Software"), to deal in the Software without restriction, including
+* without limitation the rights to use, copy, modify, merge, publish,
+* distribute, sublicense, and/or sell copies of the Software, and to
+* permit persons to whom the Software is furnished to do so, subject to
+* the following conditions:
+*
+* The above copyright notice and this permission notice shall be
+* included in all copies or substantial portions of the Software.
+*
+* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+******************************************************************************/
+
+
+#endif
9 lua52/include/lua.hpp
@@ -0,0 +1,9 @@
+// lua.hpp
+// Lua header files for C++
+// <<extern "C">> not supplied automatically because Lua also compiles as C++
+
+extern "C" {
+#include "lua.h"
+#include "lualib.h"
+#include "lauxlib.h"
+}
531 lua52/include/luaconf.h
@@ -0,0 +1,531 @@
+/*
+** $Id: luaconf.h,v 1.170 2011/12/06 16:58:36 roberto Exp $
+** Configuration file for Lua
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lconfig_h
+#define lconfig_h
+
+#include <limits.h>
+#include <stddef.h>
+
+
+/*
+** ==================================================================
+** Search for "@@" to find all configurable definitions.
+** ===================================================================
+*/
+
+
+/*
+@@ LUA_ANSI controls the use of non-ansi features.
+** CHANGE it (define it) if you want Lua to avoid the use of any
+** non-ansi feature or library.
+*/
+#if !defined(LUA_ANSI) && defined(__STRICT_ANSI__)
+#define LUA_ANSI
+#endif
+
+
+#if !defined(LUA_ANSI) && defined(_WIN32) && !defined(_WIN32_WCE)
+#define LUA_WIN /* enable goodies for regular Windows platforms */
+#endif
+
+#if defined(LUA_WIN)
+#define LUA_DL_DLL
+#define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */
+#endif
+
+
+
+#if defined(LUA_USE_LINUX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN /* needs an extra library: -ldl */
+#define LUA_USE_READLINE /* needs some extra libraries */
+#define LUA_USE_STRTODHEX /* assume 'strtod' handles hexa formats */
+#define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */
+#define LUA_USE_LONGLONG /* assume support for long long */
+#endif
+
+#if defined(LUA_USE_MACOSX)
+#define LUA_USE_POSIX
+#define LUA_USE_DLOPEN /* does not need -ldl */
+#define LUA_USE_READLINE /* needs an extra library: -lreadline */
+#define LUA_USE_STRTODHEX /* assume 'strtod' handles hexa formats */
+#define LUA_USE_AFORMAT /* assume 'printf' handles 'aA' specifiers */
+#define LUA_USE_LONGLONG /* assume support for long long */
+#endif
+
+
+
+/*
+@@ LUA_USE_POSIX includes all functionality listed as X/Open System
+@* Interfaces Extension (XSI).
+** CHANGE it (define it) if your system is XSI compatible.
+*/
+#if defined(LUA_USE_POSIX)
+#define LUA_USE_MKSTEMP
+#define LUA_USE_ISATTY
+#define LUA_USE_POPEN
+#define LUA_USE_ULONGJMP
+#define LUA_USE_GMTIME_R
+#endif
+
+
+
+/*
+@@ LUA_PATH_DEFAULT is the default path that Lua uses to look for
+@* Lua libraries.
+@@ LUA_CPATH_DEFAULT is the default path that Lua uses to look for
+@* C libraries.
+** CHANGE them if your machine has a non-conventional directory
+** hierarchy or if you want to install your libraries in
+** non-conventional directories.
+*/
+#if defined(_WIN32) /* { */
+/*
+** In Windows, any exclamation mark ('!') in the path is replaced by the
+** path of the directory of the executable file of the current process.
+*/
+#define LUA_LDIR "!\\lua\\"
+#define LUA_CDIR "!\\"
+#define LUA_PATH_DEFAULT \
+ LUA_LDIR"?.lua;" LUA_LDIR"?\\init.lua;" \
+ LUA_CDIR"?.lua;" LUA_CDIR"?\\init.lua;" ".\\?.lua"
+#define LUA_CPATH_DEFAULT \
+ LUA_CDIR"?.dll;" LUA_CDIR"loadall.dll;" ".\\?.dll;" \
+ LUA_CDIR"?52.dll;" ".\\?52.dll"
+
+#else /* }{ */
+
+#define LUA_VDIR LUA_VERSION_MAJOR "." LUA_VERSION_MINOR "/"
+#define LUA_ROOT "/usr/local/"
+#define LUA_LDIR LUA_ROOT "share/lua/" LUA_VDIR
+#define LUA_CDIR LUA_ROOT "lib/lua/" LUA_VDIR
+#define LUA_PATH_DEFAULT \
+ LUA_LDIR"?.lua;" LUA_LDIR"?/init.lua;" \
+ LUA_CDIR"?.lua;" LUA_CDIR"?/init.lua;" "./?.lua"
+#define LUA_CPATH_DEFAULT \
+ LUA_CDIR"?.so;" LUA_CDIR"loadall.so;" "./?.so;" \
+ LUA_CDIR"lib?52.so;" "./lib?52.so"
+#endif /* } */
+
+
+/*
+@@ LUA_DIRSEP is the directory separator (for submodules).
+** CHANGE it if your machine does not use "/" as the directory separator
+** and is not Windows. (On Windows Lua automatically uses "\".)
+*/
+#if defined(_WIN32)
+#define LUA_DIRSEP "\\"
+#else
+#define LUA_DIRSEP "/"
+#endif
+
+
+/*
+@@ LUA_ENV is the name of the variable that holds the current
+@@ environment, used to access global names.
+** CHANGE it if you do not like this name.
+*/
+#define LUA_ENV "_ENV"
+
+
+/*
+@@ LUA_API is a mark for all core API functions.
+@@ LUALIB_API is a mark for all auxiliary library functions.
+@@ LUAMOD_API is a mark for all standard library opening functions.
+** CHANGE them if you need to define those functions in some special way.
+** For instance, if you want to create one Windows DLL with the core and
+** the libraries, you may want to use the following definition (define
+** LUA_BUILD_AS_DLL to get it).
+*/
+#if defined(LUA_BUILD_AS_DLL) /* { */
+
+#if defined(LUA_CORE) || defined(LUA_LIB) /* { */
+#define LUA_API __declspec(dllexport)
+#else /* }{ */
+#define LUA_API __declspec(dllimport)
+#endif /* } */
+
+#else /* }{ */
+
+#define LUA_API extern
+
+#endif /* } */
+
+
+/* more often than not the libs go together with the core */
+#define LUALIB_API LUA_API
+#define LUAMOD_API LUALIB_API
+
+
+/*
+@@ LUAI_FUNC is a mark for all extern functions that are not to be
+@* exported to outside modules.
+@@ LUAI_DDEF and LUAI_DDEC are marks for all extern (const) variables
+@* that are not to be exported to outside modules (LUAI_DDEF for
+@* definitions and LUAI_DDEC for declarations).
+** CHANGE them if you need to mark them in some special way. Elf/gcc
+** (versions 3.2 and later) mark them as "hidden" to optimize access
+** when Lua is compiled as a shared library. Not all elf targets support
+** this attribute. Unfortunately, gcc does not offer a way to check
+** whether the target offers that support, and those without support
+** give a warning about it. To avoid these warnings, change to the
+** default definition.
+*/
+#if defined(__GNUC__) && ((__GNUC__*100 + __GNUC_MINOR__) >= 302) && \
+ defined(__ELF__) /* { */
+#define LUAI_FUNC __attribute__((visibility("hidden"))) extern
+#define LUAI_DDEC LUAI_FUNC
+#define LUAI_DDEF /* empty */
+
+#else /* }{ */
+#define LUAI_FUNC extern
+#define LUAI_DDEC extern
+#define LUAI_DDEF /* empty */
+#endif /* } */
+
+
+
+/*
+@@ LUA_QL describes how error messages quote program elements.
+** CHANGE it if you want a different appearance.
+*/
+#define LUA_QL(x) "'" x "'"
+#define LUA_QS LUA_QL("%s")
+
+
+/*
+@@ LUA_IDSIZE gives the maximum size for the description of the source
+@* of a function in debug information.
+** CHANGE it if you want a different size.
+*/
+#define LUA_IDSIZE 60
+
+
+/*
+@@ luai_writestring/luai_writeline define how 'print' prints its results.
+** They are only used in libraries and the stand-alone program. (The #if
+** avoids including 'stdio.h' everywhere.)
+*/
+#if defined(LUA_LIB) || defined(lua_c)
+#include <stdio.h>
+#define luai_writestring(s,l) fwrite((s), sizeof(char), (l), stdout)
+#define luai_writeline() (luai_writestring("\n", 1), fflush(stdout))
+#endif
+
+/*
+@@ luai_writestringerror defines how to print error messages.
+** (A format string with one argument is enough for Lua...)
+*/
+#define luai_writestringerror(s,p) \
+ (fprintf(stderr, (s), (p)), fflush(stderr))
+
+
+
+
+
+/*
+** {==================================================================
+** Compatibility with previous versions
+** ===================================================================
+*/
+
+/*
+@@ LUA_COMPAT_ALL controls all compatibility options.
+** You can define it to get all options, or change specific options
+** to fit your specific needs.
+*/
+#if defined(LUA_COMPAT_ALL) /* { */
+
+/*
+@@ LUA_COMPAT_UNPACK controls the presence of global 'unpack'.
+** You can replace it with 'table.unpack'.
+*/
+#define LUA_COMPAT_UNPACK
+
+/*
+@@ LUA_COMPAT_LOADERS controls the presence of table 'package.loaders'.
+** You can replace it with 'package.searchers'.
+*/
+#define LUA_COMPAT_LOADERS
+
+/*
+@@ macro 'lua_cpcall' emulates deprecated function lua_cpcall.
+** You can call your C function directly (with light C functions).
+*/
+#define lua_cpcall(L,f,u) \
+ (lua_pushcfunction(L, (f)), \
+ lua_pushlightuserdata(L,(u)), \
+ lua_pcall(L,1,0,0))
+
+
+/*
+@@ LUA_COMPAT_LOG10 defines the function 'log10' in the math library.
+** You can rewrite 'log10(x)' as 'log(x, 10)'.
+*/
+#define LUA_COMPAT_LOG10
+
+/*
+@@ LUA_COMPAT_LOADSTRING defines the function 'loadstring' in the base
+** library. You can rewrite 'loadstring(s)' as 'load(s)'.
+*/
+#define LUA_COMPAT_LOADSTRING
+
+/*
+@@ LUA_COMPAT_MAXN defines the function 'maxn' in the table library.
+*/
+#define LUA_COMPAT_MAXN
+
+/*
+@@ The following macros supply trivial compatibility for some
+** changes in the API. The macros themselves document how to
+** change your code to avoid using them.
+*/
+#define lua_strlen(L,i) lua_rawlen(L, (i))
+
+#define lua_objlen(L,i) lua_rawlen(L, (i))
+
+#define lua_equal(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPEQ)
+#define lua_lessthan(L,idx1,idx2) lua_compare(L,(idx1),(idx2),LUA_OPLT)
+
+/*
+@@ LUA_COMPAT_MODULE controls compatibility with previous
+** module functions 'module' (Lua) and 'luaL_register' (C).
+*/
+#define LUA_COMPAT_MODULE
+
+#endif /* } */
+
+/* }================================================================== */
+
+
+
+/*
+@@ LUAI_BITSINT defines the number of bits in an int.
+** CHANGE here if Lua cannot automatically detect the number of bits of
+** your machine. Probably you do not need to change this.
+*/
+/* avoid overflows in comparison */
+#if INT_MAX-20 < 32760 /* { */
+#define LUAI_BITSINT 16
+#elif INT_MAX > 2147483640L /* }{ */
+/* int has at least 32 bits */
+#define LUAI_BITSINT 32
+#else /* }{ */
+#error "you must define LUA_BITSINT with number of bits in an integer"
+#endif /* } */
+
+
+/*
+@@ LUA_INT32 is an signed integer with exactly 32 bits.
+@@ LUAI_UMEM is an unsigned integer big enough to count the total
+@* memory used by Lua.
+@@ LUAI_MEM is a signed integer big enough to count the total memory
+@* used by Lua.
+** CHANGE here if for some weird reason the default definitions are not
+** good enough for your machine. Probably you do not need to change
+** this.
+*/
+#if LUAI_BITSINT >= 32 /* { */
+#define LUA_INT32 int
+#define LUAI_UMEM size_t
+#define LUAI_MEM ptrdiff_t
+#else /* }{ */
+/* 16-bit ints */
+#define LUA_INT32 long
+#define LUAI_UMEM unsigned long
+#define LUAI_MEM long
+#endif /* } */
+
+
+/*
+@@ LUAI_MAXSTACK limits the size of the Lua stack.
+** CHANGE it if you need a different limit. This limit is arbitrary;
+** its only purpose is to stop Lua to consume unlimited stack
+** space (and to reserve some numbers for pseudo-indices).
+*/
+#if LUAI_BITSINT >= 32
+#define LUAI_MAXSTACK 1000000
+#else
+#define LUAI_MAXSTACK 15000
+#endif
+
+/* reserve some space for error handling */
+#define LUAI_FIRSTPSEUDOIDX (-LUAI_MAXSTACK - 1000)
+
+
+
+
+/*
+@@ LUAL_BUFFERSIZE is the buffer size used by the lauxlib buffer system.
+** CHANGE it if it uses too much C-stack space.
+*/
+#define LUAL_BUFFERSIZE BUFSIZ
+
+
+
+
+/*
+** {==================================================================
+@@ LUA_NUMBER is the type of numbers in Lua.
+** CHANGE the following definitions only if you want to build Lua
+** with a number type different from double. You may also need to
+** change lua_number2int & lua_number2integer.
+** ===================================================================
+*/
+
+#define LUA_NUMBER_DOUBLE
+#define LUA_NUMBER double
+
+/*
+@@ LUAI_UACNUMBER is the result of an 'usual argument conversion'
+@* over a number.
+*/
+#define LUAI_UACNUMBER double
+
+
+/*
+@@ LUA_NUMBER_SCAN is the format for reading numbers.
+@@ LUA_NUMBER_FMT is the format for writing numbers.
+@@ lua_number2str converts a number to a string.
+@@ LUAI_MAXNUMBER2STR is maximum size of previous conversion.
+*/
+#define LUA_NUMBER_SCAN "%lf"
+#define LUA_NUMBER_FMT "%.14g"
+#define lua_number2str(s,n) sprintf((s), LUA_NUMBER_FMT, (n))
+#define LUAI_MAXNUMBER2STR 32 /* 16 digits, sign, point, and \0 */
+
+
+/*
+@@ lua_str2number converts a decimal numeric string to a number.
+@@ lua_strx2number converts an hexadecimal numeric string to a number.
+** In C99, 'strtod' do both conversions. C89, however, has no function
+** to convert floating hexadecimal strings to numbers. For these
+** systems, you can leave 'lua_strx2number' undefined and Lua will
+** provide its own implementation.
+*/
+#define lua_str2number(s,p) strtod((s), (p))
+
+#if defined(LUA_USE_STRTODHEX)
+#define lua_strx2number(s,p) strtod((s), (p))
+#endif
+
+
+/*
+@@ The luai_num* macros define the primitive operations over numbers.
+*/
+
+/* the following operations need the math library */
+#if defined(lobject_c) || defined(lvm_c)
+#include <math.h>
+#define luai_nummod(L,a,b) ((a) - floor((a)/(b))*(b))
+#define luai_numpow(L,a,b) (pow(a,b))
+#endif
+
+/* these are quite standard operations */
+#if defined(LUA_CORE)
+#define luai_numadd(L,a,b) ((a)+(b))
+#define luai_numsub(L,a,b) ((a)-(b))
+#define luai_nummul(L,a,b) ((a)*(b))
+#define luai_numdiv(L,a,b) ((a)/(b))
+#define luai_numunm(L,a) (-(a))
+#define luai_numeq(a,b) ((a)==(b))
+#define luai_numlt(L,a,b) ((a)<(b))
+#define luai_numle(L,a,b) ((a)<=(b))
+#define luai_numisnan(L,a) (!luai_numeq((a), (a)))
+#endif
+
+
+
+/*
+@@ LUA_INTEGER is the integral type used by lua_pushinteger/lua_tointeger.
+** CHANGE that if ptrdiff_t is not adequate on your machine. (On most
+** machines, ptrdiff_t gives a good choice between int or long.)
+*/
+#define LUA_INTEGER ptrdiff_t
+
+/*
+@@ LUA_UNSIGNED is the integral type used by lua_pushunsigned/lua_tounsigned.
+** It must have at least 32 bits.
+*/
+#define LUA_UNSIGNED unsigned LUA_INT32
+
+
+#if defined(LUA_CORE) /* { */
+
+#if defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) /* { */
+
+/* On a Microsoft compiler on a Pentium, use assembler to avoid clashes
+ with a DirectX idiosyncrasy */
+#if defined(LUA_WIN) && defined(_MSC_VER) && defined(_M_IX86) /* { */
+
+#define MS_ASMTRICK
+
+#else /* }{ */
+/* the next definition uses a trick that should work on any machine
+ using IEEE754 with a 32-bit integer type */
+
+#define LUA_IEEE754TRICK
+
+/*
+@@ LUA_IEEEENDIAN is the endianness of doubles in your machine
+** (0 for little endian, 1 for big endian); if not defined, Lua will
+** check it dynamically.
+*/
+/* check for known architectures */
+#if defined(__i386__) || defined(__i386) || defined(__X86__) || \
+ defined (__x86_64)
+#define LUA_IEEEENDIAN 0
+#elif defined(__POWERPC__) || defined(__ppc__)
+#define LUA_IEEEENDIAN 1
+#endif
+
+#endif /* } */
+
+#endif /* } */
+
+#endif /* } */
+
+/* }================================================================== */
+
+
+/*
+@@ LUA_NANTRICK_LE/LUA_NANTRICK_BE controls the use of a trick to
+** pack all types into a single double value, using NaN values to
+** represent non-number values. The trick only works on 32-bit machines
+** (ints and pointers are 32-bit values) with numbers represented as
+** IEEE 754-2008 doubles with conventional endianess (12345678 or
+** 87654321), in CPUs that do not produce signaling NaN values (all NaNs
+** are quiet).
+*/
+#if defined(LUA_CORE) && \
+ defined(LUA_NUMBER_DOUBLE) && !defined(LUA_ANSI) /* { */
+
+/* little-endian architectures that satisfy those conditions */
+#if defined(__i386__) || defined(__i386) || defined(__X86__) || \
+ defined(_M_IX86)
+
+#define LUA_NANTRICK_LE
+
+#endif
+
+#endif /* } */
+
+
+
+
+/* =================================================================== */
+
+/*
+** Local configuration. You can use this space to add your redefinitions
+** without modifying the main part of the file.
+*/
+
+
+
+#endif
+
55 lua52/include/lualib.h
@@ -0,0 +1,55 @@
+/*
+** $Id: lualib.h,v 1.43 2011/12/08 12:11:37 roberto Exp $
+** Lua standard libraries
+** See Copyright Notice in lua.h
+*/
+
+
+#ifndef lualib_h
+#define lualib_h
+
+#include "lua.h"
+
+
+
+LUAMOD_API int (luaopen_base) (lua_State *L);
+
+#define LUA_COLIBNAME "coroutine"
+LUAMOD_API int (luaopen_coroutine) (lua_State *L);
+
+#define LUA_TABLIBNAME "table"
+LUAMOD_API int (luaopen_table) (lua_State *L);
+
+#define LUA_IOLIBNAME "io"
+LUAMOD_API int (luaopen_io) (lua_State *L);
+
+#define LUA_OSLIBNAME "os"
+LUAMOD_API int (luaopen_os) (lua_State *L);
+
+#define LUA_STRLIBNAME "string"
+LUAMOD_API int (luaopen_string) (lua_State *L);
+
+#define LUA_BITLIBNAME "bit32"
+LUAMOD_API int (luaopen_bit32) (lua_State *L);
+
+#define LUA_MATHLIBNAME "math"
+LUAMOD_API int (luaopen_math) (lua_State *L);
+
+#define LUA_DBLIBNAME "debug"
+LUAMOD_API int (luaopen_debug) (lua_State *L);
+
+#define LUA_LOADLIBNAME "package"
+LUAMOD_API int (luaopen_package) (lua_State *L);
+
+
+/* open all previous libraries */
+LUALIB_API void (luaL_openlibs) (lua_State *L);
+
+
+
+#if !defined(lua_assert)
+#define lua_assert(x) ((void)0)
+#endif
+
+
+#endif
BIN  lua52/liblua52.a
Binary file not shown
BIN  lua52/lua52.lib
Binary file not shown
BIN  lua_autoc.dll
Binary file not shown
159 src/lau_autostruct.c
@@ -0,0 +1,159 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "lua.h"
+#include "lua_autohashtable.h"
+#include "lua_autotype.h"
+#include "lua_autostack.h"
+
+#include "lua_autostruct.h"
+
+typedef struct {
+ lua_autotype type;
+ int offset;
+ char* name;
+} struct_member_entry;
+
+typedef struct {
+ lua_autotype type_id;
+ int num_members;
+ int num_reserved_members;
+ struct_member_entry** members;
+} struct_entry;
+
+static lua_autohashtable* struct_table;
+
+void lua_autostruct_open(void) {
+ struct_table = lua_autohashtable_new(256);
+}
+
+static void struct_entry_delete(struct_entry* se) {
+
+ for(int i = 0; i < se->num_members; i++) {
+ free(se->members[i]->name);
+ free(se->members[i]);
+ }
+
+ free(se->members);
+ free(se);
+
+}
+
+void lua_autostruct_close(void) {
+
+ lua_autohashtable_map(struct_table, (void(*)(void*))struct_entry_delete);
+ lua_autohashtable_delete(struct_table);
+
+}
+
+void lua_autostruct_push_member_typeid(lua_State* L, lua_autotype type, void* cstruct, char* member) {
+
+ struct_entry* se = lua_autohashtable_get(struct_table, lua_autotype_name(type));
+ if (se != NULL) {
+
+ for(int j = 0; j < se->num_members; j++) {
+ if (strcmp(se->members[j]->name, member) == 0) {
+ struct_member_entry* sme = se->members[j];
+ return lua_autopush_typeid(L, sme->type, cstruct+sme->offset);
+ }
+ }
+
+ lua_pushfstring(L, "lua_autostruct: Member '%s' not registered for struct '%s'!", member, lua_autotype_name(type));
+ lua_error(L);
+ }
+
+ lua_pushfstring(L, "lua_autostruct: Struct '%s' not registered!", lua_autotype_name(type));
+ lua_error(L);
+}
+
+void lua_autostruct_pop_member_typeid(lua_State* L, lua_autotype type, void* cstruct, char* member) {
+
+ struct_entry* se = lua_autohashtable_get(struct_table, lua_autotype_name(type));
+ if (se != NULL) {
+
+ for(int j = 0; j < se->num_members; j++) {
+ if (strcmp(se->members[j]->name, member) == 0) {
+ struct_member_entry* sme = se->members[j];
+ return lua_autopop_typeid(L, sme->type, cstruct+sme->offset);
+ }
+ }
+
+ lua_pushfstring(L, "lua_autostruct: Member '%s' not registered for struct '%s'!", member, lua_autotype_name(type));
+ lua_error(L);
+ }
+
+ lua_pushfstring(L, "lua_autostruct: Struct '%s' not registered!", lua_autotype_name(type));
+ lua_error(L);
+}
+
+int lua_autostruct_has_member_typeid(lua_State* L, lua_autotype type, char* member) {
+
+ struct_entry* se = lua_autohashtable_get(struct_table, lua_autotype_name(type));
+ if (se != NULL) {
+
+ for(int j = 0; j < se->num_members; j++) {
+ if (strcmp(se->members[j]->name, member) == 0) {
+ return 1;
+ }
+ }
+
+ return 0;
+ }
+
+ lua_pushfstring(L, "lua_autostruct: Struct '%s' not registered!", lua_autotype_name(type));
+ lua_error(L);
+ return 0;
+}
+
+void lua_autostruct_add_typid(lua_State* L, lua_autotype type) {
+
+ struct_entry* se = malloc(sizeof(struct_entry));
+ se->type_id = type;
+ se->num_members = 0;
+ se->num_reserved_members = 32;
+ se->members = malloc(sizeof(struct_member_entry*) * se->num_reserved_members);
+
+ lua_autohashtable_set(struct_table, lua_autotype_name(type), se);
+
+}
+
+void lua_autostruct_addmember_typeid(lua_State* L, lua_autotype type, char* member, lua_autotype member_type, int offset) {
+
+ struct_entry* se = lua_autohashtable_get(struct_table, lua_autotype_name(type));
+ if (se != NULL) {
+
+ if (se->num_members >= se->num_reserved_members) {
+ se->num_reserved_members += 32;
+ se->members = realloc(se->members, sizeof(struct_member_entry*) * se->num_reserved_members);
+ }
+
+ struct_member_entry* sme = malloc(sizeof(struct_member_entry));
+ sme->type = member_type;
+ sme->offset = offset;
+ sme->name = malloc(strlen(member) + 1);
+ strcpy(sme->name, member);
+
+ se->members[se->num_members] = sme;
+ se->num_members++;
+ return;
+
+ }
+
+ lua_pushfstring(L, "lua_autostruct: Struct '%s' not registered!", lua_autotype_name(type));
+ lua_error(L);
+}
+
+int lua_autostruct_added_typeid(lua_State* L, lua_autotype type) {
+
+ struct_entry* se = lua_autohashtable_get(struct_table, lua_autotype_name(type));
+ if (se == NULL) { return 0; } else { return 1; }
+
+}
+
+void lua_autostruct_push_typeid(lua_State* L, lua_autotype type, void* c_in) {
+ return;
+}
+
+void lua_autostruct_pop_typeid(lua_State* L, lua_autotype type, void* c_out) {
+ return;
+}
15 src/lua_autoc.c
@@ -0,0 +1,15 @@
+#include "lua_autoc.h"
+
+void lua_autoc_open(void) {
+ lua_autotype_open();
+ lua_autostack_open();
+ lua_autostruct_open();
+ lua_autocall_open();
+}
+
+void lua_autoc_close(void) {
+ lua_autocall_close();
+ lua_autostruct_close();
+ lua_autostack_close();
+ lua_autotype_close();
+}
136 src/lua_autocall.c
@@ -0,0 +1,136 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "lua_autohashtable.h"
+#include "lua_autostack.h"
+
+#include "lua_autocall.h"
+
+#define MAX_ARG_NUM 10
+
+typedef struct {
+ char* name;
+ lua_autofunc ac_func;
+ void* func;
+ lua_autotype type_id;
+ int num_args;
+ lua_autotype arg_types[MAX_ARG_NUM];
+} func_entry;
+
+static lua_autohashtable* func_table;
+
+void lua_autocall_open(void) {
+ func_table = lua_autohashtable_new(1024);
+}
+
+static void func_entry_delete(func_entry* fe) {
+ free(fe->name);
+ free(fe);
+}
+
+void lua_autocall_close(void) {
+ lua_autohashtable_map(func_table, (void(*)(void*))func_entry_delete);
+ lua_autohashtable_delete(func_table);
+}
+
+static int total_arg_size(func_entry* fe) {
+
+ int total = 0;
+ for(int i = 0; i < fe->num_args; i++) {
+ total += lua_autotype_size(fe->arg_types[i]);
+ }
+ return total;
+
+}
+
+#define ret_stack_size 128
+#define arg_stack_size 1024
+
+static char ret_stack[ret_stack_size];
+static void* ret_stack_ptr = ret_stack;
+
+static char arg_stack[arg_stack_size];
+static void* arg_stack_ptr = arg_stack;
+
+static int ret_stack_space() {
+ return (void*)ret_stack - ret_stack_ptr + ret_stack_size;
+}
+
+static int arg_stack_space() {
+ return (void*)arg_stack - arg_stack_ptr + arg_stack_size;
+}
+
+static void lua_autocall_entry(lua_State* L, func_entry* fe) {
+
+ int ret_data_size = lua_autotype_size(fe->type_id);
+ int arg_data_size = total_arg_size(fe);
+
+ int ret_using_heap = 0; int arg_using_heap = 0;
+ void* ret_data = ret_stack_ptr;
+ void* arg_data = arg_stack_ptr;
+
+ if (ret_data_size > ret_stack_space()) {
+ ret_using_heap = 1; ret_data = malloc(ret_data_size);
+ }
+
+ if (arg_data_size > arg_stack_space()) {
+ arg_using_heap = 1; arg_data = malloc(arg_data_size);
+ }
+
+ for(int j = 0; j < fe->num_args; j++) {
+ lua_autopop_typeid(L, fe->arg_types[j], arg_data);
+ arg_data += lua_autotype_size(fe->arg_types[j]);
+ }
+
+ ret_data += ret_data_size;
+
+ /* If not using heap update stack pointers */
+ if (!ret_using_heap) { ret_stack_ptr = ret_data; }
+ if (!arg_using_heap) { arg_stack_ptr = arg_data; }
+
+ arg_data -= arg_data_size;
+ ret_data -= ret_data_size;
+
+ fe->ac_func(ret_data, arg_data);
+ lua_autopush_typeid(L, fe->type_id, ret_data);
+
+ /* Either free heap data or reduce stack pointers */
+ if (ret_using_heap) { free(ret_data); } else { ret_stack_ptr -= ret_data_size; }
+ if (arg_using_heap) { free(arg_data); } else { arg_stack_ptr -= arg_data_size; }
+
+}
+
+void lua_autocall_name(lua_State* L, char* func_name) {
+
+ func_entry* fe = lua_autohashtable_get(func_table, func_name);
+ if (fe != NULL) {
+ return lua_autocall_entry(L, fe);
+ }
+
+ lua_pushfstring(L, "lua_autocall: Function '%s' is not registered!", func_name);
+ lua_error(L);
+}
+
+void lua_autofunc_add_typeid(lua_State* L, lua_autofunc ac_func, char* name, lua_autotype ret_tid, int num_args, ...) {
+
+ if (num_args >= MAX_ARG_NUM) {
+ lua_pushfstring(L, "lua_autocall: Function has %i arguments - maximum supported is %i!", num_args, MAX_ARG_NUM);
+ lua_error(L);
+ }
+
+ func_entry* fe = malloc(sizeof(func_entry));
+ fe->name = malloc(strlen(name) + 1);
+ strcpy(fe->name, name);
+ fe->ac_func = ac_func;
+ fe->type_id = ret_tid;
+ fe->num_args = num_args;
+
+ va_list argl;
+ va_start(argl, num_args);
+ for(int i = 0; i < num_args; i++) {
+ fe->arg_types[i] = va_arg(argl, lua_autotype);
+ }
+
+ lua_autohashtable_set(func_table, name, fe);
+
+}
136 src/lua_autohashtable.c
@@ -0,0 +1,136 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "lua_autohashtable.h"
+
+static int hash(char* s, int size) {
+ int h = 0;
+ while (*s) h = h * 101 + *s++;
+ return abs(h) % size;
+}
+
+static lua_autobucket* lua_autobucket_new(char* string, void* item) {
+
+ lua_autobucket* b = malloc(sizeof(lua_autobucket));
+ b->item = item;
+
+ b->string = malloc(strlen(string) + 1);
+ strcpy(b->string, string);
+
+ b->next = NULL;
+ b->prev = NULL;
+
+ return b;
+}
+
+static void lua_autobucket_delete(lua_autobucket* b) {
+ if(b->next != NULL) { lua_autobucket_delete(b->next); }
+ free(b->string);
+ free(b);
+}
+
+lua_autohashtable* lua_autohashtable_new(int size) {
+
+ lua_autohashtable* ht = malloc(sizeof(lua_autohashtable));
+
+ ht->size = size;
+ ht->buckets = malloc( sizeof(lua_autobucket*) * ht->size );
+
+ for(int i = 0; i < size; i++) { ht->buckets[i] = NULL; }
+
+ return ht;
+}
+
+void lua_autohashtable_delete(lua_autohashtable* ht) {
+ for(int i=0; i< ht->size; i++) {
+ if (ht->buckets[i] != NULL) {
+ lua_autobucket_delete(ht->buckets[i]);
+ }
+ }
+ free(ht->buckets);
+ free(ht);
+}
+
+int lua_autohashtable_contains(lua_autohashtable* ht, char* string) {
+
+ if (lua_autohashtable_get(ht, string) == NULL) {
+ return 0;
+ } else {
+ return 1;
+ }
+
+}
+
+void* lua_autohashtable_get(lua_autohashtable* ht, char* string) {
+
+ int index = hash(string, ht->size);
+ lua_autobucket* b = ht->buckets[index];
+
+ if (b == NULL) {
+ return NULL;
+ }
+
+ while(1){
+ if (strcmp(b->string, string) == 0){ return b->item; }
+ if (b->next == NULL) { return NULL; }
+ else {b = b->next; }
+ }
+
+ return NULL;
+
+}
+
+void lua_autohashtable_set(lua_autohashtable* ht, char* string, void* item) {
+
+ int index = hash(string, ht->size);
+ lua_autobucket* b = ht->buckets[index];
+
+ if (b == NULL) {
+ lua_autobucket* new_bucket = lua_autobucket_new(string, item);
+ ht->buckets[index] = new_bucket;
+ return;
+ }
+
+ while(1) {
+
+ if( strcmp(b->string, string) == 0) {
+ b->item = item;
+ return;
+ }
+
+ if( b->next == NULL) {
+ lua_autobucket* new_bucket = lua_autobucket_new(string, item);
+ b->next = new_bucket;
+ new_bucket->prev = b;
+ return;
+ }
+
+ b = b->next;
+ }
+
+}
+
+char* lua_autohashtable_find(lua_autohashtable* ht, void* item) {
+
+ for(int i = 0; i < ht->size; i++) {
+ lua_autobucket* b = ht->buckets[i];
+ while (b != NULL) {
+ if (b->item == item) { return b->string; }
+ b = b->next;
+ }
+ }
+
+ return NULL;
+}
+
+void lua_autohashtable_map(lua_autohashtable* ht, void (*func)(void*)) {
+
+ for(int i = 0; i < ht->size; i++) {
+ lua_autobucket* b = ht->buckets[i];
+ while (b != NULL) {
+ func(b->item);
+ b = b->next;
+ }
+ }
+}
+
244 src/lua_autostack.c
@@ -0,0 +1,244 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include "lua.h"
+
+#include "lua_autostruct.h"
+#include "lua_autohashtable.h"
+
+#include "lua_autostack.h"
+
+static lua_autohashtable* push_table;
+static lua_autohashtable* pop_table;
+
+void lua_autostack_open(void) {
+
+ push_table = lua_autohashtable_new(256);
+ pop_table = lua_autohashtable_new(256);
+
+ lua_autostack_func(char, lua_autopush_prim_char, lua_autopop_prim_char);
+ lua_autostack_func(signed char, lua_autopush_prim_signed_char, lua_autopop_prim_signed_char);
+ lua_autostack_func(unsigned char, lua_autopush_prim_unsigned_char, lua_autopop_prim_unsigned_char);
+ lua_autostack_func(short, lua_autopush_prim_short, lua_autopop_prim_short);
+ lua_autostack_func(unsigned short, lua_autopush_prim_unsigned_short, lua_autopop_prim_unsigned_short);
+ lua_autostack_func(int, lua_autopush_prim_int, lua_autopop_prim_int);
+ lua_autostack_func(unsigned int, lua_autopush_prim_unsigned_int, lua_autopop_prim_unsigned_int);
+ lua_autostack_func(long, lua_autopush_prim_long, lua_autopop_prim_long);
+ lua_autostack_func(unsigned long, lua_autopush_prim_unsigned_long, lua_autopop_prim_unsigned_long);
+ lua_autostack_func(long long, lua_autopush_prim_long_long, lua_autopop_prim_long_long);
+ lua_autostack_func(unsigned long long, lua_autopush_prim_unsigned_long_long, lua_autopop_prim_unsigned_long_long);
+ lua_autostack_func(float, lua_autopush_prim_float, lua_autopop_prim_float);
+ lua_autostack_func(double, lua_autopush_prim_double, lua_autopop_prim_double);
+ lua_autostack_func(long double, lua_autopush_prim_long_double, lua_autopop_prim_long_double);
+
+ lua_autostack_func(char*, lua_autopush_prim_char_ptr, lua_autopop_prim_char_ptr);
+ lua_autostack_func(const char*, lua_autopush_prim_const_char_ptr, lua_autopop_prim_const_char_ptr);
+
+ lua_autostack_push_func(void, lua_autopush_prim_void);
+
+}
+
+void lua_autostack_close(void) {
+
+ lua_autohashtable_delete(push_table);
+ lua_autohashtable_delete(pop_table);
+
+}
+
+void lua_autopush_typeid(lua_State* L, lua_autotype type_id, void* c_in) {
+
+ lua_autopush_func push_func = lua_autohashtable_get(push_table, lua_autotype_name(type_id));
+ if (push_func != NULL) {
+ return push_func(L, c_in);
+ }
+
+ if (lua_autostruct_added_typeid(L, type_id)) {
+ return lua_autostruct_push_typeid(L, type_id, c_in);
+ }
+
+ lua_pushfstring(L, "lua_autostack: conversion to lua object from type '%s' not registered!", lua_autotype_name(type_id));
+ lua_error(L);
+}
+
+void lua_autopop_typeid(lua_State* L, lua_autotype type_id, void* c_out) {
+
+ lua_autopop_func pop_func = lua_autohashtable_get(pop_table, lua_autotype_name(type_id));
+ if (pop_func != NULL) {
+ return pop_func(L, c_out);
+ }
+
+ if (lua_autostruct_added_typeid(L, type_id)) {
+ return lua_autostruct_pop_typeid(L, type_id, c_out);
+ }
+
+ lua_pushfstring(L, "lua_autostack: conversion from lua object from type '%s' not registered!", lua_autotype_name(type_id));
+ lua_error(L);
+}
+
+void lua_autostack_func_typeid(lua_autotype type_id, lua_autopush_func push_func, lua_autopop_func pop_func) {
+
+ lua_autohashtable_set(push_table, lua_autotype_name(type_id), push_func);
+ lua_autohashtable_set(pop_table, lua_autotype_name(type_id), pop_func);
+
+}
+
+void lua_autostack_push_func_typeid(lua_autotype type_id, lua_autopush_func func) {
+ lua_autohashtable_set(push_table, lua_autotype_name(type_id), func);
+}
+
+void lua_autostack_pop_func_typeid(lua_autotype type_id, lua_autopop_func func) {
+ lua_autohashtable_set(pop_table, lua_autotype_name(type_id), func);
+}
+
+void lua_autopush_prim_char(lua_State* L, void* c_in) {
+ lua_pushinteger(L, *(char*)c_in);
+}
+
+void lua_autopop_prim_char(lua_State* L, void* c_out) {
+ *(char*)c_out = lua_tointeger(L, -1);
+ lua_pop(L, 1);
+}
+
+void lua_autopush_prim_signed_char(lua_State* L, void* c_in) {
+ lua_pushinteger(L, *(signed char*)c_in);
+}
+
+void lua_autopop_prim_signed_char(lua_State* L, void* c_out) {
+ *(signed char*)c_out = lua_tointeger(L, -1);
+ lua_pop(L, 1);
+}
+
+void lua_autopush_prim_unsigned_char(lua_State* L, void* c_in) {
+ lua_pushinteger(L, *(unsigned char*)c_in);
+}
+
+void lua_autopop_prim_unsigned_char(lua_State* L, void* c_out) {
+ *(unsigned char*)c_out = lua_tointeger(L, -1);
+ lua_pop(L, 1);
+}
+
+void lua_autopush_prim_short(lua_State* L, void* c_in) {
+ lua_pushinteger(L, *(short*)c_in);
+}
+
+void lua_autopop_prim_short(lua_State* L, void* c_out) {
+ *(short*)c_out = lua_tointeger(L, -1);
+ lua_pop(L, 1);
+}
+
+void lua_autopush_prim_unsigned_short(lua_State* L, void* c_in) {
+ lua_pushinteger(L, *(unsigned short*)c_in);
+}
+
+void lua_autopop_prim_unsigned_short(lua_State* L, void* c_out) {
+ *(unsigned short*)c_out = lua_tointeger(L, -1);
+ lua_pop(L, 1);
+}
+
+void lua_autopush_prim_int(lua_State* L, void* c_in) {
+ lua_pushinteger(L, *(int*)c_in);
+}
+
+void lua_autopop_prim_int(lua_State* L, void* c_out) {
+ *(int*)c_out = lua_tointeger(L, -1);
+ lua_pop(L, 1);
+}
+
+void lua_autopush_prim_unsigned_int(lua_State* L, void* c_in) {
+ lua_pushinteger(L, *(unsigned int*)c_in);
+}
+
+void lua_autopop_prim_unsigned_int(lua_State* L, void* c_out) {
+ *(unsigned int*)c_out = lua_tointeger(L, -1);
+ lua_pop(L, 1);
+}
+
+void lua_autopush_prim_long(lua_State* L, void* c_in) {
+ lua_pushinteger(L, *(long*)c_in);
+}
+
+void lua_autopop_prim_long(lua_State* L, void* c_out) {
+ *(long*)c_out = lua_tointeger(L, -1);
+ lua_pop(L, 1);
+}
+
+void lua_autopush_prim_unsigned_long(lua_State* L, void* c_in) {
+ lua_pushinteger(L, *(unsigned long*)c_in);
+}
+
+void lua_autopop_prim_unsigned_long(lua_State* L, void* c_out) {
+ *(unsigned long*)c_out = lua_tointeger(L, -1);
+ lua_pop(L, 1);
+}
+
+void lua_autopush_prim_long_long(lua_State* L, void* c_in) {
+ lua_pushinteger(L, *(long long*)c_in);
+}
+
+void lua_autopop_prim_long_long(lua_State* L, void* c_out) {
+ *(long long*)c_out = lua_tointeger(L, -1);
+ lua_pop(L, 1);
+}
+
+void lua_autopush_prim_unsigned_long_long(lua_State* L, void* c_in) {
+ lua_pushinteger(L, *(unsigned long long*)c_in);
+}
+
+void lua_autopop_prim_unsigned_long_long(lua_State* L, void* c_out) {
+ *(unsigned long long*)c_out = lua_tointeger(L, -1);
+ lua_pop(L, 1);
+}
+
+void lua_autopush_prim_float(lua_State* L, void* c_in) {
+ lua_pushnumber(L, *(float*)c_in);
+}
+
+void lua_autopop_prim_float(lua_State* L, void* c_out) {
+ *(float*)c_out = lua_tonumber(L, -1);
+ lua_pop(L, 1);
+}
+
+void lua_autopush_prim_double(lua_State* L, void* c_in) {
+ lua_pushnumber(L, *(double*)c_in);
+}
+
+void lua_autopop_prim_double(lua_State* L, void* c_out) {
+ *(double*)c_out = lua_tonumber(L, -1);
+ lua_pop(L, 1);
+}
+
+void lua_autopush_prim_long_double(lua_State* L, void* c_in) {
+ lua_pushnumber(L, *(long double*)c_in);
+}
+
+void lua_autopop_prim_long_double(lua_State* L, void* c_out) {
+ *(long double*)c_out = lua_tonumber(L, -1);
+ lua_pop(L, 1);
+}
+
+void lua_autopush_prim_char_ptr(lua_State* L, void* c_in) {
+ lua_pushstring(L, *(char**)c_in);
+}
+
+void lua_autopop_prim_char_ptr(lua_State* L, void* c_out) {
+ const char* ref = lua_tostring(L, -1);
+ *(char**)c_out = malloc(strlen(ref) + 1);
+ strcpy(*(char**)c_out, ref);
+ lua_pop(L, 1);
+}
+
+void lua_autopush_prim_const_char_ptr(lua_State* L, void* c_in) {
+ lua_pushstring(L, *(const char**)c_in);
+}
+
+void lua_autopop_prim_const_char_ptr(lua_State* L, void* c_out) {
+ const char* ref = lua_tostring(L, -1);
+ *(char**)c_out = malloc(strlen(ref) + 1);
+ strcpy(*(char**)c_out, ref);
+ lua_pop(L, 1);
+}
+
+void lua_autopush_prim_void(lua_State* L, void* c_in) {
+ lua_pushnil(L);
+}
+
69 src/lua_autotype.c
<
@@ -0,0 +1,69 @@
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "lua_autotype.h"
+
+typedef char* type_name;
+typedef int type_size;
+
+static type_name* type_names;
+static type_size* type_sizes;
+
+static int num_types = 0;
+static int num_reserved_types = 128;
+
+void lua_autotype_open(void) {
+
+ type_names = malloc(sizeof(type_name) * num_reserved_types);
+ type_sizes = malloc(sizeof(type_size) * num_reserved_types);
+}
+
+void lua_autotype_close(void) {
+
+ for(int i = 0; i < num_types; i++) {
+ free(type_names[i]);
+ }
+
+ free(type_names);
+ free(type_sizes);
+}
+
+lua_autotype lua_autotype_push(char* type, int size) {
+
+ for(int i = 0; i < num_types; i++) {
+ if (strcmp(type, type_names[i]) == 0) return i;
+ }
+
+ if (num_types >= num_reserved_types) {
+ num_reserved_types += 128;
+ type_names = realloc(type_names, sizeof(type_name) * num_reserved_types);
+ type_sizes = realloc(type_sizes, sizeof(type_size) * num_reserved_types);
+ }