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;
}
/* 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);
}
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;
}
/**
* Given the name of a signal, returns the signal value if found,
* or returns -1 (and sets an error) if not found.
* We accept -SIGINT, SIGINT, INT or any lowercase version or a number,
* either positive or negative.
*/
static int find_signal_by_name(Jim_Interp *interp, const char *name)
{
int i;
const char *pt = name;
/* Remove optional - and SIG from the front of the name */
if (*pt == '-') {
pt++;
}
if (strncasecmp(name, "sig", 3) == 0) {
pt += 3;
}
if (isdigit(UCHAR(pt[0]))) {
i = atoi(pt);
if (i > 0 && i < MAX_SIGNALS) {
return i;
}
}
else {
for (i = 1; i < MAX_SIGNALS; i++) {
/* Jim_SignalId() returns names such as SIGINT, and
* returns "unknown signal id" if unknown, so this will work
*/
if (strcasecmp(Jim_SignalId(i) + 3, pt) == 0) {
return i;
}
}
}
Jim_SetResultString(interp, "unknown signal ", -1);
Jim_AppendString(interp, Jim_GetResult(interp), name, -1);
return -1;
}
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;
}
static int Jim_Decompress(Jim_Interp *interp, const char *in, int len, long bufsiz, int wbits)
{
z_stream strm = {0};
void *buf;
Jim_Obj *out;
int ret;
if (JimZlibCheckBufSize(interp, bufsiz)) {
return JIM_ERR;
}
if (inflateInit2(&strm, wbits) != Z_OK) {
return JIM_ERR;
}
/* allocate a buffer - decompression is done in chunks, into this buffer;
* when the decompressed data size is given, decompression is faster because
* it's done in one pass, with less memcpy() overhead */
buf = Jim_Alloc((int)bufsiz);
out = Jim_NewEmptyStringObj(interp);
Jim_IncrRefCount(out);
strm.next_in = (Bytef*)in;
strm.avail_in = (uInt)len;
do {
do {
strm.next_out = buf;
strm.avail_out = (uInt)bufsiz;
ret = inflate(&strm, Z_NO_FLUSH);
switch (ret) {
case Z_OK:
case Z_STREAM_END:
/* append each chunk to the output object */
Jim_AppendString(interp, out, buf, (int)(bufsiz - (long)strm.avail_out));
break;
default:
Jim_DecrRefCount(interp, out);
Jim_Free(buf);
inflateEnd(&strm);
if (strm.msg != NULL)
Jim_SetResultString(interp, strm.msg, -1);
return JIM_ERR;
}
} while (strm.avail_out == 0);
} while (ret != Z_STREAM_END);
/* free memory used for decompression before we assign the return value */
Jim_Free(buf);
inflateEnd(&strm);
Jim_SetResult(interp, out);
Jim_DecrRefCount(interp, out);
return JIM_OK;
}
/* 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 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;
}
/* 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;
}
/**
* Read from 'fd', append the data to strObj and close 'fd'.
* Returns JIM_OK if OK, or JIM_ERR on error.
*/
static int JimAppendStreamToString(Jim_Interp *interp, fdtype fd, Jim_Obj *strObj)
{
char buf[256];
FILE *fh = JimFdOpenForRead(fd);
if (fh == NULL) {
return JIM_ERR;
}
while (1) {
int retval = fread(buf, 1, sizeof(buf), fh);
if (retval > 0) {
Jim_AppendString(interp, strObj, buf, retval);
}
if (retval != sizeof(buf)) {
break;
}
}
Jim_RemoveTrailingNewline(strObj);
fclose(fh);
return JIM_OK;
}
/**
* nsObj is a canonical namespace name (.e.g. "" for root, "abc" for ::abc)
*
* The given name is appended to the namespace name to produce a complete canonical name.
*
* e.g. "" "abc" => abc
* "" "::abc" => abc
* "" "abc::def" => abc::def
* "abc" "def" => abc::def
* "abc" "::def" => def
*
*/
Jim_Obj *JimCanonicalNamespace(Jim_Interp *interp, Jim_Obj *nsObj, Jim_Obj *nameObj)
{
Jim_Obj *objPtr;
const char *name = Jim_String(nameObj);
assert(nameObj->refCount != 0);
assert(nsObj->refCount != 0);
if (name[0] == ':' && name[1] == ':') {
/* Absolute namespace */
while (*++name == ':') {
}
return Jim_NewStringObj(interp, name, -1);
}
if (Jim_Length(nsObj) == 0) {
/* Relative to the global namespace */
return nameObj;
}
/* Relative to non-global namespace */
objPtr = Jim_DuplicateObj(interp, nsObj);
Jim_AppendString(interp, objPtr, "::", 2);
Jim_AppendObj(interp, objPtr, nameObj);
return objPtr;
}
/* Poor man's implementation of exec with system()
* The system() call *may* do command line redirection, etc.
* The standard output is not available.
* Can't redirect filehandles.
*/
static int Jim_ExecCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
Jim_Obj *cmdlineObj = Jim_NewEmptyStringObj(interp);
int i, j;
int rc;
/* Create a quoted command line */
for (i = 1; i < argc; i++) {
int len;
const char *arg = Jim_GetString(argv[i], &len);
if (i > 1) {
Jim_AppendString(interp, cmdlineObj, " ", 1);
}
if (strpbrk(arg, "\\\" ") == NULL) {
/* No quoting required */
Jim_AppendString(interp, cmdlineObj, arg, len);
continue;
}
Jim_AppendString(interp, cmdlineObj, "\"", 1);
for (j = 0; j < len; j++) {
if (arg[j] == '\\' || arg[j] == '"') {
Jim_AppendString(interp, cmdlineObj, "\\", 1);
}
Jim_AppendString(interp, cmdlineObj, &arg[j], 1);
}
Jim_AppendString(interp, cmdlineObj, "\"", 1);
}
rc = system(Jim_String(cmdlineObj));
Jim_FreeNewObj(interp, cmdlineObj);
if (rc) {
Jim_Obj *errorCode = Jim_NewListObj(interp, NULL, 0);
Jim_ListAppendElement(interp, errorCode, Jim_NewStringObj(interp, "CHILDSTATUS", -1));
Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, 0));
Jim_ListAppendElement(interp, errorCode, Jim_NewIntObj(interp, rc));
Jim_SetGlobalVariableStr(interp, "errorCode", errorCode);
return JIM_ERR;
}
return JIM_OK;
}
static Jim_Obj *JimSqliteFormatQuery(Jim_Interp *interp, Jim_Obj *fmtObjPtr,
int objc, Jim_Obj *const *objv)
{
const char *fmt;
int fmtLen;
Jim_Obj *resObjPtr;
fmt = Jim_GetString(fmtObjPtr, &fmtLen);
resObjPtr = Jim_NewStringObj(interp, "", 0);
while (fmtLen) {
const char *p = fmt;
char spec[2];
while (*fmt != '%' && fmtLen) {
fmt++;
fmtLen--;
}
Jim_AppendString(interp, resObjPtr, p, fmt - p);
if (fmtLen == 0)
break;
fmt++;
fmtLen--; /* skip '%' */
if (*fmt != '%') {
if (objc == 0) {
Jim_FreeNewObj(interp, resObjPtr);
Jim_SetResultString(interp, "not enough arguments for all format specifiers", -1);
return NULL;
}
else {
objc--;
}
}
switch (*fmt) {
case 's':
{
const char *str;
char *quoted;
int len, newLen;
str = Jim_GetString(objv[0], &len);
quoted = JimSqliteQuoteString(str, len, &newLen);
Jim_AppendString(interp, resObjPtr, quoted, newLen);
Jim_Free(quoted);
}
objv++;
break;
case '%':
Jim_AppendString(interp, resObjPtr, "%", 1);
break;
default:
spec[0] = *fmt;
spec[1] = '\0';
Jim_FreeNewObj(interp, resObjPtr);
Jim_SetResultFormatted(interp,
"bad field specifier \"%s\", only %%s and %%%% are valid", spec);
return NULL;
}
fmt++;
fmtLen--;
}
return resObjPtr;
}
/* Calls to [aio.file] create commands that are implemented by this
* C command. */
static int JimAioHandlerCommand(Jim_Interp *interp, int argc,
Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
int option;
const char *options[] = {
"close",
"seek", "tell",
"gets", "read", "puts",
"flush", "eof",
"ndelay",
"readable", "writable", "onexception",
"accept",
NULL
};
enum {OPT_CLOSE,
OPT_SEEK, OPT_TELL,
OPT_GETS, OPT_READ, OPT_PUTS,
OPT_FLUSH, OPT_EOF,
OPT_NDELAY,
OPT_READABLE, OPT_WRITABLE, OPT_EXCEPTION,
OPT_ACCEPT
};
if (argc < 2) {
Jim_WrongNumArgs(interp, 1, argv, "method ?args ...?");
return JIM_ERR;
}
if (Jim_GetEnum(interp, argv[1], options, &option, "AIO method",
JIM_ERRMSG) != JIM_OK)
return JIM_ERR;
/* CLOSE */
if (option == OPT_CLOSE) {
if (argc != 2) {
Jim_WrongNumArgs(interp, 2, argv, "");
return JIM_ERR;
}
Jim_DeleteCommand(interp, Jim_GetString(argv[0], NULL));
return JIM_OK;
} else if (option == OPT_SEEK) {
/* SEEK */
int orig = SEEK_SET;
long offset;
if (argc != 3 && argc != 4) {
Jim_WrongNumArgs(interp, 2, argv, "offset ?origin?");
return JIM_ERR;
}
if (argc == 4) {
if (Jim_CompareStringImmediate(interp, argv[3], "start"))
orig = SEEK_SET;
else if (Jim_CompareStringImmediate(interp, argv[3], "current"))
orig = SEEK_CUR;
else if (Jim_CompareStringImmediate(interp, argv[3], "end"))
orig = SEEK_END;
else {
Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
Jim_AppendStrings(interp, Jim_GetResult(interp),
"bad origin \"", Jim_GetString(argv[3], NULL),
"\" must be: start, current, or end", NULL);
return JIM_ERR;
}
}
if (Jim_GetLong(interp, argv[2], &offset) != JIM_OK)
return JIM_ERR;
if (fseek(af->fp, offset, orig) == -1) {
JimAioSetError(interp);
return JIM_ERR;
}
return JIM_OK;
} else if (option == OPT_TELL) {
/* TELL */
long position;
if (argc != 2) {
Jim_WrongNumArgs(interp, 2, argv, "");
return JIM_ERR;
}
position = ftell(af->fp);
Jim_SetResult(interp, Jim_NewIntObj(interp, position));
return JIM_OK;
} else if (option == OPT_GETS) {
/* GETS */
char buf[AIO_BUF_LEN];
Jim_Obj *objPtr;
if (argc != 2 && argc != 3) {
Jim_WrongNumArgs(interp, 2, argv, "?varName?");
return JIM_ERR;
}
objPtr = Jim_NewStringObj(interp, NULL, 0);
while (1) {
int more = 0;
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')
more = 1;
if (more) {
Jim_AppendString(interp, objPtr, buf, AIO_BUF_LEN-1);
} else {
/* strip "\n" */
Jim_AppendString(interp, objPtr, buf, strlen(buf)-1);
}
if (!more)
break;
}
if (ferror(af->fp) && (errno != EAGAIN)) {
/* I/O error */
Jim_IncrRefCount(objPtr);
Jim_DecrRefCount(interp, objPtr);
JimAioSetError(interp);
return JIM_ERR;
}
/* On EOF returns -1 if varName was specified, or the empty string. */
if (feof(af->fp) && Jim_Length(objPtr) == 0) {
Jim_IncrRefCount(objPtr);
Jim_DecrRefCount(interp, objPtr);
if (argc == 3)
Jim_SetResult(interp, Jim_NewIntObj(interp, -1));
return JIM_OK;
}
if (argc == 3) {
int totLen;
Jim_GetString(objPtr, &totLen);
if (Jim_SetVariable(interp, argv[2], objPtr) != JIM_OK) {
Jim_IncrRefCount(objPtr);
Jim_DecrRefCount(interp, objPtr);
return JIM_ERR;
}
Jim_SetResult(interp, Jim_NewIntObj(interp, totLen));
} else {
Jim_SetResult(interp, objPtr);
}
return JIM_OK;
} else if (option == OPT_READ) {
/* READ */
char buf[AIO_BUF_LEN];
Jim_Obj *objPtr;
int nonewline = 0;
int neededLen = -1; /* -1 is "read as much as possible" */
if (argc != 2 && argc != 3) {
Jim_WrongNumArgs(interp, 2, argv, "?-nonewline? ?len?");
return JIM_ERR;
}
if (argc == 3 &&
Jim_CompareStringImmediate(interp, argv[2], "-nonewline"))
{
nonewline = 1;
argv++;
argc--;
}
if (argc == 3) {
jim_wide wideValue;
if (Jim_GetWide(interp, argv[2], &wideValue) != JIM_OK)
return JIM_ERR;
if (wideValue < 0) {
Jim_SetResultString(interp, "invalid parameter: negative len",
-1);
return JIM_ERR;
}
neededLen = (int) wideValue;
}
objPtr = Jim_NewStringObj(interp, NULL, 0);
while (neededLen != 0) {
int retval;
int readlen;
if (neededLen == -1) {
readlen = AIO_BUF_LEN;
} else {
readlen = (neededLen > AIO_BUF_LEN ? AIO_BUF_LEN : neededLen);
}
retval = fread(buf, 1, readlen, af->fp);
if (retval > 0) {
Jim_AppendString(interp, objPtr, buf, retval);
if (neededLen != -1) {
neededLen -= retval;
}
}
if (retval != readlen) break;
}
/* Check for error conditions */
if (ferror(af->fp)) {
/* I/O error */
Jim_FreeNewObj(interp, objPtr);
JimAioSetError(interp);
return JIM_ERR;
}
if (nonewline) {
int len;
const char *s = Jim_GetString(objPtr, &len);
if (len > 0 && s[len-1] == '\n') {
objPtr->length--;
objPtr->bytes[objPtr->length] = '\0';
}
}
Jim_SetResult(interp, objPtr);
return JIM_OK;
} else if (option == OPT_PUTS) {
/* PUTS */
int wlen;
const char *wdata;
if (argc != 3 && (argc != 4 || !Jim_CompareStringImmediate(
interp, argv[2], "-nonewline"))) {
Jim_WrongNumArgs(interp, 2, argv, "?-nonewline? string");
return JIM_ERR;
}
wdata = Jim_GetString(argv[2+(argc==4)], &wlen);
if (fwrite(wdata, 1, wlen, af->fp) != (unsigned)wlen ||
(argc == 3 && fwrite("\n", 1, 1, af->fp) != 1)) {
JimAioSetError(interp);
return JIM_ERR;
}
return JIM_OK;
} else if (option == OPT_FLUSH) {
/* FLUSH */
if (argc != 2) {
Jim_WrongNumArgs(interp, 2, argv, "");
return JIM_ERR;
}
if (fflush(af->fp) == EOF) {
JimAioSetError(interp);
return JIM_ERR;
}
return JIM_OK;
} else if (option == OPT_EOF) {
/* EOF */
if (argc != 2) {
Jim_WrongNumArgs(interp, 2, argv, "");
return JIM_ERR;
}
Jim_SetResult(interp, Jim_NewIntObj(interp, feof(af->fp)));
return JIM_OK;
} else if (option == OPT_NDELAY) {
#ifdef O_NDELAY
int fmode = af->flags;
if (argc == 3) {
jim_wide wideValue;
if (Jim_GetWide(interp, argv[2], &wideValue) != JIM_OK)
return JIM_ERR;
switch (wideValue) {
case 0:
fmode &= ~O_NDELAY; break ;
case 1:
fmode |= O_NDELAY; break ;
}
fcntl(af->fd,F_SETFL,fmode);
af->flags = fmode;
}
Jim_SetResult(interp, Jim_NewIntObj(interp, (fmode & O_NONBLOCK)?1:0));
return JIM_OK;
#else
return JIM_ERR;
#endif
} else if ( (option == OPT_READABLE)
|| (option == OPT_WRITABLE)
|| (option == OPT_EXCEPTION)
) {
int mask = 0;
Jim_Obj **scrListObjpp = NULL;
Jim_Obj *listObj;
const char *dummy = NULL;
int scrlen = 0;
if (!(Jim_CreateFileHandler && Jim_DeleteFileHandler)) {
Jim_SetResultString(interp, "Eventloop not present ( or loaded too late ) !", -1);
return JIM_ERR;
}
switch (option) {
case OPT_READABLE: mask = JIM_EVENT_READABLE; scrListObjpp = &af->rEvent;
if (argc == 4) mask |= JIM_EVENT_FEOF ; break;
case OPT_WRITABLE: mask = JIM_EVENT_WRITABLE; scrListObjpp = &af->wEvent; break;
case OPT_EXCEPTION: mask = JIM_EVENT_EXCEPTION; scrListObjpp = &af->eEvent; break;
}
switch (argc) {
case 4:
case 3:
if (*scrListObjpp) {
Jim_DeleteFileHandler(interp, af->fp); //,mask);
Jim_DecrRefCount(interp, *scrListObjpp);
*scrListObjpp = NULL;
}
if ( dummy = Jim_GetString(argv[2],&scrlen),(scrlen == 0)) {
break;
} else {
*scrListObjpp = Jim_NewListObj(interp, NULL, 0);
Jim_IncrRefCount(*scrListObjpp);
// fprintf(stderr,"0 %p \n",*scrListObjpp);
listObj = argv[2];
if (Jim_IsShared(listObj))
listObj = Jim_DuplicateObj(interp, listObj);
// Jim_IncrRefCount(listObj);
// fprintf(stderr,"script:\"%s\" argp: %p objp1: %p\n", Jim_GetString(argv[2], NULL),argv[2],listObj);
// fprintf(stderr,"1");
Jim_ListAppendElement(interp,*scrListObjpp,listObj);
// fprintf(stderr,"2");
if (mask & JIM_EVENT_FEOF) {
listObj = argv[3];
if (Jim_IsShared(listObj))
listObj = Jim_DuplicateObj(interp, listObj);
// Jim_IncrRefCount(listObj);
// fprintf(stderr,"script:\"%s\" argp: %p objp2: %p\n", Jim_GetString(argv[3], NULL),argv[3],listObj);
// fprintf(stderr,"3");
Jim_ListAppendElement(interp,*scrListObjpp,listObj);
// fprintf(stderr,"4");
}
// fprintf(stderr,"event readable fd: %d, script:\"%s\" objp3: %p\n",af->fd, Jim_GetString(argv[2], NULL),argv[2]);
Jim_IncrRefCount(*scrListObjpp);
// fprintf(stderr,"6 %p \n",Jim_CreateFileHandler);
Jim_CreateFileHandler(interp, af->fp, mask,
JimAioFileEventHandler,
*scrListObjpp,
JimAioFileEventFinalizer);
// fprintf(stderr,"7");
}
break;
case 2:
if (*scrListObjpp)
Jim_SetResult(interp,*scrListObjpp);
return JIM_OK;
default:
Jim_WrongNumArgs(interp, 2, argv, "");
return JIM_ERR;
}
} else if (option == OPT_ACCEPT) {
int ret;
fprintf(stderr,"ACCEPT\n");
ret = JimAioAcceptHelper(interp,af);
fprintf(stderr,"ret %d\n",ret);
return (ret);
}
return JIM_OK;
}
static void tcl_output(void *privData, const char *file, unsigned line,
const char *function, const char *string)
{
struct log_capture_state *state = privData;
Jim_AppendString(state->interp, state->output, string, strlen(string));
}
static int aio_cmd_read(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
char buf[AIO_BUF_LEN];
Jim_Obj *objPtr;
int nonewline = 0;
int neededLen = -1; /* -1 is "read as much as possible" */
if (argc && Jim_CompareStringImmediate(interp, argv[0], "-nonewline")) {
nonewline = 1;
argv++;
argc--;
}
if (argc == 1) {
jim_wide wideValue;
if (Jim_GetWide(interp, argv[0], &wideValue) != JIM_OK)
return JIM_ERR;
if (wideValue < 0) {
Jim_SetResultString(interp, "invalid parameter: negative len", -1);
return JIM_ERR;
}
neededLen = (int)wideValue;
}
else if (argc) {
return -1;
}
objPtr = Jim_NewStringObj(interp, NULL, 0);
while (neededLen != 0) {
int retval;
int readlen;
if (neededLen == -1) {
readlen = AIO_BUF_LEN;
}
else {
readlen = (neededLen > AIO_BUF_LEN ? AIO_BUF_LEN : neededLen);
}
retval = fread(buf, 1, readlen, af->fp);
if (retval > 0) {
Jim_AppendString(interp, objPtr, buf, retval);
if (neededLen != -1) {
neededLen -= retval;
}
}
if (retval != readlen)
break;
}
/* Check for error conditions */
if (JimCheckStreamError(interp, af)) {
Jim_FreeNewObj(interp, objPtr);
return JIM_ERR;
}
if (nonewline) {
int len;
const char *s = Jim_GetString(objPtr, &len);
if (len > 0 && s[len - 1] == '\n') {
objPtr->length--;
objPtr->bytes[objPtr->length] = '\0';
}
}
Jim_SetResult(interp, objPtr);
return JIM_OK;
}
int Jim_InteractivePrompt(Jim_Interp *interp)
{
int retcode = JIM_OK;
char *history_file = NULL;
#ifdef USE_LINENOISE
const char *home;
home = getenv("HOME");
if (home && isatty(STDIN_FILENO)) {
int history_len = strlen(home) + sizeof("/.jim_history");
history_file = Jim_Alloc(history_len);
snprintf(history_file, history_len, "%s/.jim_history", home);
Jim_HistoryLoad(history_file);
}
#endif
printf("Welcome to Jim version %d.%d" JIM_NL,
JIM_VERSION / 100, JIM_VERSION % 100);
Jim_SetVariableStrWithStr(interp, JIM_INTERACTIVE, "1");
while (1) {
Jim_Obj *scriptObjPtr;
const char *result;
int reslen;
char prompt[20];
const char *str;
if (retcode != 0) {
const char *retcodestr = Jim_ReturnCode(retcode);
if (*retcodestr == '?') {
snprintf(prompt, sizeof(prompt) - 3, "[%d] ", retcode);
}
else {
snprintf(prompt, sizeof(prompt) - 3, "[%s] ", retcodestr);
}
}
else {
prompt[0] = '\0';
}
strcat(prompt, ". ");
scriptObjPtr = Jim_NewStringObj(interp, "", 0);
Jim_IncrRefCount(scriptObjPtr);
while (1) {
char state;
int len;
char *line;
line = Jim_HistoryGetline(prompt);
if (line == NULL) {
if (errno == EINTR) {
continue;
}
Jim_DecrRefCount(interp, scriptObjPtr);
retcode = JIM_OK;
goto out;
}
if (Jim_Length(scriptObjPtr) != 0) {
Jim_AppendString(interp, scriptObjPtr, "\n", 1);
}
Jim_AppendString(interp, scriptObjPtr, line, -1);
free(line);
str = Jim_GetString(scriptObjPtr, &len);
if (len == 0) {
continue;
}
if (Jim_ScriptIsComplete(str, len, &state))
break;
snprintf(prompt, sizeof(prompt), "%c> ", state);
}
#ifdef USE_LINENOISE
if (strcmp(str, "h") == 0) {
/* built-in history command */
Jim_HistoryShow();
Jim_DecrRefCount(interp, scriptObjPtr);
continue;
}
Jim_HistoryAdd(Jim_String(scriptObjPtr));
if (history_file) {
Jim_HistorySave(history_file);
}
#endif
retcode = Jim_EvalObj(interp, scriptObjPtr);
Jim_DecrRefCount(interp, scriptObjPtr);
if (retcode == JIM_EXIT) {
retcode = JIM_EXIT;
break;
}
if (retcode == JIM_ERR) {
Jim_MakeErrorMessage(interp);
}
result = Jim_GetString(Jim_GetResult(interp), &reslen);
if (reslen) {
printf("%s\n", result);
}
}
out:
Jim_Free(history_file);
return retcode;
}
static Jim_Obj *
JimWinBuildCommandLine(Jim_Interp *interp, char **argv)
{
char *start, *special;
int quote, i;
Jim_Obj *strObj = Jim_NewStringObj(interp, "", 0);
for (i = 0; argv[i]; i++) {
if (i > 0) {
Jim_AppendString(interp, strObj, " ", 1);
}
if (argv[i][0] == '\0') {
quote = 1;
}
else {
quote = 0;
for (start = argv[i]; *start != '\0'; start++) {
if (isspace(UCHAR(*start))) {
quote = 1;
break;
}
}
}
if (quote) {
Jim_AppendString(interp, strObj, "\"" , 1);
}
start = argv[i];
for (special = argv[i]; ; ) {
if ((*special == '\\') && (special[1] == '\\' ||
special[1] == '"' || (quote && special[1] == '\0'))) {
Jim_AppendString(interp, strObj, start, special - start);
start = special;
while (1) {
special++;
if (*special == '"' || (quote && *special == '\0')) {
/*
* N backslashes followed a quote -> insert
* N * 2 + 1 backslashes then a quote.
*/
Jim_AppendString(interp, strObj, start, special - start);
break;
}
if (*special != '\\') {
break;
}
}
Jim_AppendString(interp, strObj, start, special - start);
start = special;
}
if (*special == '"') {
if (special == start) {
Jim_AppendString(interp, strObj, "\"", 1);
}
else {
Jim_AppendString(interp, strObj, start, special - start);
}
Jim_AppendString(interp, strObj, "\\\"", 2);
start = special + 1;
}
if (*special == '\0') {
break;
}
special++;
}
Jim_AppendString(interp, strObj, start, special - start);
if (quote) {
Jim_AppendString(interp, strObj, "\"", 1);
}
}
return strObj;
}
static int JimELAfterCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
Jim_EventLoop *eventLoop = Jim_CmdPrivData(interp);
double ms = 0;
jim_wide id;
Jim_Obj *objPtr, *idObjPtr;
static const char * const options[] = {
"cancel", "info", "idle", NULL
};
enum
{ AFTER_CANCEL, AFTER_INFO, AFTER_IDLE, AFTER_RESTART, AFTER_EXPIRE, AFTER_CREATE };
int option = AFTER_CREATE;
if (argc < 2) {
Jim_WrongNumArgs(interp, 1, argv, "option ?arg ...?");
return JIM_ERR;
}
if (Jim_GetDouble(interp, argv[1], &ms) != JIM_OK) {
if (Jim_GetEnum(interp, argv[1], options, &option, "argument", JIM_ERRMSG) != JIM_OK) {
return JIM_ERR;
}
Jim_SetEmptyResult(interp);
}
else if (argc == 2) {
/* Simply a sleep */
usleep(ms * 1000);
return JIM_OK;
}
switch (option) {
case AFTER_IDLE:
if (argc < 3) {
Jim_WrongNumArgs(interp, 2, argv, "script ?script ...?");
return JIM_ERR;
}
/* fall through */
case AFTER_CREATE: {
Jim_Obj *scriptObj = Jim_ConcatObj(interp, argc - 2, argv + 2);
Jim_IncrRefCount(scriptObj);
id = Jim_CreateTimeHandler(interp, (jim_wide)(ms * 1000), JimAfterTimeHandler, scriptObj,
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 AFTER_CANCEL:
if (argc < 3) {
Jim_WrongNumArgs(interp, 2, argv, "id|command");
return JIM_ERR;
}
else {
jim_wide remain = 0;
id = JimParseAfterId(argv[2]);
if (id <= 0) {
/* Not an event id, so search by script */
Jim_Obj *scriptObj = Jim_ConcatObj(interp, argc - 2, argv + 2);
id = JimFindAfterByScript(eventLoop, scriptObj);
Jim_FreeNewObj(interp, scriptObj);
if (id <= 0) {
/* Not found */
break;
}
}
remain = Jim_DeleteTimeHandler(interp, id);
if (remain >= 0) {
Jim_SetResultInt(interp, remain);
}
}
break;
case AFTER_INFO:
if (argc == 2) {
Jim_TimeEvent *te = eventLoop->timeEventHead;
Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
char buf[30];
const char *fmt = "after#%" JIM_WIDE_MODIFIER;
while (te) {
snprintf(buf, sizeof(buf), fmt, te->id);
Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, buf, -1));
te = te->next;
}
Jim_SetResult(interp, listObj);
}
else if (argc == 3) {
id = JimParseAfterId(argv[2]);
if (id >= 0) {
Jim_TimeEvent *e = JimFindTimeHandlerById(eventLoop, id);
if (e && e->timeProc == JimAfterTimeHandler) {
Jim_Obj *listObj = Jim_NewListObj(interp, NULL, 0);
Jim_ListAppendElement(interp, listObj, e->clientData);
Jim_ListAppendElement(interp, listObj, Jim_NewStringObj(interp, e->initialus ? "timer" : "idle", -1));
Jim_SetResult(interp, listObj);
return JIM_OK;
}
}
Jim_SetResultFormatted(interp, "event \"%#s\" doesn't exist", argv[2]);
return JIM_ERR;
}
else {
Jim_WrongNumArgs(interp, 2, argv, "?id?");
return JIM_ERR;
}
break;
}
return JIM_OK;
}
int Jim_RegsubCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
int regcomp_flags = 0;
int regexec_flags = 0;
int opt_all = 0;
int offset = 0;
regex_t *regex;
const char *p;
int result;
regmatch_t pmatch[MAX_SUB_MATCHES + 1];
int num_matches = 0;
int i, j, n;
Jim_Obj *varname;
Jim_Obj *resultObj;
const char *source_str;
int source_len;
const char *replace_str;
int replace_len;
const char *pattern;
int option;
enum {
OPT_NOCASE, OPT_LINE, OPT_ALL, OPT_START, OPT_END
};
static const char * const options[] = {
"-nocase", "-line", "-all", "-start", "--", NULL
};
if (argc < 4) {
wrongNumArgs:
Jim_WrongNumArgs(interp, 1, argv,
"?-switch ...? exp string subSpec ?varName?");
return JIM_ERR;
}
for (i = 1; i < argc; i++) {
const char *opt = Jim_String(argv[i]);
if (*opt != '-') {
break;
}
if (Jim_GetEnum(interp, argv[i], options, &option, "switch", JIM_ERRMSG | JIM_ENUM_ABBREV) != JIM_OK) {
return JIM_ERR;
}
if (option == OPT_END) {
i++;
break;
}
switch (option) {
case OPT_NOCASE:
regcomp_flags |= REG_ICASE;
break;
case OPT_LINE:
regcomp_flags |= REG_NEWLINE;
break;
case OPT_ALL:
opt_all = 1;
break;
case OPT_START:
if (++i == argc) {
goto wrongNumArgs;
}
if (Jim_GetIndex(interp, argv[i], &offset) != JIM_OK) {
return JIM_ERR;
}
break;
}
}
if (argc - i != 3 && argc - i != 4) {
goto wrongNumArgs;
}
regex = SetRegexpFromAny(interp, argv[i], regcomp_flags);
if (!regex) {
return JIM_ERR;
}
pattern = Jim_String(argv[i]);
source_str = Jim_GetString(argv[i + 1], &source_len);
replace_str = Jim_GetString(argv[i + 2], &replace_len);
varname = argv[i + 3];
/* Create the result string */
resultObj = Jim_NewStringObj(interp, "", 0);
/* If an offset has been specified, adjust for that now.
* If it points past the end of the string, point to the terminating null
*/
if (offset) {
if (offset < 0) {
offset += source_len + 1;
}
if (offset > source_len) {
offset = source_len;
}
else if (offset < 0) {
offset = 0;
}
}
/* Copy the part before -start */
Jim_AppendString(interp, resultObj, source_str, offset);
/*
* The following loop is to handle multiple matches within the
* same source string; each iteration handles one match and its
* corresponding substitution. If "-all" hasn't been specified
* then the loop body only gets executed once.
*/
n = source_len - offset;
p = source_str + offset;
do {
int match = regexec(regex, p, MAX_SUB_MATCHES, pmatch, regexec_flags);
if (match >= REG_BADPAT) {
char buf[100];
regerror(match, regex, buf, sizeof(buf));
Jim_SetResultFormatted(interp, "error while matching pattern: %s", buf);
return JIM_ERR;
}
if (match == REG_NOMATCH) {
break;
}
num_matches++;
/*
* Copy the portion of the source string before the match to the
* result variable.
*/
Jim_AppendString(interp, resultObj, p, pmatch[0].rm_so);
/*
* Append the subSpec (replace_str) argument to the variable, making appropriate
* substitutions. This code is a bit hairy because of the backslash
* conventions and because the code saves up ranges of characters in
* subSpec to reduce the number of calls to Jim_SetVar.
*/
for (j = 0; j < replace_len; j++) {
int idx;
int c = replace_str[j];
if (c == '&') {
idx = 0;
}
else if (c == '\\' && j < replace_len) {
c = replace_str[++j];
if ((c >= '0') && (c <= '9')) {
idx = c - '0';
}
else if ((c == '\\') || (c == '&')) {
Jim_AppendString(interp, resultObj, replace_str + j, 1);
continue;
}
else {
/* If the replacement is a trailing backslash, just replace with a backslash, otherwise
* with the literal backslash and the following character
*/
Jim_AppendString(interp, resultObj, replace_str + j - 1, (j == replace_len) ? 1 : 2);
continue;
}
}
else {
Jim_AppendString(interp, resultObj, replace_str + j, 1);
continue;
}
if ((idx < MAX_SUB_MATCHES) && pmatch[idx].rm_so != -1 && pmatch[idx].rm_eo != -1) {
Jim_AppendString(interp, resultObj, p + pmatch[idx].rm_so,
pmatch[idx].rm_eo - pmatch[idx].rm_so);
}
}
p += pmatch[0].rm_eo;
n -= pmatch[0].rm_eo;
/* If -all is not specified, or there is no source left, we are done */
if (!opt_all || n == 0) {
break;
}
/* An anchored pattern without -line must be done */
if ((regcomp_flags & REG_NEWLINE) == 0 && pattern[0] == '^') {
break;
}
/* If the pattern is empty, need to step forwards */
if (pattern[0] == '\0' && n) {
/* Need to copy the char we are moving over */
Jim_AppendString(interp, resultObj, p, 1);
p++;
n--;
}
regexec_flags |= REG_NOTBOL;
} while (n);
/*
* Copy the portion of the string after the last match to the
* result variable.
*/
Jim_AppendString(interp, resultObj, p, -1);
/* And now set or return the result variable */
if (argc - i == 4) {
result = Jim_SetVariable(interp, varname, resultObj);
if (result == JIM_OK) {
Jim_SetResultInt(interp, num_matches);
}
else {
Jim_FreeObj(interp, resultObj);
}
}
else {
Jim_SetResult(interp, resultObj);
result = JIM_OK;
}
return result;
}
int Jim_RegexpCmd(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
int opt_indices = 0;
int opt_all = 0;
int opt_inline = 0;
regex_t *regex;
int match, i, j;
int offset = 0;
regmatch_t *pmatch = NULL;
int source_len;
int result = JIM_OK;
const char *pattern;
const char *source_str;
int num_matches = 0;
int num_vars;
Jim_Obj *resultListObj = NULL;
int regcomp_flags = 0;
int eflags = 0;
int option;
enum {
OPT_INDICES, OPT_NOCASE, OPT_LINE, OPT_ALL, OPT_INLINE, OPT_START, OPT_END
};
static const char * const options[] = {
"-indices", "-nocase", "-line", "-all", "-inline", "-start", "--", NULL
};
if (argc < 3) {
wrongNumArgs:
Jim_WrongNumArgs(interp, 1, argv,
"?-switch ...? exp string ?matchVar? ?subMatchVar ...?");
return JIM_ERR;
}
for (i = 1; i < argc; i++) {
const char *opt = Jim_String(argv[i]);
if (*opt != '-') {
break;
}
if (Jim_GetEnum(interp, argv[i], options, &option, "switch", JIM_ERRMSG | JIM_ENUM_ABBREV) != JIM_OK) {
return JIM_ERR;
}
if (option == OPT_END) {
i++;
break;
}
switch (option) {
case OPT_INDICES:
opt_indices = 1;
break;
case OPT_NOCASE:
regcomp_flags |= REG_ICASE;
break;
case OPT_LINE:
regcomp_flags |= REG_NEWLINE;
break;
case OPT_ALL:
opt_all = 1;
break;
case OPT_INLINE:
opt_inline = 1;
break;
case OPT_START:
if (++i == argc) {
goto wrongNumArgs;
}
if (Jim_GetIndex(interp, argv[i], &offset) != JIM_OK) {
return JIM_ERR;
}
break;
}
}
if (argc - i < 2) {
goto wrongNumArgs;
}
regex = SetRegexpFromAny(interp, argv[i], regcomp_flags);
if (!regex) {
return JIM_ERR;
}
pattern = Jim_String(argv[i]);
source_str = Jim_GetString(argv[i + 1], &source_len);
num_vars = argc - i - 2;
if (opt_inline) {
if (num_vars) {
Jim_SetResultString(interp, "regexp match variables not allowed when using -inline",
-1);
result = JIM_ERR;
goto done;
}
num_vars = regex->re_nsub + 1;
}
pmatch = Jim_Alloc((num_vars + 1) * sizeof(*pmatch));
/* If an offset has been specified, adjust for that now.
* If it points past the end of the string, point to the terminating null
*/
if (offset) {
if (offset < 0) {
offset += source_len + 1;
}
if (offset > source_len) {
source_str += source_len;
}
else if (offset > 0) {
source_str += offset;
}
eflags |= REG_NOTBOL;
}
if (opt_inline) {
resultListObj = Jim_NewListObj(interp, NULL, 0);
}
next_match:
match = regexec(regex, source_str, num_vars + 1, pmatch, eflags);
if (match >= REG_BADPAT) {
char buf[100];
regerror(match, regex, buf, sizeof(buf));
Jim_SetResultFormatted(interp, "error while matching pattern: %s", buf);
result = JIM_ERR;
goto done;
}
if (match == REG_NOMATCH) {
goto done;
}
num_matches++;
if (opt_all && !opt_inline) {
/* Just count the number of matches, so skip the substitution h */
goto try_next_match;
}
/*
* If additional variable names have been specified, return
* index information in those variables.
*/
j = 0;
for (i += 2; opt_inline ? j < num_vars : i < argc; i++, j++) {
Jim_Obj *resultObj;
if (opt_indices) {
resultObj = Jim_NewListObj(interp, NULL, 0);
}
else {
resultObj = Jim_NewStringObj(interp, "", 0);
}
if (pmatch[j].rm_so == -1) {
if (opt_indices) {
Jim_ListAppendElement(interp, resultObj, Jim_NewIntObj(interp, -1));
Jim_ListAppendElement(interp, resultObj, Jim_NewIntObj(interp, -1));
}
}
else {
int len = pmatch[j].rm_eo - pmatch[j].rm_so;
if (opt_indices) {
Jim_ListAppendElement(interp, resultObj, Jim_NewIntObj(interp,
offset + pmatch[j].rm_so));
Jim_ListAppendElement(interp, resultObj, Jim_NewIntObj(interp,
offset + pmatch[j].rm_so + len - 1));
}
else {
Jim_AppendString(interp, resultObj, source_str + pmatch[j].rm_so, len);
}
}
if (opt_inline) {
Jim_ListAppendElement(interp, resultListObj, resultObj);
}
else {
/* And now set the result variable */
result = Jim_SetVariable(interp, argv[i], resultObj);
if (result != JIM_OK) {
Jim_FreeObj(interp, resultObj);
break;
}
}
}
try_next_match:
if (opt_all && (pattern[0] != '^' || (regcomp_flags & REG_NEWLINE)) && *source_str) {
if (pmatch[0].rm_eo) {
offset += pmatch[0].rm_eo;
source_str += pmatch[0].rm_eo;
}
else {
source_str++;
offset++;
}
if (*source_str) {
eflags = REG_NOTBOL;
goto next_match;
}
}
done:
if (result == JIM_OK) {
if (opt_inline) {
Jim_SetResult(interp, resultListObj);
}
else {
Jim_SetResultInt(interp, num_matches);
}
}
Jim_Free(pmatch);
return result;
}
/* Calls to [aio.file] create commands that are implemented by this
* C command. */
static int JimAioHandlerCommand(Jim_Interp *interp, int argc,
Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
int option;
const char *options[] = {
"close", "seek", "tell", "gets", "read", "puts", "flush", "eof", NULL
};
enum {OPT_CLOSE, OPT_SEEK, OPT_TELL, OPT_GETS, OPT_READ, OPT_PUTS,
OPT_FLUSH, OPT_EOF
};
if (argc < 2) {
Jim_WrongNumArgs(interp, 1, argv, "method ?args ...?");
return JIM_ERR;
}
if (Jim_GetEnum(interp, argv[1], options, &option, "AIO method",
JIM_ERRMSG) != JIM_OK)
return JIM_ERR;
/* CLOSE */
if (option == OPT_CLOSE) {
if (argc != 2) {
Jim_WrongNumArgs(interp, 2, argv, "");
return JIM_ERR;
}
Jim_DeleteCommand(interp, Jim_GetString(argv[0], NULL));
return JIM_OK;
} else if (option == OPT_SEEK) {
/* SEEK */
int orig = SEEK_SET;
long offset;
if (argc != 3 && argc != 4) {
Jim_WrongNumArgs(interp, 2, argv, "offset ?origin?");
return JIM_ERR;
}
if (argc == 4) {
if (Jim_CompareStringImmediate(interp, argv[3], "start"))
orig = SEEK_SET;
else if (Jim_CompareStringImmediate(interp, argv[3], "current"))
orig = SEEK_CUR;
else if (Jim_CompareStringImmediate(interp, argv[3], "end"))
orig = SEEK_END;
else {
Jim_SetResult(interp, Jim_NewEmptyStringObj(interp));
Jim_AppendStrings(interp, Jim_GetResult(interp),
"bad origin \"", Jim_GetString(argv[3], NULL),
"\" must be: start, current, or end", NULL);
return JIM_ERR;
}
}
if (Jim_GetLong(interp, argv[2], &offset) != JIM_OK)
return JIM_ERR;
if (fseek(af->fp, offset, orig) == -1) {
JimAioSetError(interp);
return JIM_ERR;
}
return JIM_OK;
} else if (option == OPT_TELL) {
/* TELL */
long position;
if (argc != 2) {
Jim_WrongNumArgs(interp, 2, argv, "");
return JIM_ERR;
}
position = ftell(af->fp);
Jim_SetResult(interp, Jim_NewIntObj(interp, position));
return JIM_OK;
} else if (option == OPT_GETS) {
/* GETS */
char buf[AIO_BUF_LEN];
Jim_Obj *objPtr;
if (argc != 2 && argc != 3) {
Jim_WrongNumArgs(interp, 2, argv, "?varName?");
return JIM_ERR;
}
objPtr = Jim_NewStringObj(interp, NULL, 0);
while (1) {
int more = 0;
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] == '\n')
more = 1;
if (more) {
Jim_AppendString(interp, objPtr, buf, AIO_BUF_LEN-1);
} else {
/* strip "\n" */
Jim_AppendString(interp, objPtr, buf, strlen(buf)-1);
}
if (!more)
break;
}
if (ferror(af->fp)) {
/* I/O error */
Jim_IncrRefCount(objPtr);
Jim_DecrRefCount(interp, objPtr);
JimAioSetError(interp);
return JIM_ERR;
}
/* On EOF returns -1 if varName was specified, or the empty string. */
if (feof(af->fp) && Jim_Length(objPtr) == 0) {
Jim_IncrRefCount(objPtr);
Jim_DecrRefCount(interp, objPtr);
if (argc == 3)
Jim_SetResult(interp, Jim_NewIntObj(interp, -1));
return JIM_OK;
}
if (argc == 3) {
int totLen;
Jim_GetString(objPtr, &totLen);
if (Jim_SetVariable(interp, argv[2], objPtr) != JIM_OK) {
Jim_IncrRefCount(objPtr);
Jim_DecrRefCount(interp, objPtr);
return JIM_ERR;
}
Jim_SetResult(interp, Jim_NewIntObj(interp, totLen));
} else {
Jim_SetResult(interp, objPtr);
}
return JIM_OK;
} else if (option == OPT_READ) {
/* READ */
char buf[AIO_BUF_LEN];
Jim_Obj *objPtr;
int nonewline = 0;
int neededLen = -1; /* -1 is "read as much as possible" */
if (argc != 2 && argc != 3) {
Jim_WrongNumArgs(interp, 2, argv, "?-nonewline? ?len?");
return JIM_ERR;
}
if (argc == 3 &&
Jim_CompareStringImmediate(interp, argv[2], "-nonewline"))
{
nonewline = 1;
argv++;
argc--;
}
if (argc == 3) {
jim_wide wideValue;
if (Jim_GetWide(interp, argv[2], &wideValue) != JIM_OK)
return JIM_ERR;
if (wideValue < 0) {
Jim_SetResultString(interp, "invalid parameter: negative len",
-1);
return JIM_ERR;
}
neededLen = (int) wideValue;
}
objPtr = Jim_NewStringObj(interp, NULL, 0);
while (neededLen != 0) {
int retval;
int readlen;
if (neededLen == -1) {
readlen = AIO_BUF_LEN;
} else {
readlen = (neededLen > AIO_BUF_LEN ? AIO_BUF_LEN : neededLen);
}
retval = fread(buf, 1, readlen, af->fp);
if (retval > 0) {
Jim_AppendString(interp, objPtr, buf, retval);
if (neededLen != -1) {
neededLen -= retval;
}
}
if (retval != readlen) break;
}
/* Check for error conditions */
if (ferror(af->fp)) {
/* I/O error */
Jim_FreeNewObj(interp, objPtr);
JimAioSetError(interp);
return JIM_ERR;
}
if (nonewline) {
int len;
const char *s = Jim_GetString(objPtr, &len);
if (len > 0 && s[len-1] == '\n') {
objPtr->length--;
objPtr->bytes[objPtr->length] = '\0';
}
}
Jim_SetResult(interp, objPtr);
return JIM_OK;
} else if (option == OPT_PUTS) {
/* PUTS */
int wlen;
const char *wdata;
if (argc != 3 && (argc != 4 || !Jim_CompareStringImmediate(
interp, argv[2], "-nonewline"))) {
Jim_WrongNumArgs(interp, 2, argv, "?-nonewline? string");
return JIM_ERR;
}
wdata = Jim_GetString(argv[2+(argc==4)], &wlen);
if (fwrite(wdata, 1, wlen, af->fp) != (unsigned)wlen ||
(argc == 3 && fwrite("\n", 1, 1, af->fp) != 1)) {
JimAioSetError(interp);
return JIM_ERR;
}
return JIM_OK;
} else if (option == OPT_FLUSH) {
/* FLUSH */
if (argc != 2) {
Jim_WrongNumArgs(interp, 2, argv, "");
return JIM_ERR;
}
if (fflush(af->fp) == EOF) {
JimAioSetError(interp);
return JIM_ERR;
}
return JIM_OK;
} else if (option == OPT_EOF) {
/* EOF */
if (argc != 2) {
Jim_WrongNumArgs(interp, 2, argv, "");
return JIM_ERR;
}
Jim_SetResult(interp, Jim_NewIntObj(interp, feof(af->fp)));
return JIM_OK;
}
return JIM_OK;
}
