static int history_cmd_getline(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
Jim_Obj *objPtr;
char *line = Jim_HistoryGetline(interp, Jim_String(argv[0]));
/* On EOF returns -1 if varName was specified; otherwise the empty string. */
if (line == NULL) {
if (argc == 2) {
Jim_SetResultInt(interp, -1);
}
return JIM_OK;
}
objPtr = Jim_NewStringObjNoAlloc(interp, line, -1);
/* Returns the length of the string if varName was specified */
if (argc == 2) {
if (Jim_SetVariable(interp, argv[1], objPtr) != JIM_OK) {
Jim_FreeNewObj(interp, objPtr);
return JIM_ERR;
}
Jim_SetResultInt(interp, Jim_Length(objPtr));
}
else {
Jim_SetResult(interp, objPtr);
}
return JIM_OK;
}
static int aio_cmd_tell(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
Jim_SetResultInt(interp, ftell(af->fp));
return JIM_OK;
}
static int aio_cmd_sendto(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
int wlen;
int len;
const char *wdata;
union sockaddr_any sa;
const char *addr = Jim_String(argv[1]);
int salen;
if (IPV6 && af->addr_family == PF_INET6) {
if (JimParseIPv6Address(interp, addr, &sa, &salen) != JIM_OK) {
return JIM_ERR;
}
}
else if (JimParseIpAddress(interp, addr, &sa, &salen) != JIM_OK) {
return JIM_ERR;
}
wdata = Jim_GetString(argv[0], &wlen);
/* Note that we don't validate the socket type. Rely on sendto() failing if appropriate */
len = sendto(fileno(af->fp), wdata, wlen, 0, &sa.sa, salen);
if (len < 0) {
JimAioSetError(interp, NULL);
return JIM_ERR;
}
Jim_SetResultInt(interp, len);
return JIM_OK;
}
static int Jim_PosixPidCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
if (argc != 1) {
Jim_WrongNumArgs(interp, 1, argv, "");
return JIM_ERR;
}
Jim_SetResultInt(interp, getpid());
return JIM_OK;
}
static int clock_cmd_micros(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
struct timeval tv;
gettimeofday(&tv, NULL);
Jim_SetResultInt(interp, (jim_wide) tv.tv_sec * 1000000 + tv.tv_usec);
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;
}
static int Jim_PosixUptimeCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
#ifdef HAVE_SYSINFO
struct sysinfo info;
if (argc != 1) {
Jim_WrongNumArgs(interp, 1, argv, "");
return JIM_ERR;
}
if (sysinfo(&info) == -1) {
Jim_PosixSetError(interp);
return JIM_ERR;
}
Jim_SetResultInt(interp, info.uptime);
#else
Jim_SetResultInt(interp, (long)time(NULL));
#endif
return JIM_OK;
}
static int Jim_PosixForkCommand(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
pid_t pid;
JIM_NOTUSED(argv);
if (argc != 1) {
Jim_WrongNumArgs(interp, 1, argv, "");
return JIM_ERR;
}
if ((pid = fork()) == -1) {
Jim_PosixSetError(interp);
return JIM_ERR;
}
Jim_SetResultInt(interp, (jim_wide) pid);
return JIM_OK;
}
static int array_cmd_size(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
Jim_Obj *objPtr;
int len = 0;
/* Not found means zero length */
objPtr = Jim_GetVariable(interp, argv[0], JIM_NONE);
if (objPtr) {
len = Jim_DictSize(interp, objPtr);
if (len < 0) {
return JIM_ERR;
}
}
Jim_SetResultInt(interp, len);
return JIM_OK;
}
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 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;
}
/* 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 clock_cmd_scan(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
char *pt;
struct tm tm;
time_t now = time(0);
if (!Jim_CompareStringImmediate(interp, argv[1], "-format")) {
return -1;
}
/* Initialise with the current date/time */
localtime_r(&now, &tm);
/*@@pt = strptime(Jim_String(argv[0]), Jim_String(argv[2]), &tm);
if (pt == 0 || *pt != 0) {
Jim_SetResultString(interp, "Failed to parse time according to format", -1);
return JIM_ERR;
}*/
/* Now convert into a time_t */
Jim_SetResultInt(interp, mktime(&tm));
return JIM_OK;
}
static int aio_cmd_ndelay(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
AioFile *af = Jim_CmdPrivData(interp);
int fmode = af->flags;
if (argc) {
long nb;
if (Jim_GetLong(interp, argv[0], &nb) != JIM_OK) {
return JIM_ERR;
}
if (nb) {
fmode |= O_NDELAY;
}
else {
fmode &= ~O_NDELAY;
}
fcntl(af->fd, F_SETFL, fmode);
af->flags = fmode;
}
Jim_SetResultInt(interp, (fmode & O_NONBLOCK) ? 1 : 0);
return JIM_OK;
}
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;
}
static int array_cmd_exists(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
/* Just a regular [info exists] */
Jim_SetResultInt(interp, Jim_GetVariable(interp, argv[0], 0) != 0);
return JIM_OK;
}
static int clock_cmd_seconds(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
{
Jim_SetResultInt(interp, time(NULL));
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;
}
