改写 alien core使其可以适配lua5.3

时间：2014-11-15 17:06:56 阅读：164 评论：0 收藏：0 [点我收藏+]

/* Lua FFI using libffi */
/* Author: Fabio Mascarenhas */
/* License: MIT/X11 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#include "lua.h"
#include "lualib.h"
#include "lauxlib.h"
#include "ffi.h"

#ifdef WINDOWS
#include <windows.h>
#define ALLOCA _alloca
#else
#include <sys/mman.h>
#include <unistd.h>
# if !defined(MAP_ANONYMOUS) && defined(MAP_ANON)
# define MAP_ANONYMOUS MAP_ANON
# endif
#define ALLOCA alloca
#endif

#define BLOCKSIZE _pagesize

#define ALIEN_LIBRARY_META "alien_library"
#define ALIEN_FUNCTION_META "alien_function"
#define ALIEN_BUFFER_META "alien_buffer"
#define ALIEN_CALLBACK_META "alien_callback"

#ifndef uchar
#define uchar unsigned char
#endif

typedef enum {
AT_SHORT,
AT_INT,
AT_LONG,
AT_VOID,
AT_FLOAT,
AT_DOUBLE,
AT_CHAR,
AT_BYTE,
AT_STRING,
AT_PTR,
AT_REFINT,
AT_REFCHAR,
AT_REFDOUBLE,
AT_CALLBACK
} alien_Type;

typedef struct _alien_Library {
void *lib;
char *name;
} alien_Library;

typedef struct _alien_Function {
alien_Library *lib;
void *fn;
char *name;
alien_Type ret_type;
ffi_cif cif;
ffi_type *ffi_ret_type;
int nparams;
alien_Type *params;
ffi_type **ffi_params;
} alien_Function;

typedef struct _alien_Callback {
/* alien_Function part! */
alien_Library *lib;
void *fn;
char *name;
alien_Type ret_type;
ffi_cif cif;
ffi_type *ffi_ret_type;
int nparams;
alien_Type *params;
ffi_type **ffi_params;
/* callback part */
lua_State *L;
int fn_ref;
} alien_Callback;

typedef struct _alien_Wrap {
alien_Type tag;
union {
void *p;
int i;
} val;
} alien_Wrap;

typedef union _tagITEM {
ffi_closure closure;
union _tagITEM *next;
} ITEM;

static ITEM *free_list;
int _pagesize;

/* Information to compute strucuture access */

typedef struct { char c; char x; } s_char;
typedef struct { char c; short x; } s_short;
typedef struct { char c; int x; } s_int;
typedef struct { char c; long x; } s_long;
typedef struct { char c; float x; } s_float;
typedef struct { char c; double x; } s_double;
typedef struct { char c; char *x; } s_char_p;
typedef struct { char c; void *x; } s_void_p;

#define AT_CHAR_ALIGN (sizeof(s_char) - sizeof(char))
#define AT_SHORT_ALIGN (sizeof(s_short) - sizeof(short))
#define AT_INT_ALIGN (sizeof(s_int) - sizeof(int))
#define AT_LONG_ALIGN (sizeof(s_long) - sizeof(long))
#define AT_FLOAT_ALIGN (sizeof(s_float) - sizeof(float))
#define AT_DOUBLE_ALIGN (sizeof(s_double) - sizeof(double))
#define AT_CHAR_P_ALIGN (sizeof(s_char_p) - sizeof(char*))
#define AT_VOID_P_ALIGN (sizeof(s_void_p) - sizeof(void*))

static void more_core(void)
{
ITEM *item;
int count, i;

/* determine the pagesize */
#ifdef WINDOWS
if (!_pagesize) {
SYSTEM_INFO systeminfo;
GetSystemInfo(&systeminfo);
_pagesize = systeminfo.dwPageSize;
}
#else
if (!_pagesize) {
_pagesize = getpagesize();
}
#endif

/* calculate the number of nodes to allocate */
count = BLOCKSIZE / sizeof(ITEM);

/* allocate a memory block */
#ifdef WINDOWS
item = (ITEM *)VirtualAlloc(NULL,
count * sizeof(ITEM),
MEM_COMMIT,
PAGE_EXECUTE_READWRITE);
if (item == NULL)
return;
#else
item = (ITEM *)mmap(NULL,
count * sizeof(ITEM),
PROT_READ | PROT_WRITE | PROT_EXEC,
MAP_PRIVATE | MAP_ANONYMOUS,
-1,
0);
if (item == (void *)MAP_FAILED)
return;
#endif

/* put them into the free list */
for (i = 0; i < count; ++i) {
item->next = free_list;
free_list = item;
++item;
}
}

/******************************************************************/

/* put the item back into the free list */
void free_closure(void *p)
{
ITEM *item = (ITEM *)p;
item->next = free_list;
free_list = item;
}

/* return one item from the free list, allocating more if needed */
void *malloc_closure(void)
{
ITEM *item;
if (!free_list)
more_core();
if (!free_list)
return NULL;
item = free_list;
free_list = item->next;
return item;
}

#if defined(LINUX)
#define PLATFORM "linux"
#define USE_DLOPEN
#elif defined(BSD)
#define PLATFORM "bsd"
#define USE_DLOPEN
#elif defined(DARWIN)
#define PLATFORM "darwin"
#define USE_DLOPEN
#endif

#if defined(USE_DLOPEN)

#ifndef RTLD_DEFAULT
#define RTLD_DEFAULT 0
#endif

#include <dlfcn.h>

static void alien_unload (void *lib) {
if(lib && (lib != RTLD_DEFAULT))
dlclose(lib);
}

static void *alien_load (lua_State *L, const char *libname) {
void *lib;
lib = dlopen(libname, RTLD_NOW);
if(lib == NULL) lua_pushstring(L, dlerror());
return lib;
}

static void *alien_loadfunc (lua_State *L, void *lib, const char *sym) {
if(!lib) lib = RTLD_DEFAULT;
void *f = dlsym(lib, sym);
if (f == NULL) lua_pushstring(L, dlerror());
return f;
}

#elif defined(WINDOWS)

#define PLATFORM "windows"

static void pusherror (lua_State *L) {
int error = GetLastError();
char buffer[128];
if (FormatMessage(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, error, 0, buffer, sizeof(buffer), NULL))
lua_pushstring(L, buffer);
else
lua_pushfstring(L, "system error %d\n", error);
}

static void alien_unload (void *lib) {
if(lib)
FreeLibrary((HINSTANCE)lib);
}

static void *alien_load (lua_State *L, const char *libname) {
HINSTANCE lib = LoadLibrary(libname);
if (lib == NULL) pusherror(L);
return lib;
}

static void *alien_loadfunc (lua_State *L, void *lib, const char *sym) {
HINSTANCE module;
void *f;
module = (HINSTANCE)lib;
if(!module) module = GetModuleHandle(NULL);
f = (lua_CFunction)GetProcAddress(module, sym);
if (f == NULL) pusherror(L);
return f;
}

#else

#define DLMSG "dynamic libraries not enabled; check your Lua installation"

#define PLATFORM "unknown"

static void alien_unload (void *lib) {
(void)lib; /* to avoid warnings */
}

static void *alien_load (lua_State *L, const char *path) {
(void)path; /* to avoid warnings */
lua_pushliteral(L, DLMSG);
return NULL;
}

static void *alien_loadfunc (lua_State *L, void *lib, const char *sym) {
(void)lib; (void)sym; /* to avoid warnings */
lua_pushliteral(L, DLMSG);
return NULL;
}

#endif

#ifndef WINDOWS
#define FFI_STDCALL FFI_DEFAULT_ABI
#endif

#ifdef DARWIN
#define FFI_SYSV FFI_DEFAULT_ABI
#endif

static const ffi_abi ffi_abis[] = { FFI_DEFAULT_ABI, FFI_SYSV, FFI_STDCALL };
static const char *const ffi_abi_names[] = { "default", "cdecl", "stdcall", NULL };

static alien_Library *alien_checklibrary(lua_State *L, int index) {
void *ud = luaL_checkudata(L, index, ALIEN_LIBRARY_META);
luaL_argcheck(L, ud != NULL, index, "alien library expected");
return (alien_Library *)ud;
}

static alien_Function *alien_checkfunction(lua_State *L, int index) {
luaL_getmetatable(L, ALIEN_FUNCTION_META);
lua_getmetatable(L, index);
if(lua_rawequal(L, -1, -2)) {
lua_pop(L, 2);
return (alien_Function *)lua_touserdata(L, index);
}
lua_pop(L, 2);
luaL_getmetatable(L, ALIEN_CALLBACK_META);
lua_getmetatable(L, index);
if(lua_rawequal(L, -1, -2)) {
ffi_closure *ud = *((ffi_closure**)lua_touserdata(L, index));
lua_pop(L, 2);
return (alien_Function *)ud->user_data;
}
lua_pop(L, 2);
luaL_argcheck(L, 0, index, "alien function expected");
return NULL;
}

static ffi_closure *alien_checkcallback(lua_State *L, int index) {
void *ud = luaL_checkudata(L, index, ALIEN_CALLBACK_META);
luaL_argcheck(L, ud != NULL, index, "alien callback expected");
return *((ffi_closure **)ud);
}

static char *alien_checkbuffer(lua_State *L, int index) {
void *ud = luaL_checkudata(L, index, ALIEN_BUFFER_META);
luaL_argcheck(L, ud != NULL, index, "alien buffer expected");
return (char *)ud;
}

static int alien_get(lua_State *L) {
char *name;
const char *libname;
size_t len;
libname = luaL_checklstring(L, lua_gettop(L), &len);
name = (char*)malloc(sizeof(char) * (len + 1));
if(name) {
void *lib;
alien_Library *al;
strcpy(name, libname);
al = (alien_Library *)lua_newuserdata(L, sizeof(alien_Library));
if(!al) luaL_error(L, "out of memory!");
lib = alien_load(L, libname);
if(lib) {
luaL_getmetatable(L, ALIEN_LIBRARY_META);
lua_setmetatable(L, -2);
al->lib = lib;
al->name = name;
return 1;
} else {
lua_error(L);
}
} else {
luaL_error(L, "out of memory!");
}
return 0;
}

static int alien_makefunction(lua_State *L, void *lib, void *fn, char *name) {
alien_Function *af;
af = (alien_Function *)lua_newuserdata(L, sizeof(alien_Function));
if(af) {
luaL_getmetatable(L, ALIEN_FUNCTION_META);
lua_setmetatable(L, -2);
af->fn = fn;
af->name = name;
af->lib = lib;
af->nparams = 0;
af->ret_type = AT_VOID;
af->params = NULL;
} else luaL_error(L, "out of memory!");
return 1;
}

static int alien_library_get(lua_State *L) {
const char *funcname;
char *name;
size_t len;
funcname = luaL_checklstring(L, 2, &len);
lua_getfield(L, lua_upvalueindex(1), funcname);
if(!lua_isnil(L, -1)) return 1;
name = (char*)malloc(sizeof(char) * (len + 1));
if(name) {
alien_Library *al;
void *fn;
strcpy(name, funcname);
al = alien_checklibrary(L, 1);
fn = alien_loadfunc(L, al->lib, funcname);
if(fn) {
alien_makefunction(L, al, fn, name);
lua_pushvalue(L, -1);
lua_setfield(L, lua_upvalueindex(1), funcname);
return 1;
} else {
free(name);
lua_error(L);
}
} else {
luaL_error(L, "out of memory!");
}
return 0;
}

static int alien_function_new(lua_State *L) {
void *fn;
if(lua_isuserdata(L, 1)) {
void *fn = lua_touserdata(L, 1);
return alien_makefunction(L, NULL, fn, NULL);
} else luaL_error(L, "alien: not an userdata");
return 0;
}

static int alien_library_tostring(lua_State *L) {
alien_Library *al;
al = alien_checklibrary(L, 1);
lua_pushfstring(L, "alien library %s", (al->name ? al->name : "default"));
return 1;
}

static void alien_callback_call(ffi_cif *cif, void *resp, void **args, void *data) {
alien_Callback *ac;
int nparams, i;
void *ptr;
ac = (alien_Callback *)data;
lua_rawgeti(ac->L, LUA_REGISTRYINDEX, ac->fn_ref);
//lua_getref(ac->L, ac->fn_ref);
nparams = ac->nparams;
for(i = 0; i < nparams; i++) {
switch(ac->params[i]) {
case AT_BYTE: lua_pushnumber(ac->L, (signed char)*((int*)args[i])); break;
case AT_CHAR: lua_pushnumber(ac->L, (uchar)*((int*)args[i])); break;
case AT_SHORT: lua_pushnumber(ac->L, (short)*((int*)args[i])); break;
case AT_LONG:
lua_pushnumber(ac->L, (long)*((long*)args[i])); break;
case AT_INT: lua_pushnumber(ac->L, *((int*)args[i])); break;
case AT_FLOAT: lua_pushnumber(ac->L, (float)*((float*)args[i])); break;
case AT_DOUBLE: lua_pushnumber(ac->L, *((double*)args[i])); break;
case AT_STRING: lua_pushstring(ac->L, *((char**)args[i])); break;
case AT_REFINT:
lua_pushnumber(ac->L, **((int**)args[i])); break;
case AT_REFCHAR:
lua_pushnumber(ac->L, **((uchar**)args[i])); break;
case AT_REFDOUBLE:
lua_pushnumber(ac->L, **((double**)args[i])); break;
case AT_PTR:
ptr = *((void**)args[i]);
ptr ? lua_pushlightuserdata(ac->L, ptr) : lua_pushnil(ac->L);
break;
default: luaL_error(ac->L, "alien: unknown parameter type in callback");
}
}
lua_call(ac->L, nparams, 1);
switch(ac->ret_type) {
case AT_VOID: break;
case AT_SHORT: *((int*)resp) = (short)lua_tointeger(ac->L, -1); break;
case AT_LONG:
*((long*)resp) = (long)lua_tointeger(ac->L, -1); break;
case AT_INT: *((int*)resp) = (int)lua_tointeger(ac->L, -1); break;
case AT_CHAR: *((int*)resp) = (uchar)lua_tointeger(ac->L, -1); break;
case AT_BYTE: *((int*)resp) = (signed char)lua_tointeger(ac->L, -1); break;
case AT_FLOAT: *((float*)resp) = (float)lua_tonumber(ac->L, -1); break;
case AT_DOUBLE: *((double*)resp) = (double)lua_tonumber(ac->L, -1); break;
case AT_STRING:
if(lua_isuserdata(ac->L, -1))
*((char**)resp) = lua_touserdata(ac->L, -1);
else
*((const char**)resp) = lua_tostring(ac->L, -1);
break;
case AT_PTR:
if(lua_isstring(ac->L, -1))
*((void**)resp) = (void*)lua_tostring(ac->L, -1);
else
*((void**)resp) = lua_touserdata(ac->L, -1);
break;
default: luaL_error(ac->L, "alien: unknown return type in callback");
}
}

static int alien_callback_new(lua_State *L) {
int fn_ref;
alien_Callback *ac;
alien_Type at;
ffi_closure **ud;
int i, nparams;
ffi_status status;
ffi_abi abi;
static ffi_type *const ffitypes[] = {&ffi_type_void, &ffi_type_sint, &ffi_type_double,
&ffi_type_uchar, &ffi_type_pointer, &ffi_type_pointer,
&ffi_type_pointer, &ffi_type_pointer, &ffi_type_pointer,
&ffi_type_pointer, &ffi_type_sshort, &ffi_type_schar,
#ifndef WINDOWS
&ffi_type_slong,
#else
&ffi_type_sint,
#endif
&ffi_type_float};
static int const types[] = {AT_VOID, AT_INT, AT_DOUBLE, AT_CHAR, AT_STRING, AT_PTR, AT_REFINT,
AT_REFDOUBLE, AT_REFCHAR, AT_CALLBACK, AT_SHORT, AT_BYTE, AT_LONG,
AT_FLOAT};
static const char *const typenames[] =
{"void", "int", "double", "char", "string", "pointer",
"ref int", "ref double", "ref char", "callback",
"short", "byte", "long", "float", NULL};
luaL_checktype(L, 1, LUA_TFUNCTION);
if(lua_istable(L, 2)) {
//nparams = lua_objlen(L, 2);
nparams = lua_rawlen(L, 2);
} else {
nparams = lua_gettop(L) - 2;
}
ac = (alien_Callback *)malloc(sizeof(alien_Callback));
ud = (ffi_closure **)lua_newuserdata(L, sizeof(ffi_closure**));
if(ac != NULL && ud != NULL) {
int j;
*ud = malloc_closure();
if(*ud == NULL) { free(ac); luaL_error(L, "alien: cannot allocate callback"); }
ac->L = L;
if(lua_istable(L, 2)) {
lua_getfield(L, 2, "ret");
ac->ret_type = types[luaL_checkoption(L, -1, "int", typenames)];
ac->ffi_ret_type = ffitypes[luaL_checkoption(L, -1, "int", typenames)];
lua_getfield(L, 2, "abi");
abi = ffi_abis[luaL_checkoption(L, -1, "default", ffi_abi_names)];
lua_pop(L, 2);
} else {
ac->ret_type = types[luaL_checkoption(L, 2, "int", typenames)];
ac->ffi_ret_type = ffitypes[luaL_checkoption(L, 2, "int", typenames)];
abi = FFI_DEFAULT_ABI;
}
ac->nparams = nparams;
if(ac->nparams > 0) {
ac->params = (alien_Type *)malloc(ac->nparams * sizeof(alien_Type));
if(!ac->params) luaL_error(L, "alien: out of memory");
ac->ffi_params = (ffi_type **)malloc(ac->nparams * sizeof(ffi_type*));
if(!ac->ffi_params) luaL_error(L, "alien: out of memory");
}
if(lua_istable(L, 2)) {
for(i = 0, j = 1; i < ac->nparams; i++, j++) {
lua_rawgeti(L, 2, j);
ac->ffi_params[i] = ffitypes[luaL_checkoption(L, -1, "int", typenames)];
ac->params[i] = types[luaL_checkoption(L, -1, "int", typenames)];
lua_pop(L, 1);
}
} else {
for(i = 0, j = 3; i < ac->nparams; i++, j++) {
ac->ffi_params[i] = ffitypes[luaL_checkoption(L, j, "int", typenames)];
ac->params[i] = types[luaL_checkoption(L, j, "int", typenames)];
}
}
lua_pushvalue(L, 1);
//ac->fn_ref = lua_ref(L, 1);
ac->fn_ref = luaL_ref(L, 1);
luaL_getmetatable(L, ALIEN_CALLBACK_META);
lua_setmetatable(L, -2);
status = ffi_prep_cif(&(ac->cif), abi, ac->nparams,
ac->ffi_ret_type, ac->ffi_params);
if(status != FFI_OK) luaL_error(L, "alien: cannot create callback");
status = ffi_prep_closure(*ud, &(ac->cif), &alien_callback_call, ac);
ac->fn = *ud;
ac->lib = NULL;
ac->name = NULL;
if(status != FFI_OK) luaL_error(L, "alien: cannot create callback");
return 1;
} else {
if(ac) free(ac);
luaL_error(L, "alien: cannot allocate callback");
}
return 0;
}

static int alien_sizeof(lua_State *L) {
static const int sizes[] = {sizeof(int), sizeof(double), sizeof(uchar),
sizeof(char*), sizeof(void*), sizeof(char),
sizeof(short), sizeof(long), sizeof(float),
sizeof(void*), sizeof(char*), sizeof(int*),
sizeof(double*)};
static const char *const typenames[] = {"int", "double", "char", "string",
"pointer", "byte", "short", "long",
"float", "callback", "ref char",
"ref int", "ref double", NULL};
lua_pushnumber(L, sizes[luaL_checkoption(L, 1, "int", typenames)]);
return 1;
}

static int alien_align(lua_State *L) {
static const int aligns[] = {AT_INT_ALIGN, AT_DOUBLE_ALIGN, AT_CHAR_ALIGN,
AT_CHAR_P_ALIGN, AT_VOID_P_ALIGN, AT_CHAR_ALIGN,
AT_SHORT_ALIGN, AT_LONG_ALIGN, AT_FLOAT_ALIGN,
AT_VOID_P_ALIGN, AT_CHAR_P_ALIGN, AT_VOID_P_ALIGN,
AT_VOID_P_ALIGN};
static const char *const typenames[] = {"int", "double", "char", "string",
"pointer", "byte", "short", "long",
"float", "callback", "ref char",
"ref int", "ref double", NULL};
lua_pushnumber(L, aligns[luaL_checkoption(L, 1, "char", typenames)]);
return 1;
}

static int alien_function_types(lua_State *L) {
static ffi_type* ffitypes[] = {&ffi_type_void, &ffi_type_sint, &ffi_type_double,
&ffi_type_uchar, &ffi_type_pointer, &ffi_type_pointer,
&ffi_type_pointer, &ffi_type_pointer, &ffi_type_pointer,
&ffi_type_pointer, &ffi_type_sshort, &ffi_type_schar,
#ifndef WINDOWS
&ffi_type_slong,
#else
&ffi_type_sint,
#endif
&ffi_type_float};
static const int types[] = {AT_VOID, AT_INT, AT_DOUBLE, AT_CHAR, AT_STRING, AT_PTR, AT_REFINT,
AT_REFDOUBLE, AT_REFCHAR, AT_CALLBACK, AT_SHORT, AT_BYTE, AT_LONG,
AT_FLOAT};
static const char *const typenames[] =
{"void", "int", "double", "char", "string", "pointer",
"ref int", "ref double", "ref char", "callback",
"short", "byte", "long", "float", NULL};
ffi_status status;
ffi_abi abi;
alien_Function *af = alien_checkfunction(L, 1);
int i, j, ret_type;
if(lua_istable(L, 2)) {
lua_getfield(L, 2, "ret");
ret_type = luaL_checkoption(L, -1, "int", typenames);
af->ret_type = types[ret_type];
af->ffi_ret_type = ffitypes[ret_type];
lua_getfield(L, 2, "abi");
abi = ffi_abis[luaL_checkoption(L, -1, "default", ffi_abi_names)];
lua_pop(L, 2);
} else {
ret_type = luaL_checkoption(L, 2, "int", typenames);
af->ret_type = types[ret_type];
af->ffi_ret_type = ffitypes[ret_type];
abi = FFI_DEFAULT_ABI;
}
if(af->params) {
free(af->params); free(af->ffi_params);
af->params = NULL; af->ffi_params = NULL;
}
if(lua_istable(L, 2)) {
//af->nparams = lua_objlen(L, 2);
af->nparams = lua_rawlen(L, 2);
} else {
af->nparams = lua_gettop(L) - 2;
}
if(af->nparams > 0) {
af->ffi_params = (ffi_type **)malloc(sizeof(ffi_type *) * af->nparams);
if(!af->ffi_params) luaL_error(L, "alien: out of memory");
af->params = (alien_Type *)malloc(af->nparams * sizeof(alien_Type));
if(!af->params) luaL_error(L, "alien: out of memory");
}
if(lua_istable(L, 2)) {
for(i = 0, j = 1; i < af->nparams; i++, j++) {
lua_rawgeti(L, 2, j);
af->ffi_params[i] = ffitypes[luaL_checkoption(L, -1, "int", typenames)];
af->params[i] = types[luaL_checkoption(L, -1, "int", typenames)];
lua_pop(L, 1);
}
} else {
for(i = 0, j = 3; i < af->nparams; i++, j++) {
int type = luaL_checkoption(L, j, "int", typenames);
af->ffi_params[i] = ffitypes[type];
af->params[i] = types[type];
}
}
status = ffi_prep_cif(&(af->cif), abi, af->nparams,
af->ffi_ret_type,
af->ffi_params);
if(status != FFI_OK)
luaL_error(L, "alien: error in libffi preparation");
return 0;
}

static int alien_function_tostring(lua_State *L) {
alien_Function*af;
af = alien_checkfunction(L, 1);
lua_pushfstring(L, "alien function %s, library %s", af->name ? af->name : "anonymous",
((af->lib && af->lib->name) ? af->lib->name : "default"));
return 1;
}

static int alien_function_call(lua_State *L) {
int i, j, nargs, nparams;
int iret; double dret; void *pret; long lret; float fret;
int *refi_args = NULL;
int nrefi, nrefd, nrefc;
double *refd_args =NULL;
char *refc_args = NULL;
void **args = NULL;
ffi_cif *cif;
alien_Function *af = alien_checkfunction(L, 1);
cif = &(af->cif);
nparams = af->nparams;
nargs = lua_gettop(L) - 1;
if(nargs < nparams)
luaL_error(L, "alien: too few arguments (function %s)", af->name ?
af->name : "anonymous");
else if(nargs > nparams)
luaL_error(L, "alien: too many arguments (function %s)", af->name ?
af->name : "anonymous");
for(i = 0, nrefi = 0, nrefd = 0, nrefc = 0; i < nparams; i++) {
switch(af->params[i]) {
case AT_REFINT: nrefi++; break;
case AT_REFDOUBLE: nrefd++; break;
case AT_REFCHAR: nrefc++; break;
}
}
if(nrefi > 0) refi_args = (int*)ALLOCA(sizeof(int) * nrefi);
if(nrefd > 0) refd_args = (double*)ALLOCA(sizeof(double) * nrefd);
if(nrefc > 0) refc_args = (char*)ALLOCA(sizeof(char) * nrefc);
if(nargs > 0) args = ALLOCA(sizeof(void*) * nargs);
for(i = 0, j = 2; i < nparams; i++, j++) {
void *arg;
switch(af->params[i]) {
case AT_SHORT:
arg = ALLOCA(sizeof(short)); *((short*)arg) = (short)lua_tointeger(L, j);
args[i] = arg; break;
case AT_LONG:
arg = ALLOCA(sizeof(long)); *((long*)arg) = (long)lua_tointeger(L, j);
args[i] = arg; break;
case AT_INT:
arg = ALLOCA(sizeof(int)); *((int*)arg) = (int)lua_tointeger(L, j);
args[i] = arg; break;
case AT_CHAR:
arg = ALLOCA(sizeof(uchar)); *((uchar*)arg) = (uchar)lua_tointeger(L, j);
args[i] = arg; break;
case AT_BYTE:
arg = ALLOCA(sizeof(char)); *((char*)arg) = (signed char)lua_tointeger(L, j);
args[i] = arg; break;
case AT_FLOAT:
arg = ALLOCA(sizeof(float)); *((float*)arg) = (float)lua_tonumber(L, j);
args[i] = arg; break;
case AT_DOUBLE:
arg = ALLOCA(sizeof(double)); *((double*)arg) = (double)lua_tonumber(L, j);
args[i] = arg; break;
case AT_STRING:
arg = ALLOCA(sizeof(char*));
if(lua_isuserdata(L, j))
*((char**)arg) = lua_isnil(L, j) ? NULL : lua_touserdata(L, j);
else
*((const char**)arg) = lua_isnil(L, j) ? NULL : lua_tostring(L, j);
args[i] = arg;
break;
case AT_CALLBACK:
arg = ALLOCA(sizeof(void*));
*((void**)arg) = alien_checkcallback(L, j);
args[i] = arg;
break;
case AT_PTR:
arg = ALLOCA(sizeof(char*));
*((void**)arg) = lua_isnil(L, j) ? NULL :
(lua_isstring(L, j) ? (void*)lua_tostring(L, j) :
lua_touserdata(L, j));
args[i] = arg;
break;
case AT_REFINT:
*refi_args = (int)lua_tointeger(L, j);
arg = ALLOCA(sizeof(int*));
*((int**)arg) = refi_args;
args[i] = arg; refi_args++; break;
break;
case AT_REFCHAR:
*refc_args = (char)lua_tointeger(L, j);
arg = ALLOCA(sizeof(char*));
*((char**)arg) = refc_args;
args[i] = arg; refc_args++; break;
break;
case AT_REFDOUBLE:
*refd_args = lua_tonumber(L, j);
arg = ALLOCA(sizeof(double*));
*((double**)arg) = refd_args;
args[i] = arg; refd_args++; break;
break;
default:
luaL_error(L, "alien: parameter %i is of unknown type (function %s)", j,
af->name ? af->name : "anonymous");
}
}
pret = NULL;
switch(af->ret_type) {
case AT_VOID: ffi_call(cif, af->fn, NULL, args); lua_pushnil(L); break;
case AT_SHORT: ffi_call(cif, af->fn, &iret, args); lua_pushnumber(L, (short)iret); break;
case AT_LONG:
ffi_call(cif, af->fn, &lret, args); lua_pushnumber(L, lret); break;
case AT_INT: ffi_call(cif, af->fn, &iret, args); lua_pushnumber(L, iret); break;
case AT_CHAR: ffi_call(cif, af->fn, &iret, args); lua_pushnumber(L, (uchar)iret); break;
case AT_BYTE: ffi_call(cif, af->fn, &iret, args); lua_pushnumber(L, (signed char)iret); break;
case AT_FLOAT: ffi_call(cif, af->fn, &fret, args); lua_pushnumber(L, fret); break;
case AT_DOUBLE: ffi_call(cif, af->fn, &dret, args); lua_pushnumber(L, dret); break;
case AT_STRING: ffi_call(cif, af->fn, &pret, args);
if (pret)
{
lua_pushstring(L, (const char *)pret);
}
else
{
lua_pushnil(L);
}
break;
case AT_PTR: ffi_call(cif, af->fn, &pret, args);
(pret ? lua_pushlightuserdata(L, pret) : lua_pushnil(L)); break;
default:
luaL_error(L, "alien: unknown return type (function %s)", af->name ?
af->name : "anonymous");
}
refi_args -= nrefi; refd_args -= nrefd; refc_args -= nrefc;
for(i = 0; i < nparams; i++) {
switch(af->params[i]) {
case AT_REFINT: lua_pushnumber(L, *refi_args); refi_args++; break;
case AT_REFDOUBLE: lua_pushnumber(L, *refd_args); refd_args++; break;
case AT_REFCHAR: lua_pushnumber(L, *refc_args); refc_args++; break;
}
}
return 1 + nrefi + nrefc + nrefd;
}

static int alien_library_gc(lua_State *L) {
alien_Library *al = alien_checklibrary(L, 1);
if(al->lib) {
alien_unload(al->lib);
if(al->name) free(al->name);
}
return 0;
}

static int alien_function_gc(lua_State *L) {
alien_Function *af = alien_checkfunction(L, 1);
if(af->name) free(af->name);
if(af->params) free(af->params);
if(af->ffi_params) free(af->ffi_params);
return 0;
}

static int alien_callback_gc(lua_State *L) {
ffi_closure *ud = alien_checkcallback(L, 1);
alien_Callback *ac = (alien_Callback *)ud->user_data;
//lua_unref(ac->L, ac->fn_ref);
luaL_unref(ac->L, LUA_REGISTRYINDEX, ac->fn_ref);
if(ac->params) free(ac->params);
if(ac->ffi_params) free(ac->ffi_params);
free_closure(ud);
return 0;
}

static int alien_register(lua_State *L) {
const char *meta = luaL_checkstring(L, 1);
luaL_getmetatable(L, meta);
if(lua_isnil(L, -1))
luaL_newmetatable(L, meta);
return 1;
}

static int alien_pack(lua_State *L) {
int i, top;
alien_Wrap *ud;
const char *meta = luaL_checkstring(L, 1);
ud = (alien_Wrap*)lua_newuserdata(L, sizeof(alien_Wrap) * lua_gettop(L));
top = lua_gettop(L);
for(i = 2; i < top ; i++) {
if(lua_isnil(L, i)) {
ud[i - 2].tag = AT_PTR;
ud[i - 2].val.p = NULL;
}
else if(lua_isuserdata(L, i)) {
ud[i - 2].tag = AT_PTR;
ud[i - 2].val.p = lua_touserdata(L, i);
} else {
ud[i - 2].tag = AT_INT;
ud[i - 2].val.i = lua_tointeger(L, i);
}
}
ud[lua_gettop(L) - 2].tag = AT_VOID;
luaL_getmetatable(L, meta);
lua_setmetatable(L, -2);
return 1;
}

static int alien_unpack(lua_State *L) {
int size, i;
alien_Wrap *ud;
const char *meta = luaL_checkstring(L, 1);
ud = (alien_Wrap *)luaL_checkudata(L, 2, meta);
luaL_argcheck(L, ud != NULL, 2, "userdata has wrong metatable");
while(ud->tag != AT_VOID) {
switch(ud->tag) {
case AT_INT: lua_pushnumber(L, ud->val.i); break;
case AT_PTR: ud->val.p ? lua_pushlightuserdata(L, ud->val.p) :
lua_pushnil(L); break;
default: luaL_error(L, "wrong type in wrapped value");
}
ud++;
}
return lua_gettop(L) - 2;
}

static int alien_repack(lua_State *L) {
int size, i, top;
alien_Wrap *ud;
const char *meta = luaL_checkstring(L, 1);
ud = (alien_Wrap *)luaL_checkudata(L, 2, meta);
i = 3;
top = lua_gettop(L);
while(ud->tag != AT_VOID) {
if(i > top || lua_isnil(L, i)) {
ud->tag = AT_PTR;
ud->val.p = NULL;
}
else if(lua_isuserdata(L, i)) {
ud->tag = AT_PTR;
ud->val.p = lua_touserdata(L, i);
} else {
ud->tag = AT_INT;
ud->val.i = lua_tointeger(L, i);
}
ud++; i++;
}
return 0;
}

static int alien_buffer_new(lua_State *L) {
const char *s; char *b;
size_t size;
if(lua_type(L, 1) == LUA_TSTRING) {
s = lua_tolstring(L, 1, &size);
size++;
} else if(lua_type(L, 1) == LUA_TLIGHTUSERDATA) {
luaL_getmetatable(L, ALIEN_BUFFER_META);
lua_setmetatable(L, -2);
return 1;
} else {
s = NULL;

//size = luaL_optint(L, 1, BUFSIZ);
size = luaL_optinteger(L, 1, BUFSIZ);
}
b = (char *)lua_newuserdata(L, size);
if(b) {
if(s) {
memcpy(b, s, size - 1);
b[size - 1] = ‘\0‘;
}
luaL_getmetatable(L, ALIEN_BUFFER_META);
lua_setmetatable(L, -2);
return 1;
} else {
luaL_error(L, "cannot allocate buffer");
}
return 0;
}

static int alien_buffer_tostring(lua_State *L) {
char *b;
int size;
b = alien_checkbuffer(L, 1);
if(lua_gettop(L) < 2 || lua_isnil(L, 2))
size = strlen(b);
else
size = luaL_checkinteger(L, 2);
lua_pushlstring(L, b, size);
return 1;
}

static int alien_buffer_len(lua_State *L) {
char *b = alien_checkbuffer(L, 1);
lua_pushinteger(L, strlen(b));
return 1;
}

static int alien_buffer_topointer(lua_State *L) {
char *b = alien_checkbuffer(L, 1);
lua_pushlightuserdata(L, b);
return 1;
}

static int alien_buffer_put(lua_State *L);

static int alien_buffer_get(lua_State *L) {
static const void* funcs[] = {&alien_buffer_tostring,
&alien_buffer_topointer,
&alien_buffer_len,
&alien_buffer_get,
&alien_buffer_put};
static const char *const funcnames[] = { "tostring", "topointer", "len", "get", "set", NULL };
static const int types[] = {AT_VOID, AT_INT, AT_DOUBLE, AT_CHAR, AT_STRING, AT_PTR, AT_REFINT,
AT_REFDOUBLE, AT_REFCHAR, AT_CALLBACK, AT_SHORT, AT_BYTE, AT_LONG,
AT_FLOAT};
static const char *const typenames[] =
{"void", "int", "double", "char", "string", "pointer",
"ref int", "ref double", "ref char", "callback",
"short", "byte", "long", "float", NULL};
char *b = alien_checkbuffer(L, 1);
if(lua_type(L, 2) == LUA_TSTRING) {
lua_pushcfunction(L,
(lua_CFunction)funcs[luaL_checkoption(L, 2, "tostring", funcnames)]);
} else {
void *p;
int offset = luaL_checkinteger(L, 2) - 1;
int type = types[luaL_checkoption(L, 3, "char", typenames)];
switch(type) {
case AT_SHORT: lua_pushnumber(L, *((short*)(&b[offset]))); break;
case AT_INT: lua_pushnumber(L, *((int*)(&b[offset]))); break;
case AT_LONG: lua_pushnumber(L, *((long*)(&b[offset]))); break;
case AT_BYTE: lua_pushnumber(L, (signed char)b[offset]); break;
case AT_CHAR: lua_pushnumber(L, b[offset]); break;
case AT_FLOAT: lua_pushnumber(L, *((float*)(&b[offset]))); break;
case AT_DOUBLE: lua_pushnumber(L, *((double*)(&b[offset]))); break;
case AT_STRING:
p = *((void**)&b[offset]);
if (p)
{
lua_pushstring(L, (char*)p);
}
else
{
lua_pushnil(L);
}

break;
case AT_CALLBACK:
p = *((void**)&b[offset]);
p ? alien_makefunction(L, NULL, p, NULL) : lua_pushnil(L);
break;
case AT_PTR:
p = *((void**)&b[offset]);
p ? lua_pushlightuserdata(L, p) : lua_pushnil(L);
break;
default:
luaL_error(L, "alien: unknown type in buffer:get");
}
}
return 1;
}

static int alien_buffer_put(lua_State *L) {
static const int types[] = {AT_VOID, AT_INT, AT_DOUBLE, AT_CHAR, AT_STRING, AT_PTR, AT_REFINT,
AT_REFDOUBLE, AT_REFCHAR, AT_CALLBACK, AT_SHORT, AT_BYTE, AT_LONG,
AT_FLOAT};
static const char *const typenames[] =
{"void", "int", "double", "char", "string", "pointer",
"ref int", "ref double", "ref char", "callback",
"short", "byte", "long", "float", NULL};
char *b = alien_checkbuffer(L, 1);
int offset = luaL_checkinteger(L, 2) - 1;
int type = types[luaL_checkoption(L, 4, "char", typenames)];
switch(type) {
case AT_SHORT: *((short*)(&b[offset])) = (short)lua_tointeger(L, 3); break;
case AT_INT: *((int*)(&b[offset])) = (int)lua_tointeger(L, 3); break;
case AT_LONG: *((long*)(&b[offset])) = (long)lua_tointeger(L, 3); break;
case AT_BYTE: b[offset] = (signed char)lua_tointeger(L, 3); break;
case AT_CHAR: b[offset] = (char)lua_tointeger(L, 3); break;
case AT_FLOAT: *((float*)(&b[offset])) = (float)lua_tonumber(L, 3); break;
case AT_DOUBLE: *((double*)(&b[offset])) = (double)lua_tonumber(L, 3); break;
case AT_STRING: *((char**)(&b[offset])) =
(lua_isnil(L, 3) ? NULL : (char*)lua_tostring(L, 3)); break;
case AT_CALLBACK: *((void**)(&b[offset])) = alien_checkcallback(L, 3); break;
case AT_PTR: *((void**)(&b[offset])) =
(lua_isnil(L, 3) ? NULL : (lua_isuserdata(L, 3) ? lua_touserdata(L, 3) :
(void*)lua_tostring(L, 3))); break;
default:
luaL_error(L, "alien: unknown type in buffer:put");
}
return 0;
}

static int alien_register_library_meta(lua_State *L) {
luaL_newmetatable(L, ALIEN_LIBRARY_META);
lua_pushliteral(L, "__gc");
lua_pushcfunction(L, alien_library_gc);
lua_settable(L, -3);
lua_pushliteral(L, "__tostring");
lua_pushcfunction(L, alien_library_tostring);
lua_settable(L, -3);
lua_pushliteral(L, "__index");
lua_newtable(L);
lua_pushcclosure(L, alien_library_get, 1);
lua_settable(L, -3);
lua_pop(L, 1);
return 0;
}

static int alien_register_callback_meta(lua_State *L) {
luaL_newmetatable(L, ALIEN_CALLBACK_META);
lua_pushliteral(L, "__call");
lua_pushcfunction(L, alien_function_call);
lua_settable(L, -3);
lua_pushliteral(L, "__gc");
lua_pushcfunction(L, alien_callback_gc);
lua_settable(L, -3);
lua_pushliteral(L, "__tostring");
lua_pushcfunction(L, alien_function_tostring);
lua_settable(L, -3);
lua_pop(L, 1);
return 0;
}

static int alien_register_function_meta(lua_State *L) {
luaL_newmetatable(L, ALIEN_FUNCTION_META);
lua_pushliteral(L, "__index");
lua_newtable(L);
lua_pushliteral(L, "types");
lua_pushcfunction(L, alien_function_types);
lua_settable(L, -3);
lua_settable(L, -3);
lua_pushliteral(L, "__call");
lua_pushcfunction(L, alien_function_call);
lua_settable(L, -3);
lua_pushliteral(L, "__gc");
lua_pushcfunction(L, alien_function_gc);
lua_settable(L, -3);
lua_pushliteral(L, "__tostring");
lua_pushcfunction(L, alien_function_tostring);
lua_settable(L, -3);
lua_pop(L, 1);
return 0;
}

static int alien_register_buffer_meta(lua_State *L) {
luaL_newmetatable(L, ALIEN_BUFFER_META);
lua_pushliteral(L, "__index");
lua_pushcfunction(L, alien_buffer_get);
lua_settable(L, -3);
lua_pushliteral(L, "__newindex");
lua_pushcfunction(L, alien_buffer_put);
lua_settable(L, -3);
lua_pushliteral(L, "__tostring");
lua_pushcfunction(L, alien_buffer_tostring);
lua_settable(L, -3);
lua_pop(L, 1);
return 0;
}

static int alien_errno(lua_State *L) {
lua_pushnumber(L, errno);
return 1;
}

static int alien_udata2str(lua_State *L) {
char *ud;
int size;
if(lua_isnil(L, 1)) {
lua_pushnil(L);
return 1;
}
luaL_checktype(L, 1, LUA_TLIGHTUSERDATA);
ud = (char *)lua_touserdata(L, 1);
if(lua_gettop(L) < 2 || lua_isnil(L, 2))
size = strlen(ud);
else
size = luaL_checkinteger(L, 2);
lua_pushlstring(L, ud, size);
return 1;
}

static int alien_udata2double(lua_State *L) {
double *ud;
int size, i;
if(lua_isnil(L, 1)) {
lua_pushnil(L);
return 1;
}
luaL_checktype(L, 1, LUA_TLIGHTUSERDATA);
if(lua_gettop(L) < 2 || lua_isnil(L, 2))
size = 1;
else
size = luaL_checkinteger(L, 2);
ud = (double *)lua_touserdata(L, 1);
for(i = 0; i < size; i++)
lua_pushnumber(L, ud[i]);
return size;
}

static int alien_udata2int(lua_State *L) {
int *ud;
int size, i;
if(lua_isnil(L, 1)) {
lua_pushnil(L);
return 1;
}
luaL_checktype(L, 1, LUA_TLIGHTUSERDATA);
if(lua_gettop(L) < 2 || lua_isnil(L, 2))
size = 1;
else
size = luaL_checkinteger(L, 2);
ud = (int *)lua_touserdata(L, 1);
for(i = 0; i < size; i++) {
lua_pushnumber(L, ud[i]);
}
return size;
}

static int alien_udata2short(lua_State *L) {
short *ud;
int size, i;
if(lua_isnil(L, 1)) {
lua_pushnil(L);
return 1;
}
luaL_checktype(L, 1, LUA_TLIGHTUSERDATA);
if(lua_gettop(L) < 2 || lua_isnil(L, 2))
size = 1;
else
size = luaL_checkinteger(L, 2);
ud = (short *)lua_touserdata(L, 1);
for(i = 0; i < size; i++)
lua_pushnumber(L, ud[i]);
return size;
}

static int alien_udata2char(lua_State *L) {
char *ud;
int size, i;
if(lua_isnil(L, 1)) {
lua_pushnil(L);
return 1;
}
luaL_checktype(L, 1, LUA_TLIGHTUSERDATA);
if(lua_gettop(L) < 2 || lua_isnil(L, 2))
size = 1;
else
size = luaL_checkinteger(L, 2);
ud = (char *)lua_touserdata(L, 1);
for(i = 0; i < size; i++)
lua_pushnumber(L, ud[i]);
return size;
}

static int alien_udata2long(lua_State *L) {
long *ud;
int size, i;
if(lua_isnil(L, 1)) {
lua_pushnil(L);
return 1;
}
luaL_checktype(L, 1, LUA_TLIGHTUSERDATA);
if(lua_gettop(L) < 2 || lua_isnil(L, 2))
size = 1;
else
size = luaL_checkinteger(L, 2);
ud = (long *)lua_touserdata(L, 1);
for(i = 0; i < size; i++)
lua_pushnumber(L, ud[i]);
return size;
}

static int alien_udata2float(lua_State *L) {
float *ud;
int size, i;
if(lua_isnil(L, 1)) {
lua_pushnil(L);
return 1;
}
luaL_checktype(L, 1, LUA_TLIGHTUSERDATA);
if(lua_gettop(L) < 2 || lua_isnil(L, 2))
size = 1;
else
size = luaL_checkinteger(L, 2);
ud = (float *)lua_touserdata(L, 1);
for(i = 0; i < size; i++)
lua_pushnumber(L, ud[i]);
return size;
}

static int alien_isnull(lua_State *L) {
void *ud;
luaL_checktype(L, 1, LUA_TLIGHTUSERDATA);
ud = lua_touserdata(L, 1);
lua_pushboolean(L, ud == NULL);
return 1;
}

static int alien_table_new(lua_State *L) {
int narray, nhash;
//narray = luaL_optint(L, 1, 0);
//nhash = luaL_optint(L, 2, 0);

narray = luaL_optinteger(L, 1, 0);
nhash = luaL_optinteger(L, 2, 0);
lua_createtable(L, narray, nhash);
return 1;
}

static const struct luaL_Reg alienlib[] = {
{"load", alien_get},
{"align", alien_align},
{"tag", alien_register},
{"wrap", alien_pack},
{"rewrap", alien_repack},
{"unwrap", alien_unpack},
{"errno", alien_errno},
{"tostring", alien_udata2str},
{"isnull", alien_isnull},
{"sizeof", alien_sizeof},
{"todouble", alien_udata2double},
{"toint", alien_udata2int},
{"tolong", alien_udata2long},
{"tofloat", alien_udata2float},
{"toshort", alien_udata2short},
{"tochar", alien_udata2char},
{"buffer", alien_buffer_new},
{"callback", alien_callback_new},
{"funcptr", alien_function_new},
{"table", alien_table_new},
{NULL, NULL},
};

static int alien_register_main(lua_State *L) {
alien_Library *al;
luaL_newlib(L, alienlib);
lua_pushliteral(L, PLATFORM);
lua_setfield(L, -2, "platform");
al = (alien_Library *)lua_newuserdata(L, sizeof(alien_Library));
al->lib = NULL;
al->name = "default";
luaL_getmetatable(L, ALIEN_LIBRARY_META);
lua_setmetatable(L, -2);
lua_setfield(L, -2, "default");
return 1;
}

__declspec(dllexport) int luaopen_alien(lua_State *L) {
alien_register_library_meta(L);
alien_register_callback_meta(L);
alien_register_function_meta(L);
alien_register_buffer_meta(L);
lua_getglobal(L, "alien");
if(lua_isnil(L, -1)) {
lua_newtable(L);
lua_pushvalue(L, -1);
lua_setglobal(L, "alien");
}
lua_newtable(L);
lua_pushvalue(L, -1);
lua_setfield(L, -3, "core");
alien_register_main(L);
return 1;
}

标签：lua alien windowsapi

原文地址：http://blog.csdn.net/cparent/article/details/41118231

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行