static int
Win32_AnimateWindow(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
HWND hwnd;
DWORD dwTime = 0, dwFlags = 0;
struct map_t { const char* s; DWORD f; };
if (objc != 4) {
Jim_WrongNumArgs(interp, 1, objv, "windowhandle time flags");
return JIM_ERR;
}
if (Jim_GetLong(interp, objv[1], (long *)&hwnd) != JIM_OK)
return JIM_ERR;
if (Jim_GetLong(interp, objv[2], &dwTime) != JIM_OK)
return JIM_ERR;
if (GetAnimateWindowFlagsFromObj(interp, objv[3], &dwFlags) != JIM_OK)
return JIM_ERR;
if (!AnimateWindow(hwnd, dwTime, dwFlags)) {
DWORD err = GetLastError();
Jim_Obj *errObj;
if (err == ERROR_SUCCESS)
errObj = Jim_NewStringObj(interp, "error: "
" calling thread does not own the window", -1);
else
errObj = Win32ErrorObj(interp, "AnimateWindow", err);
Jim_SetResult(interp, errObj);
return JIM_ERR;
}
return JIM_OK;
}
static int aio_cmd_seek(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
int orig = SEEK_SET;
long offset;
if (argc == 2) {
if (Jim_CompareStringImmediate(interp, argv[1], "start"))
orig = SEEK_SET;
else if (Jim_CompareStringImmediate(interp, argv[1], "current"))
orig = SEEK_CUR;
else if (Jim_CompareStringImmediate(interp, argv[1], "end"))
orig = SEEK_END;
else {
return -1;
}
}
if (Jim_GetLong(interp, argv[0], &offset) != JIM_OK) {
return JIM_ERR;
}
if (fseek(af->fp, offset, orig) == -1) {
JimAioSetError(interp, af->filename);
return JIM_ERR;
}
return JIM_OK;
}
static int clock_cmd_format(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
/* How big is big enough? */
char buf[100];
time_t t;
long seconds;
const char *format = "%a %b %d %H:%M:%S %Z %Y";
if (argc == 2 || (argc == 3 && !Jim_CompareStringImmediate(interp, argv[1], "-format"))) {
return -1;
}
if (argc == 3) {
format = Jim_String(argv[2]);
}
if (Jim_GetLong(interp, argv[0], &seconds) != JIM_OK) {
return JIM_ERR;
}
t = seconds;
/*@@if (strftime(buf, sizeof(buf), format, localtime(&t)) == 0) {
Jim_SetResultString(interp, "format string too long", -1);
return JIM_ERR;
}*/
Jim_SetResultString(interp, buf, -1);
return JIM_OK;
}
static int
Win32_GetModuleFileName(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
HMODULE hModule = NULL;
char path[MAX_PATH];
DWORD len = 0;
if (objc > 2) {
Jim_WrongNumArgs(interp, 1, objv, "?moduleid?");
return JIM_ERR;
}
if (objc == 2) {
if (Jim_GetLong(interp, objv[1], (long *)&hModule) != JIM_OK) {
return JIM_ERR;
}
}
len = GetModuleFileNameA(hModule, path, MAX_PATH);
if (len != 0) {
Jim_Obj *pathObj = Jim_NewStringObj(interp, path, len);
Jim_SetResult(interp, pathObj);
} else {
Jim_SetResult(interp,
Win32ErrorObj(interp, "GetModuleFileName", GetLastError()));
return JIM_ERR;
}
return JIM_OK;
}
static int Jim_AlarmCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
int ret;
if (argc != 2) {
Jim_WrongNumArgs(interp, 1, argv, "seconds");
return JIM_ERR;
}
else {
#ifdef HAVE_UALARM
double t;
ret = Jim_GetDouble(interp, argv[1], &t);
if (ret == JIM_OK) {
if (t < 1) {
ualarm(t * 1e6, 0);
}
else {
alarm(t);
}
}
#else
long t;
ret = Jim_GetLong(interp, argv[1], &t);
if (ret == JIM_OK) {
alarm(t);
}
#endif
}
return ret;
}
static int
Win32_ShowWindow(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
HWND hwnd;
int cmd;
const char *cmds[] = {
"SW_HIDE", "SW_SHOWNORMAL", "SW_SHOWMINIMIZED", "SW_MAXIMIZE",
"SW_SHOWNOACTIVATE", "SW_SHOW", "SW_MINIMIZE", "SW_SHOWMINNOACTIVE",
"SW_SHOWNA", "SW_RESTORE", "SW_SHOWDEFAULT", "SW_FORCEMINIMIZE",
NULL
};
if (objc != 3) {
Jim_WrongNumArgs(interp, 1, objv, "windowhandle option");
return JIM_ERR;
}
if (Jim_GetLong(interp, objv[1], (long *)&hwnd) != JIM_OK)
return JIM_ERR;
if (Jim_GetEnum(interp, objv[2], cmds, &cmd, "command", JIM_ERRMSG) != JIM_OK)
return JIM_ERR;
if (!ShowWindow(hwnd, cmd)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "ShowWindow", GetLastError()));
return JIM_ERR;
}
return JIM_OK;
}
int Variable::toInt() const
{
long val;
if (Jim_GetLong(interpreter_, value(), &val) != JIM_OK)
return 0;
return val;
}
/*
* os.wait ?-nohang? pid
*
* An interface to waitpid(2)
*
* Returns a 3 element list.
*
* If -nohang is specified, and the process is still alive, returns
*
* {0 none 0}
*
* If the process does not exist or has already been waited for, returns:
*
* {-1 error <error-description>}
*
* If the process exited normally, returns:
*
* {<pid> exit <exit-status>}
*
* If the process terminated on a signal, returns:
*
* {<pid> signal <signal-number>}
*
* Otherwise (core dump, stopped, continued, ...), returns:
*
* {<pid> other 0}
*/
static int Jim_PosixWaitCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
int nohang = 0;
long pid;
int status;
Jim_Obj *listObj;
const char *type;
int value;
if (argc > 1 && Jim_CompareStringImmediate(interp, argv[1], "-nohang")) {
nohang = 1;
}
if (argc != nohang + 2) {
Jim_WrongNumArgs(interp, 1, argv, "?-nohang? pid");
return JIM_ERR;
}
if (Jim_GetLong(interp, argv[nohang + 1], &pid) != JIM_OK) {
return JIM_ERR;
}
pid = waitpid(pid, &status, nohang ? WNOHANG : 0);
listObj = Jim_NewListObj(interp, NULL, 0);
Jim_ListAppendElement(interp, listObj, Jim_NewIntObj(interp, pid));
if (pid < 0) {
type = "error";
value = errno;
}
else if (pid == 0) {
type = "none";
value = 0;
}
else if (WIFEXITED(status)) {
type = "exit";
value = WEXITSTATUS(status);
}
else if (WIFSIGNALED(status)) {
type = "signal";
value = WTERMSIG(status);
}
else {
type = "other";
value = 0;
}
Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, type, -1));
if (pid < 0) {
Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, strerror(value), -1));
}
else {
Jim_ListAppendElement(interp, listObj, Jim_NewIntObj(interp, value));
}
Jim_SetResult(interp, listObj);
return JIM_OK;
}
static int ioutil_Jim_Command_poke(Jim_Interp *interp,
int argc,
Jim_Obj *const *argv)
{
if (argc != 3) {
Jim_WrongNumArgs(interp, 1, argv, "poke ?address? ?value?");
return JIM_ERR;
}
long address;
if (Jim_GetLong(interp, argv[1], &address) != JIM_OK)
return JIM_ERR;
long value;
if (Jim_GetLong(interp, argv[2], &value) != JIM_OK)
return JIM_ERR;
*((volatile int *) address) = value;
return JIM_OK;
}
static int
Win32_CreateWindow(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
int r = JIM_ERR;
HWND hwnd, hwndParent = HWND_DESKTOP;
DWORD style = WS_VISIBLE | WS_OVERLAPPEDWINDOW;
UINT id = 0;
const char *class, *title;
if (objc < 3 || objc > 5) {
Jim_WrongNumArgs(interp, 1, objv, "class title ?parent? ?id?");
return JIM_ERR;
}
class = Jim_GetString(objv[1], NULL);
title = Jim_GetString(objv[2], NULL);
if (objc == 4) {
if (Jim_GetLong(interp, objv[3], (long *)&hwndParent) != JIM_OK)
return JIM_ERR;
style = WS_VISIBLE | WS_CHILD | WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
}
if (objc == 5) {
if (Jim_GetLong(interp, objv[4], (long *)&id) != JIM_OK)
return JIM_ERR;
}
hwnd = CreateWindowA(class, title, style,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
hwndParent, (HMENU)id, g_hInstance, NULL);
if (hwnd) {
SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)interp);
Jim_SetResult(interp, Jim_NewIntObj(interp, (DWORD)hwnd));
r = JIM_OK;
} else {
Jim_SetResult(interp,
Win32ErrorObj(interp, "CreateWindow", GetLastError()));
r = JIM_ERR;
}
return r;
}
static int JimSdlSurfaceCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
JimSdlSurface *jss;
char buf[AIO_CMD_LEN];
Jim_Obj *objPtr;
long screenId, xres, yres;
SDL_Surface *screen;
if (argc != 3) {
Jim_WrongNumArgs(interp, 1, argv, "xres yres");
return JIM_ERR;
}
if (Jim_GetLong(interp, argv[1], &xres) != JIM_OK ||
Jim_GetLong(interp, argv[2], &yres) != JIM_OK)
return JIM_ERR;
/* Try to create the surface */
screen = SDL_SetVideoMode(xres, yres, 32, SDL_SWSURFACE | SDL_ANYFORMAT);
if (screen == NULL) {
JimSdlSetError(interp);
return JIM_ERR;
}
/* Get the next file id */
if (Jim_EvalGlobal(interp, "if {[catch {incr sdl.surfaceId}]} {set sdl.surfaceId 0}") != JIM_OK)
return JIM_ERR;
objPtr = Jim_GetVariableStr(interp, "sdl.surfaceId", JIM_ERRMSG);
if (objPtr == NULL)
return JIM_ERR;
if (Jim_GetLong(interp, objPtr, &screenId) != JIM_OK)
return JIM_ERR;
/* Create the SDL screen command */
jss = Jim_Alloc(sizeof(*jss));
jss->screen = screen;
sprintf(buf, "sdl.surface%ld", screenId);
Jim_CreateCommand(interp, buf, JimSdlHandlerCommand, jss, JimSdlDelProc);
Jim_SetResult(interp, Jim_MakeGlobalNamespaceName(interp, Jim_NewStringObj(interp, buf, -1)));
return JIM_OK;
}
static int aio_cmd_recvfrom(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
char *buf;
union sockaddr_any sa;
long len;
socklen_t salen = sizeof(sa);
int rlen;
if (Jim_GetLong(interp, argv[0], &len) != JIM_OK) {
return JIM_ERR;
}
buf = Jim_Alloc(len + 1);
rlen = recvfrom(fileno(af->fp), buf, len, 0, &sa.sa, &salen);
if (rlen < 0) {
Jim_Free(buf);
JimAioSetError(interp, NULL);
return JIM_ERR;
}
buf[rlen] = 0;
Jim_SetResult(interp, Jim_NewStringObjNoAlloc(interp, buf, rlen));
if (argc > 1) {
/* INET6_ADDRSTRLEN is 46. Add some for [] and port */
char addrbuf[60];
#if IPV6
if (sa.sa.sa_family == PF_INET6) {
addrbuf[0] = '[';
/* Allow 9 for []:65535\0 */
inet_ntop(sa.sa.sa_family, &sa.sin6.sin6_addr, addrbuf + 1, sizeof(addrbuf) - 9);
snprintf(addrbuf + strlen(addrbuf), 8, "]:%d", ntohs(sa.sin.sin_port));
}
else
#endif
{
/* Allow 7 for :65535\0 */
inet_ntop(sa.sa.sa_family, &sa.sin.sin_addr, addrbuf, sizeof(addrbuf) - 7);
snprintf(addrbuf + strlen(addrbuf), 7, ":%d", ntohs(sa.sin.sin_port));
}
if (Jim_SetVariable(interp, argv[1], Jim_NewStringObj(interp, addrbuf, -1)) != JIM_OK) {
return JIM_ERR;
}
}
return JIM_OK;
}
static int
Win32_SetCursorPos(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
int r = JIM_OK;
POINT pt;
if (objc != 3) {
Jim_WrongNumArgs(interp, 1, objv, "x y");
return JIM_ERR;
}
r = Jim_GetLong(interp, objv[1], &pt.x);
if (r == JIM_OK)
r = Jim_GetLong(interp, objv[2], &pt.y);
if (r == JIM_OK) {
if (!SetCursorPos(pt.x, pt.y)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "SetCursorPos", GetLastError()));
r = JIM_ERR;
}
}
return r;
}
static int Jim_PosixSleepCommand(Jim_Interp *interp, int argc,
Jim_Obj *const *argv)
{
long longValue;
if (argc != 2) {
Jim_WrongNumArgs(interp, 1, argv, "?seconds?");
return JIM_ERR;
}
if (Jim_GetLong(interp, argv[1], &longValue) != JIM_OK)
return JIM_ERR;
sleep(longValue);
return JIM_OK;
}
static int
Win32_MoveWindow(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
HWND hwnd;
int n, param[4];
if (objc != 6) {
Jim_WrongNumArgs(interp, 1, objv, "hwnd x y width height");
return JIM_ERR;
}
if (Jim_GetLong(interp, objv[1], (long *)&hwnd) != JIM_OK)
return JIM_ERR;
for (n = 2; n < 6; n++) {
if (Jim_GetLong(interp, objv[n], (long*)¶m[n-2]) != JIM_OK)
return JIM_ERR;
}
if (!MoveWindow(hwnd, param[0], param[1], param[2], param[3], TRUE)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "MoveWindow", GetLastError()));
return JIM_ERR;
}
return JIM_OK;
}
static int Jim_Deflate(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
long level = Z_DEFAULT_COMPRESSION;
const char *in;
int len;
if (argc != 1) {
if (Jim_GetLong(interp, argv[1], &level) != JIM_OK) {
return JIM_ERR;
}
}
in = Jim_GetString(argv[0], &len);
return Jim_Compress(interp, in, len, level, -MAX_WBITS);
}
static int
Win32_Beep(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
long freq, duration;
int r = JIM_OK;
if (objc != 3) {
Jim_WrongNumArgs(interp, 1, objv, "freq duration");
return JIM_ERR;
}
r = Jim_GetLong(interp, objv[1], &freq);
if (r == JIM_OK)
r = Jim_GetLong(interp, objv[2], &duration);
if (freq < 0x25) freq = 0x25;
if (freq > 0x7fff) freq = 0x7fff;
if (r == JIM_OK) {
if (!Beep(freq, duration)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "Beep", GetLastError()));
r = JIM_ERR;
}
}
return r;
}
static int aio_cmd_listen(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
long backlog;
if (Jim_GetLong(interp, argv[0], &backlog) != JIM_OK) {
return JIM_ERR;
}
if (listen(af->fd, backlog)) {
JimAioSetError(interp, NULL);
return JIM_ERR;
}
return JIM_OK;
}
static int
Win32_UpdateWindow(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
HWND hwnd;
if (objc != 2) {
Jim_WrongNumArgs(interp, 1, objv, "hwnd");
return JIM_ERR;
}
if (Jim_GetLong(interp, objv[1], (long *)&hwnd) != JIM_OK)
return JIM_ERR;
if (!UpdateWindow(hwnd)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "UpdateWindow", GetLastError()));
return JIM_ERR;
}
return JIM_OK;
}
static int
Win32_SetCursor(Jim_Interp *interp, int objc, Jim_Obj *const objv[])
{
HCURSOR hCursor;
int r = JIM_OK;
if (objc != 2) {
Jim_WrongNumArgs(interp, 1, objv, "hCursor");
return JIM_ERR;
}
r = Jim_GetLong(interp, objv[1], (long *)&hCursor);
if (r == JIM_OK) {
hCursor = SetCursor(hCursor);
Jim_SetResult(interp, Jim_NewIntObj(interp, (DWORD)hCursor));
}
return r;
}
/* win32.CloseWindow windowHandle */
static int
Win32_CloseWindow(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
long hwnd;
if (objc != 2) {
Jim_WrongNumArgs(interp, 1, objv, "?windowHandle?");
return JIM_ERR;
}
if (Jim_GetLong(interp, objv[1], &hwnd) != JIM_OK)
return JIM_ERR;
if (!CloseWindow((HWND)hwnd)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "CloseWindow", GetLastError()));
return JIM_ERR;
}
return JIM_OK;
}
static int Jim_KillCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
int sig;
long pid;
Jim_Obj *pidObj;
const char *signame;
if (argc != 2 && argc != 3) {
Jim_WrongNumArgs(interp, 1, argv, "?SIG|-0? pid");
return JIM_ERR;
}
if (argc == 2) {
sig = SIGTERM;
pidObj = argv[1];
}
else {
signame = Jim_String(argv[1]);
pidObj = argv[2];
/* Special 'kill -0 pid' to determine if a pid exists */
if (strcmp(signame, "-0") == 0 || strcmp(signame, "0") == 0) {
sig = 0;
}
else {
sig = find_signal_by_name(interp, signame);
if (sig < 0) {
return JIM_ERR;
}
}
}
if (Jim_GetLong(interp, pidObj, &pid) != JIM_OK) {
return JIM_ERR;
}
if (kill(pid, sig) == 0) {
return JIM_OK;
}
Jim_SetResultString(interp, "kill: Failed to deliver signal", -1);
return JIM_ERR;
}
static int Jim_Crc32(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
long init;
const char *in;
int len;
if (argc == 1) {
init = crc32(0L, Z_NULL, 0);
} else {
if (Jim_GetLong(interp, argv[1], &init) != JIM_OK) {
return JIM_ERR;
}
}
in = Jim_GetString(argv[0], &len);
Jim_SetResultInt(interp, crc32((uLong)init, (const Bytef *)in, (uInt)len) & 0xFFFFFFFF);
return JIM_OK;
}
static int ioutil_Jim_Command_peek(Jim_Interp *interp,
int argc,
Jim_Obj *const *argv)
{
if (argc != 2) {
Jim_WrongNumArgs(interp, 1, argv, "peek ?address?");
return JIM_ERR;
}
long address;
if (Jim_GetLong(interp, argv[1], &address) != JIM_OK)
return JIM_ERR;
int value = *((volatile int *) address);
Jim_SetResult(interp, Jim_NewIntObj(interp, value));
return JIM_OK;
}
static int Jim_Inflate(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
long bufsiz = DEF_DECOMPRESS_BUFSIZ;
const char *in;
int len;
if (argc != 1) {
if (Jim_GetLong(interp, argv[1], &bufsiz) != JIM_OK) {
return JIM_ERR;
}
if (JimZlibCheckBufSize(interp, bufsiz)) {
return JIM_ERR;
}
}
in = Jim_GetString(argv[0], &len);
return Jim_Decompress(interp, in, len, bufsiz, -MAX_WBITS);
}
static int aio_cmd_copy(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
long count = 0;
long maxlen = LONG_MAX;
FILE *outfh = Jim_AioFilehandle(interp, argv[0]);
if (outfh == NULL) {
return JIM_ERR;
}
if (argc == 2) {
if (Jim_GetLong(interp, argv[1], &maxlen) != JIM_OK) {
return JIM_ERR;
}
}
while (count < maxlen) {
int ch = fgetc(af->fp);
if (ch == EOF || fputc(ch, outfh) == EOF) {
break;
}
count++;
}
if (ferror(af->fp)) {
Jim_SetResultFormatted(interp, "error while reading: %s", strerror(errno));
clearerr(af->fp);
return JIM_ERR;
}
if (ferror(outfh)) {
Jim_SetResultFormatted(interp, "error while writing: %s", strerror(errno));
clearerr(outfh);
return JIM_ERR;
}
Jim_SetResultInt(interp, count);
return JIM_OK;
}
static int
Win32_SetForegroundWindow(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
HWND hwnd;
int r = JIM_OK;
if (objc != 2) {
Jim_WrongNumArgs(interp, 1, objv, "windowHandle");
return JIM_ERR;
}
r = Jim_GetLong(interp, objv[1], (long *)&hwnd);
if (r == JIM_OK) {
if (!SetForegroundWindow(hwnd)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "SetForegroundWindow", GetLastError()));
r = JIM_ERR;
}
}
return r;
}
/* win32.MessageBox message title ?type? */
static int
Win32_MessageBox(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
int r;
const char *message, *title;
long int type = 0;
if (objc < 3 || objc > 4) {
Jim_WrongNumArgs(interp, 1, objv, "message title ?type?");
return JIM_ERR;
}
message = Jim_String(objv[1]);
title = Jim_String(objv[2]);
if (objc == 4) {
if (Jim_GetLong(interp, objv[3], &type) != JIM_OK)
return JIM_ERR;
}
r = (int) MessageBoxA(NULL, message, title, (int)type);
Jim_SetResultInt(interp, r);
return JIM_OK;
}
static int JimAioAcceptHelper(Jim_Interp *interp, AioFile *serv_af )
{
int sock;
int addrlen = sizeof(struct sockaddr_in);
AioFile *af;
char buf[AIO_CMD_LEN];
Jim_Obj *objPtr;
long fileId;
fprintf(stderr,"accepting connection for %d \n",serv_af->fd);
sock = accept(serv_af->fd,(struct sockaddr*)&serv_af->sa,&addrlen);
fprintf(stderr,"done, got %d \n",sock);
if (sock < 0)
return JIM_ERR;
/* Get the next file id */
fprintf(stderr,"getting fileid:");
if (Jim_EvalGlobal(interp,
"if {[catch {incr aio.fileId}]} {set aio.fileId 0}") != JIM_OK)
return JIM_ERR;
objPtr = Jim_GetGlobalVariableStr(interp, "aio.fileId", JIM_ERRMSG);
if (objPtr == NULL) return JIM_ERR;
if (Jim_GetLong(interp, objPtr, &fileId) != JIM_OK) return JIM_ERR;
fprintf(stderr," %ld\n", fileId);
/* Create the file command */
af = Jim_Alloc(sizeof(*af));
af->fd = sock;
af->fp = fdopen(sock,"r+");
af->OpenFlags = AIO_FDOPEN;
af->flags = fcntl(af->fd,F_GETFL);
// fprintf(stderr,"hallo\n");
af->rEvent = NULL;
af->wEvent = NULL;
af->eEvent = NULL;
sprintf(buf, "aio.sockstream%ld", fileId);
Jim_CreateCommand(interp, buf, JimAioHandlerCommand, af, JimAioDelProc);
Jim_SetResultString(interp, buf, -1);
fprintf(stderr,"returning\n");
return JIM_OK;
}
static int
Win32_FreeLibrary(Jim_Interp *interp, int objc, Jim_Obj * const *objv)
{
HMODULE hModule = NULL;
int r = JIM_OK;
if (objc != 2) {
Jim_WrongNumArgs(interp, 1, objv, "hmodule");
return JIM_ERR;
}
r = Jim_GetLong(interp, objv[1], (long *)&hModule);
if (r == JIM_OK) {
if (!FreeLibrary(hModule)) {
Jim_SetResult(interp,
Win32ErrorObj(interp, "FreeLibrary", GetLastError()));
r = JIM_ERR;
}
}
return r;
}
