static int JimAioOpenCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { const char *mode; const char *filename; if (argc != 2 && argc != 3) { Jim_WrongNumArgs(interp, 1, argv, "filename ?mode?"); return JIM_ERR; } mode = (argc == 3) ? Jim_String(argv[2]) : "r"; filename = Jim_String(argv[1]); #ifdef jim_ext_tclcompat /* If the filename starts with '|', use popen instead */ if (*filename == '|') { Jim_Obj *evalObj[3]; evalObj[0] = Jim_NewStringObj(interp, "popen", -1); evalObj[1] = Jim_NewStringObj(interp, filename + 1, -1); evalObj[2] = Jim_NewStringObj(interp, mode, -1); return Jim_EvalObjVector(interp, 3, evalObj); } #endif return JimMakeChannel(interp, NULL, -1, argv[1], "aio.handle%ld", 0, mode); }
/* * 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 Win32_GetSystemInfo(Jim_Interp *interp, int objc, Jim_Obj *const *objv) { Jim_Obj *a[20]; SYSTEM_INFO si; int n = 0; struct pa_map { int arch; const char *name; }; struct pa_map *p, map[] = { { PROCESSOR_ARCHITECTURE_INTEL, "intel" }, { PROCESSOR_ARCHITECTURE_MIPS, "mips" }, { PROCESSOR_ARCHITECTURE_ALPHA, "alpha" }, { PROCESSOR_ARCHITECTURE_PPC, "ppc" }, { PROCESSOR_ARCHITECTURE_SHX, "shx" }, { PROCESSOR_ARCHITECTURE_ARM, "arm" }, { PROCESSOR_ARCHITECTURE_IA64, "ia64" }, { PROCESSOR_ARCHITECTURE_ALPHA64,"alpha64" }, { PROCESSOR_ARCHITECTURE_MSIL, "msil" }, { PROCESSOR_ARCHITECTURE_AMD64, "amd64"}, { PROCESSOR_ARCHITECTURE_IA32_ON_WIN64, "ia32onwin64" }, { PROCESSOR_ARCHITECTURE_UNKNOWN,"unknown" } }; JIM_NOTUSED(objc); JIM_NOTUSED(objv); GetSystemInfo(&si); a[n++] = Jim_NewStringObj(interp, "ProcessorArchitecture", -1); for (p = map; p->arch != PROCESSOR_ARCHITECTURE_UNKNOWN; ++p) { if (p->arch == si.wProcessorArchitecture) { break; } } a[n++] = Jim_NewStringObj(interp, p->name, -1); #define JIMADD(name,element) \ a[n++] = Jim_NewStringObj(interp, #name, -1); \ a[n++] = Jim_NewIntObj(interp, (jim_wide)si. ## element ) JIMADD(PageSize, dwPageSize); JIMADD(MinimumApplicationAddress, lpMinimumApplicationAddress); JIMADD(MaximumApplicationAddress, lpMaximumApplicationAddress); JIMADD(ActiveProcessorMask, dwActiveProcessorMask); JIMADD(NumberOfProcessors, dwNumberOfProcessors); JIMADD(ProcessorType, dwProcessorType); JIMADD(AllocationGranularity, dwAllocationGranularity); JIMADD(ProcessorLevel, wProcessorLevel); JIMADD(ProcessorRevision, wProcessorRevision); #undef JIMADD Jim_SetResult(interp, Jim_NewListObj(interp, a, n)); return JIM_OK; }
static int StoreStatData(Jim_Interp *interp, Jim_Obj *varName, const struct stat *sb) { /* Just use a list to store the data */ Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0); AppendStatElement(interp, listObj, "dev", sb->st_dev); AppendStatElement(interp, listObj, "ino", sb->st_ino); AppendStatElement(interp, listObj, "mode", sb->st_mode); AppendStatElement(interp, listObj, "nlink", sb->st_nlink); AppendStatElement(interp, listObj, "uid", sb->st_uid); AppendStatElement(interp, listObj, "gid", sb->st_gid); AppendStatElement(interp, listObj, "size", sb->st_size); AppendStatElement(interp, listObj, "atime", sb->st_atime); AppendStatElement(interp, listObj, "mtime", sb->st_mtime); AppendStatElement(interp, listObj, "ctime", sb->st_ctime); Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, "type", -1)); Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, JimGetFileType((int)sb->st_mode), -1)); /* Was a variable specified? */ if (varName) { Jim_Obj *objPtr = Jim_GetVariable(interp, varName, JIM_NONE); if (objPtr) { if (Jim_DictSize(interp, objPtr) < 0) { /* This message matches the one from Tcl */ Jim_SetResultFormatted(interp, "can't set \"%#s(dev)\": variable isn't array", varName); Jim_FreeNewObj(interp, listObj); return JIM_ERR; } if (Jim_IsShared(objPtr)) objPtr = Jim_DuplicateObj(interp, objPtr); /* Just cheat here and append as a list and convert to a dict */ Jim_ListAppendList(interp, objPtr, listObj); Jim_DictSize(interp, objPtr); Jim_InvalidateStringRep(objPtr); Jim_FreeNewObj(interp, listObj); listObj = objPtr; } Jim_SetVariable(interp, varName, listObj); } /* And also return the value */ Jim_SetResult(interp, listObj); return JIM_OK; }
static Jim_Obj * Win32ErrorObj(Jim_Interp *interp, const char * szPrefix, DWORD dwError) { Jim_Obj *msgObj = NULL; char * lpBuffer = NULL; DWORD dwLen = 0; dwLen = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, dwError, LANG_NEUTRAL, (char *)&lpBuffer, 0, NULL); if (dwLen < 1) { dwLen = FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY, "code 0x%1!08X!%n", 0, LANG_NEUTRAL, (char *)&lpBuffer, 0, (va_list *)&dwError); } msgObj = Jim_NewStringObj(interp, szPrefix, -1); if (dwLen > 0) { char *p = lpBuffer + dwLen - 1; /* remove cr-lf at end */ for ( ; p && *p && isspace(UCHAR(*p)); p--) ; *++p = 0; Jim_AppendString(interp, msgObj, ": ", 2); Jim_AppendString(interp, msgObj, lpBuffer, -1); } LocalFree((HLOCAL)lpBuffer); return msgObj; }
static int ioutil_Jim_Command_ls(Jim_Interp *interp, int argc, Jim_Obj * const *argv) { if (argc != 2) { Jim_WrongNumArgs(interp, 1, argv, "ls ?dir?"); return JIM_ERR; } const char *name = Jim_GetString(argv[1], NULL); DIR *dirp = NULL; dirp = opendir(name); if (dirp == NULL) return JIM_ERR; Jim_Obj *objPtr = Jim_NewListObj(interp, NULL, 0); for (;; ) { struct dirent *entry = NULL; entry = readdir(dirp); if (entry == NULL) break; if ((strcmp(".", entry->d_name) == 0) || (strcmp("..", entry->d_name) == 0)) continue; Jim_ListAppendElement(interp, objPtr, Jim_NewStringObj(interp, entry->d_name, strlen(entry->d_name))); } closedir(dirp); Jim_SetResult(interp, objPtr); return JIM_OK; }
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 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; }
/** * Creates a channel for fh/fd/filename. * * If fh is not NULL, uses that as the channel (and set AIO_KEEPOPEN). * Otherwise, if fd is >= 0, uses that as the chanel. * Otherwise opens 'filename' with mode 'mode'. * * hdlfmt is a sprintf format for the filehandle. Anything with %ld at the end will do. * mode is used for open or fdopen. * * Creates the command and sets the name as the current result. */ static int JimMakeChannel(Jim_Interp *interp, FILE *fh, int fd, Jim_Obj *filename, const char *hdlfmt, int family, const char *mode) { AioFile *af; char buf[AIO_CMD_LEN]; int OpenFlags = 0; if (filename == NULL) { filename = Jim_NewStringObj(interp, hdlfmt, -1); } Jim_IncrRefCount(filename); if (fh == NULL) { if (fd < 0) { fh = fopen(Jim_String(filename), mode); } else { fh = fdopen(fd, mode); } } else { OpenFlags = AIO_KEEPOPEN; } if (fh == NULL) { JimAioSetError(interp, filename); #if !defined(JIM_ANSIC) if (fd >= 0) { close(fd); } #endif Jim_DecrRefCount(interp, filename); return JIM_ERR; } /* Create the file command */ af = Jim_Alloc(sizeof(*af)); memset(af, 0, sizeof(*af)); af->fp = fh; af->fd = fileno(fh); af->filename = filename; #ifdef FD_CLOEXEC if ((OpenFlags & AIO_KEEPOPEN) == 0) { fcntl(af->fd, F_SETFD, FD_CLOEXEC); } #endif af->OpenFlags = OpenFlags; #ifdef O_NDELAY af->flags = fcntl(af->fd, F_GETFL); #endif af->addr_family = family; snprintf(buf, sizeof(buf), hdlfmt, Jim_GetId(interp)); Jim_CreateCommand(interp, buf, JimAioSubCmdProc, af, JimAioDelProc); Jim_SetResultString(interp, buf, -1); return JIM_OK; }
int Jim_MakeTempFile(Jim_Interp *interp, const char *filename_template, int unlink_file) { int fd; mode_t mask; Jim_Obj *filenameObj; if (filename_template == NULL) { const char *tmpdir = getenv("TMPDIR"); if (tmpdir == NULL || *tmpdir == '\0' || access(tmpdir, W_OK) != 0) { tmpdir = "/tmp/"; } filenameObj = Jim_NewStringObj(interp, tmpdir, -1); if (tmpdir[0] && tmpdir[strlen(tmpdir) - 1] != '/') { Jim_AppendString(interp, filenameObj, "/", 1); } Jim_AppendString(interp, filenameObj, "tcl.tmp.XXXXXX", -1); } else { filenameObj = Jim_NewStringObj(interp, filename_template, -1); } /* Update the template name directly with the filename */ mask = umask(S_IXUSR | S_IRWXG | S_IRWXO); #ifdef HAVE_MKSTEMP fd = mkstemp(filenameObj->bytes); #else if (mktemp(filenameObj->bytes) == NULL) { fd = -1; } else { fd = open(filenameObj->bytes, O_RDWR | O_CREAT | O_TRUNC); } #endif umask(mask); if (fd < 0) { Jim_SetResultErrno(interp, Jim_String(filenameObj)); Jim_FreeNewObj(interp, filenameObj); return -1; } if (unlink_file) { remove(Jim_String(filenameObj)); } Jim_SetResult(interp, filenameObj); return fd; }
/* * Create error messages for unusual process exits. An * extra newline gets appended to each error message, but * it gets removed below (in the same fashion that an * extra newline in the command's output is removed). */ static int JimCheckWaitStatus(Jim_Interp *interp, pidtype pid, int waitStatus) { Jim_Obj *errorCode = Jim_NewListObj(interp, NULL, 0); int rc = JIM_ERR; if (WIFEXITED(waitStatus)) { if (WEXITSTATUS(waitStatus) == 0) { Jim_ListAppendElement(interp, errorCode, Jim_NewStringObj(interp, "NONE", -1)); rc = JIM_OK; } else { Jim_ListAppendElement(interp, errorCode, Jim_NewStringObj(interp, "CHILDSTATUS", -1)); Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, (long)pid)); Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, WEXITSTATUS(waitStatus))); } } else { const char *type; const char *action; if (WIFSIGNALED(waitStatus)) { type = "CHILDKILLED"; action = "killed"; } else { type = "CHILDSUSP"; action = "suspended"; } Jim_ListAppendElement(interp, errorCode, Jim_NewStringObj(interp, type, -1)); #ifdef jim_ext_signal Jim_SetResultFormatted(interp, "child %s by signal %s", action, Jim_SignalId(WTERMSIG(waitStatus))); Jim_ListAppendElement(interp, errorCode, Jim_NewStringObj(interp, Jim_SignalId(WTERMSIG(waitStatus)), -1)); Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, pid)); Jim_ListAppendElement(interp, errorCode, Jim_NewStringObj(interp, Jim_SignalName(WTERMSIG(waitStatus)), -1)); #else Jim_SetResultFormatted(interp, "child %s by signal %d", action, WTERMSIG(waitStatus)); Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, WTERMSIG(waitStatus))); Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, (long)pid)); Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, WTERMSIG(waitStatus))); #endif } Jim_SetGlobalVariableStr(interp, "errorCode", errorCode); return rc; }
/* Everything passing between interpreters must be converted to a string */ static Jim_Obj *JimInterpCopyObj(Jim_Interp *target, Jim_Obj *obj) { const char *rep; int len; rep = Jim_GetString(obj, &len); return Jim_NewStringObj(target, rep, len); }
/* not so pretty code to fish out ip number*/ static int zylinjtag_Jim_Command_ip(Jim_Interp *interp, int argc, Jim_Obj * const *argv) { #if !defined(__CYGWIN__) Jim_Obj *tclOutput = Jim_NewStringObj(interp, "", 0); struct ifaddrs *ifa = NULL, *ifp = NULL; if (getifaddrs(&ifp) < 0) { return JIM_ERR; } for (ifa = ifp; ifa; ifa = ifa->ifa_next) { char ip[200]; socklen_t salen; if (ifa->ifa_addr->sa_family == AF_INET) salen = sizeof(struct sockaddr_in); else if (ifa->ifa_addr->sa_family == AF_INET6) salen = sizeof(struct sockaddr_in6); else continue; if (getnameinfo(ifa->ifa_addr, salen, ip, sizeof(ip), NULL, 0, NI_NUMERICHOST) < 0) { continue; } Jim_AppendString(interp, tclOutput, ip, strlen(ip)); break; } freeifaddrs(ifp); #else Jim_Obj *tclOutput = Jim_NewStringObj(interp, "fixme!!!", 0); LOG_ERROR("NOT IMPLEMENTED!!!"); #endif Jim_SetResult(interp, tclOutput); return JIM_OK; }
/* XXX: Temporary */ static int Jim_EvalEnsemble(Jim_Interp *interp, const char *basecmd, const char *subcmd, int argc, Jim_Obj *const *argv) { Jim_Obj *prefixObj = Jim_NewStringObj(interp, basecmd, -1); Jim_AppendString(interp, prefixObj, " ", 1); Jim_AppendString(interp, prefixObj, subcmd, -1); return Jim_EvalObjPrefix(interp, prefixObj, argc, argv); }
/* not so pretty code to fish out eth0 mac address */ static int ioutil_Jim_Command_mac(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { struct ifreq *ifr, *ifend; struct ifreq ifreq; struct ifconf ifc; struct ifreq ifs[5]; int SockFD; SockFD = socket(AF_INET, SOCK_DGRAM, 0); if (SockFD < 0) return JIM_ERR; ifc.ifc_len = sizeof(ifs); ifc.ifc_req = ifs; if (ioctl(SockFD, SIOCGIFCONF, &ifc) < 0) { close(SockFD); return JIM_ERR; } ifend = ifs + (ifc.ifc_len / sizeof(struct ifreq)); for (ifr = ifc.ifc_req; ifr < ifend; ifr++) { /* if (ifr->ifr_addr.sa_family == AF_INET) */ { if (strcmp("eth0", ifr->ifr_name) != 0) continue; strncpy(ifreq.ifr_name, ifr->ifr_name, sizeof(ifreq.ifr_name)); if (ioctl(SockFD, SIOCGIFHWADDR, &ifreq) < 0) { close(SockFD); return JIM_ERR; } close(SockFD); Jim_Obj *tclOutput = Jim_NewStringObj(interp, "", 0); char buffer[256]; sprintf(buffer, "%02x-%02x-%02x-%02x-%02x-%02x", ifreq.ifr_hwaddr.sa_data[0]&0xff, ifreq.ifr_hwaddr.sa_data[1]&0xff, ifreq.ifr_hwaddr.sa_data[2]&0xff, ifreq.ifr_hwaddr.sa_data[3]&0xff, ifreq.ifr_hwaddr.sa_data[4]&0xff, ifreq.ifr_hwaddr.sa_data[5]&0xff); Jim_AppendString(interp, tclOutput, buffer, strlen(buffer)); Jim_SetResult(interp, tclOutput); return JIM_OK; } } close(SockFD); return JIM_ERR; }
static void JimInterpCopyVariable(Jim_Interp *target, Jim_Interp *source, const char *var, const char *default_value) { Jim_Obj *value = Jim_GetGlobalVariableStr(source, var, JIM_NONE); const char *str; str = value ? Jim_String(value) : default_value; if (str) { Jim_SetGlobalVariableStr(target, var, Jim_NewStringObj(target, str, -1)); } }
static int Jim_PosixGetidsCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { Jim_Obj *objv[8]; if (argc != 1) { Jim_WrongNumArgs(interp, 1, argv, ""); return JIM_ERR; } objv[0] = Jim_NewStringObj(interp, "uid", -1); objv[1] = Jim_NewIntObj(interp, getuid()); objv[2] = Jim_NewStringObj(interp, "euid", -1); objv[3] = Jim_NewIntObj(interp, geteuid()); objv[4] = Jim_NewStringObj(interp, "gid", -1); objv[5] = Jim_NewIntObj(interp, getgid()); objv[6] = Jim_NewStringObj(interp, "egid", -1); objv[7] = Jim_NewIntObj(interp, getegid()); Jim_SetResult(interp, Jim_NewListObj(interp, objv, 8)); return JIM_OK; }
static int aio_cmd_gets(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { AioFile *af = Jim_CmdPrivData(interp); char buf[AIO_BUF_LEN]; Jim_Obj *objPtr; int len; errno = 0; objPtr = Jim_NewStringObj(interp, NULL, 0); while (1) { buf[AIO_BUF_LEN - 1] = '_'; if (fgets(buf, AIO_BUF_LEN, af->fp) == NULL) break; if (buf[AIO_BUF_LEN - 1] == '\0' && buf[AIO_BUF_LEN - 2] != '\n') { Jim_AppendString(interp, objPtr, buf, AIO_BUF_LEN - 1); } else { len = strlen(buf); if (len && (buf[len - 1] == '\n')) { /* strip "\n" */ len--; } Jim_AppendString(interp, objPtr, buf, len); break; } } if (JimCheckStreamError(interp, af)) { /* I/O error */ Jim_FreeNewObj(interp, objPtr); return JIM_ERR; } if (argc) { if (Jim_SetVariable(interp, argv[0], objPtr) != JIM_OK) { Jim_FreeNewObj(interp, objPtr); return JIM_ERR; } len = Jim_Length(objPtr); if (len == 0 && feof(af->fp)) { /* On EOF returns -1 if varName was specified */ len = -1; } Jim_SetResultInt(interp, len); } else { Jim_SetResult(interp, objPtr); } return JIM_OK; }
Jim_Obj *Jim_NamespaceTail(Jim_Interp *interp, Jim_Obj *ns) { const char *name = Jim_String(ns); const char *pt = strrchr(name, ':'); if (pt && pt != name && pt[-1] == ':') { return Jim_NewStringObj(interp, pt + 1, -1); } else { return ns; } }
/** * Returns the parent of the given namespace. * * ::bob::tom => ::bob * bob::tom => bob * ::bob => :: * bob => "" * :: => "" * "" => "" */ Jim_Obj *Jim_NamespaceQualifiers(Jim_Interp *interp, Jim_Obj *ns) { const char *name = Jim_String(ns); const char *pt = strrchr(name, ':'); if (pt && pt != name && pt[-1] == ':') { return Jim_NewStringObj(interp, name, pt - name - 1); } else { return interp->emptyObj; } }
static int jim_stacktrace_command(Jim_Interp *interp, int argc, Jim_Obj * const *argv) { if (argc != 1) { return JIM_ERR; } Jim_Obj * stacktrace = Jim_DuplicateObj(interp, interp->stackTrace); /* insert actual error site at beginning of list*/ Jim_Obj *procname = Jim_NewStringObj(interp, "", -1); /* Uhhh... don't know this one. */ Jim_ListInsertElements(interp, stacktrace, 0, 1, &procname); Jim_Obj *filename = Jim_NewStringObj(interp, interp->errorFileName, -1); Jim_ListInsertElements(interp, stacktrace, 1, 1, &filename); Jim_Obj *line = Jim_NewIntObj(interp, interp->errorLine); Jim_ListInsertElements(interp, stacktrace, 2, 1, &line); Jim_SetResult(interp, stacktrace); return JIM_OK; }
static FILE *JimGetAioFilehandle(Jim_Interp *interp, const char *name) { FILE *fh; Jim_Obj *fhObj; fhObj = Jim_NewStringObj(interp, name, -1); Jim_IncrRefCount(fhObj); fh = Jim_AioFilehandle(interp, fhObj); Jim_DecrRefCount(interp, fhObj); return fh; }
static int JimELAfterCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { jim_wide ms, id; Jim_Obj *objPtr, *idObjPtr; const char *options[] = { "info", "cancel", "restart", "expire", NULL }; enum {INFO, CANCEL, RESTART, EXPIRE, CREATE }; int option = CREATE ; if (argc < 3) { Jim_WrongNumArgs(interp, 1, argv, "<after milliseconds> script"); return JIM_ERR; } if (Jim_GetWide(interp, argv[1], &ms) != JIM_OK) if (Jim_GetEnum(interp, argv[1], options, &option, "after options", JIM_ERRMSG) != JIM_OK) return JIM_ERR; switch (option) { case CREATE: Jim_IncrRefCount(argv[2]); id = Jim_CreateTimeHandler(interp, ms, JimAfterTimeHandler, argv[2], JimAfterTimeEventFinalizer); objPtr = Jim_NewStringObj(interp, NULL, 0); Jim_AppendString(interp, objPtr, "after#", -1); idObjPtr = Jim_NewIntObj(interp, id); Jim_IncrRefCount(idObjPtr); Jim_AppendObj(interp, objPtr, idObjPtr); Jim_DecrRefCount(interp, idObjPtr); Jim_SetResult(interp, objPtr); return JIM_OK; case CANCEL: { int tlen ; jim_wide remain = 0; const char *tok = Jim_GetString(argv[2], &tlen); if ( sscanf(tok,"after#%lld",&id) == 1) { remain = Jim_DeleteTimeHandler(interp, id); if (remain > -2) { Jim_SetResult(interp, Jim_NewIntObj(interp, remain)); return JIM_OK; } } Jim_SetResultString(interp, "invalid event" , -1); return JIM_ERR; } default: fprintf(stderr,"unserviced option to after %d\n",option); } return JIM_OK; }
static int signal_set_sigmask_result(Jim_Interp *interp, jim_wide sigmask) { int i; Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0); for (i = 0; i < MAX_SIGNALS; i++) { if (sigmask & sig_to_bit(i)) { Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, Jim_SignalId(i), -1)); } } Jim_SetResult(interp, listObj); 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; }
/* find full path to file */ static int jim_find(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { if (argc != 2) return JIM_ERR; const char *file = Jim_GetString(argv[1], NULL); char *full_path = find_file(file); if (full_path == NULL) return JIM_ERR; Jim_Obj *result = Jim_NewStringObj(interp, full_path, strlen(full_path)); free(full_path); Jim_SetResult(interp, result); return JIM_OK; }
static int JimRlReadlineCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { char *line; if (argc != 2) { Jim_WrongNumArgs(interp, 1, argv, "prompt"); return JIM_ERR; } line = readline(Jim_String(argv[1])); if (!line) { return JIM_EXIT; } Jim_SetResult(interp, Jim_NewStringObj(interp, line, -1)); return JIM_OK; }
static int aio_cmd_accept(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { AioFile *af = Jim_CmdPrivData(interp); int sock; union sockaddr_any sa; socklen_t addrlen = sizeof(sa); sock = accept(af->fd, &sa.sa, &addrlen); if (sock < 0) { JimAioSetError(interp, NULL); return JIM_ERR; } /* Create the file command */ return JimMakeChannel(interp, NULL, sock, Jim_NewStringObj(interp, "accept", -1), "aio.sockstream%ld", af->addr_family, "r+"); }
/* *----------------------------------------------------------------------------- * * Jim_ReaddirCmd -- * Implements the rename TCL command: * readdir ?-nocomplain? dirPath * * Results: * Standard TCL result. *----------------------------------------------------------------------------- */ int Jim_ReaddirCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv) { const char *dirPath; DIR *dirPtr; struct dirent *entryPtr; int nocomplain = 0; if (argc == 3 && Jim_CompareStringImmediate(interp, argv[1], "-nocomplain")) { nocomplain = 1; } if (argc != 2 && !nocomplain) { Jim_WrongNumArgs(interp, 1, argv, "?-nocomplain? dirPath"); return JIM_ERR; } dirPath = Jim_String(argv[1 + nocomplain]); dirPtr = opendir(dirPath); if (dirPtr == NULL) { if (nocomplain) { return JIM_OK; } Jim_SetResultString(interp, strerror(errno), -1); return JIM_ERR; } else { Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0); while ((entryPtr = readdir(dirPtr)) != NULL) { if (entryPtr->d_name[0] == '.') { if (entryPtr->d_name[1] == '\0') { continue; } if ((entryPtr->d_name[1] == '.') && (entryPtr->d_name[2] == '\0')) continue; } Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, entryPtr->d_name, -1)); } closedir(dirPtr); Jim_SetResult(interp, listObj); return JIM_OK; } }
Jim_Obj * Variable::defaultValue() const { assert(interpreter_); switch (type_) { case ValueType::STRING: return Jim_NewStringObj(interpreter_, defaultStrValue_, std::strlen(defaultStrValue_)); case ValueType::INT: return Jim_NewIntObj(interpreter_, defaultIntValue_); case ValueType::BOOL: return Jim_NewIntObj(interpreter_, defaultBoolValue_ ? 1 : 0); } return nullptr; }