newtRef NsStrExactCompare(newtRefArg rcvr, newtRefArg a, newtRefArg b)
{
char* aString;
char* bString;
newtRefVar theResult;
(void) rcvr;
/* check parameters */
if (! NewtRefIsString(a))
{
theResult = NewtThrow(kNErrNotAString, a);
} else if (! NewtRefIsString(b)) {
theResult = NewtThrow(kNErrNotAString, b);
} else if (a == b) {
theResult = NewtMakeInteger(0);
} else {
aString = NewtRefToString(a);
bString = NewtRefToString(b);
theResult = NewtMakeInteger(strcmp(aString, bString));
}
return theResult;
}
newtRef NsStrEqual(newtRefArg rcvr, newtRefArg a, newtRefArg b)
{
char* aString;
char* bString;
newtRefVar theResult = kNewtRefNIL;
(void) rcvr;
/* check parameters */
if (! NewtRefIsString(a))
{
theResult = NewtThrow(kNErrNotAString, a);
} else if (! NewtRefIsString(b)) {
theResult = NewtThrow(kNErrNotAString, b);
} else if (a == b) {
theResult = kNewtRefTRUE;
} else {
aString = NewtRefToString(a);
bString = NewtRefToString(b);
if (strcasecmp(aString, bString) == 0)
{
theResult = kNewtRefTRUE;
}
}
return theResult;
}
newtRef NsEndsWith(newtRefArg rcvr, newtRefArg str, newtRefArg sub)
{
bool result;
if (! NewtRefIsString(str))
return NewtThrow(kNErrNotAString, str);
if (! NewtRefIsString(sub))
return NewtThrow(kNErrNotAString, sub);
result = NewtEndsWith(NewtRefToString(str), NewtRefToString(sub));
return NewtMakeBoolean(result);
}
newtRef NsGetEnv(newtRefArg rcvr, newtRefArg r)
{
if (! NewtRefIsString(r))
return NewtThrow(kNErrNotAString, r);
return NewtGetEnv(NewtRefToString(r));
}
newtRef NsCompile(newtRefArg rcvr, newtRefArg r)
{
if (! NewtRefIsString(r))
return NewtThrow(kNErrNotAString, r);
return NBCCompileStr(NewtRefToString(r), true);
}
newtRef NsMakeBinaryFromHex(newtRefArg rcvr, newtRefArg hex, newtRefArg klass)
{
if (! NewtRefIsString(hex))
return NewtThrow(kNErrNotAString, hex);
return NewtMakeBinaryFromHex(klass, NewtRefToString(hex), false);
}
newtRef NsStrLen(newtRefArg rcvr, newtRefArg r)
{
if (! NewtRefIsString(r))
return NewtThrow(kNErrNotAString, r);
return NewtMakeInteger(NewtStringLength(r));
}
newtRef protoREGEX_regcomp(newtRefArg pattern, newtRefArg opt)
{
regex_t preg;
int cflags = REG_EXTENDED;
int err;
if (! NewtRefIsString(pattern))
return NewtThrow(kNErrNotAString, pattern);
if (NewtRefIsString(opt))
{
char * optstr;
uint32_t len;
uint32_t i;
optstr = NewtRefToString(opt);
len = NewtLength(opt);
for (i = 0; i < len && optstr[i]; i++)
{
switch (optstr[i])
{
/*
case 'e':
cflags |= REG_EXTENDED;
break;
*/
case 'i':
cflags |= REG_ICASE;
break;
case 'm':
cflags |= REG_NEWLINE;
break;
}
}
}
err = regcomp(&preg, NewtRefToString(pattern), cflags);
if (err != 0)
{
return NewtThrow(kNErrRegcomp, pattern);
}
return NewtMakeBinary(kNewtRefUnbind, (uint8_t *)&preg, sizeof(preg), false);
}
newtRef NsParamStr(newtRefArg rcvr, newtRefArg baseString, newtRefArg paramStrArray)
{
if (! NewtRefIsString(baseString))
return NewtThrow(kNErrNotAString, baseString);
if (! NewtRefIsArray(paramStrArray))
return NewtThrow(kNErrNotAnArray, paramStrArray);
return NewtParamStr(NewtRefToString(baseString), NewtStringLength(baseString), paramStrArray, true);
}
newtRef NsMakeSymbol(newtRefArg rcvr, newtRefArg r)
{
char * s;
if (! NewtRefIsString(r))
return NewtThrow(kNErrNotAString, r);
s = NewtRefToString(r);
return NewtMakeSymbol(s);
}
newtRef NsSplit(newtRefArg rcvr, newtRefArg r, newtRefArg sep)
{
newtRefVar result;
if (! NewtRefIsString(r))
return NewtThrow(kNErrNotAString, r);
switch (NewtGetRefType(sep, true))
{
case kNewtCharacter:
{
newtRefVar v;
char * next;
char * s;
int c;
s = NewtRefToString(r);
c = NewtRefToCharacter(sep);
result = NewtMakeArray(kNewtRefUnbind, 0);
while (*s)
{
next = strchr(s, c);
if (next == NULL) break;
v = NewtMakeString2(s, next - s, false);
NcAddArraySlot(result, v);
s = next + 1;
}
if (s == NewtRefToString(r))
v = r;
else
v = NSSTR(s);
NcAddArraySlot(result, v);
}
break;
default:
{
newtRefVar initObj[] = {r};
result = NewtMakeArray2(kNewtRefNIL, sizeof(initObj) / sizeof(newtRefVar), initObj);
}
break;
}
return result;
}
newtRef NsSubStr(newtRefArg rcvr, newtRefArg r, newtRefArg start, newtRefArg count)
{
char* theString;
char* theBuffer;
int theStart, theEnd;
size_t theLen;
newtRefVar theResult;
(void) rcvr;
/* check parameters */
if (! NewtRefIsString(r))
return NewtThrow(kNErrNotAString, r);
if (! NewtRefIsInteger(start))
return NewtThrow(kNErrNotAnInteger, start);
theString = NewtRefToString(r);
theLen = strlen(theString);
theStart = NewtRefToInteger(start);
if (!NewtRefIsNIL(count))
{
if (!NewtRefIsInteger(count))
{
return NewtThrow(kNErrNotAnInteger, count);
}
theEnd = theStart + NewtRefToInteger(count);
if (theEnd > theLen)
{
return NewtThrow(kNErrOutOfRange, count);
}
} else {
theEnd = theLen;
}
/* new length */
theLen = theEnd - theStart;
/* create a buffer to copy the characters to */
theBuffer = (char*) malloc(theLen + 1);
(void) memcpy(theBuffer, (const char*) &theString[theStart], theLen);
theBuffer[theLen] = 0;
theResult = NewtMakeString(theBuffer, false);
free(theBuffer);
return theResult;
}
void NewtInitSysEnv(void)
{
struct {
char * name;
newtRefVar slot;
const char * defaultValue;
} envs[] = {
{"NEWTLIB", NSSYM0(NEWTLIB), __LIBDIR__ ":."},
{"PLATFORM", NSSYM(PLATFORM), __PLATFORM__},
{"DYLIBSUFFIX", NSSYM(DYLIBSUFFIX), __DYLIBSUFFIX__},
{NULL, kNewtRefUnbind, NULL}
};
newtRefVar env;
newtRefVar proto;
newtRefVar v;
uint16_t i;
env = NcMakeFrame();
proto = NcMakeFrame();
for (i = 0; envs[i].name != NULL; i++)
{
NcSetSlot(proto, envs[i].slot, NewtMakeString(envs[i].defaultValue, true));
}
/* NEWTLIB is a special case, it can be overridden from the value in
the global variables. */
v = NewtGetEnv("NEWTLIB");
if (NewtRefIsString(v))
{
v = NcSplit(v, NewtMakeCharacter(':'));
NcSetSlot(proto, NSSYM0(NEWTLIB), v);
}
else
{
newtRefVar default_newtlib_array[] = {NSSTR(__LIBDIR__), NSSTR(".")};
newtRefVar default_newtlib = NewtMakeArray2(
kNewtRefNIL,
sizeof(default_newtlib_array) / sizeof(newtRefVar),
default_newtlib_array);
NcSetSlot(proto, NSSYM0(NEWTLIB), default_newtlib);
}
NcSetSlot(env, NSSYM0(_proto), NewtPackLiteral(proto));
NcSetSlot(GLOBALS, NSSYM0(_ENV_), env);
}
newtRef protoREGEX_regexec(newtRefArg preg, newtRefArg str)
{
newtRefVar substr;
newtRefVar r;
regmatch_t pmatch[10];
size_t nmatch;
char * src;
int eflags = 0;
int err;
int i;
if (NewtRefIsNIL(str))
return kNewtRefNIL;
if (! protoREGEX_refIsPreg(preg))
return kNewtRefUnbind;
if (! NewtRefIsString(str))
return NewtThrow(kNErrNotAString, str);
nmatch = sizeof(pmatch) / sizeof(regmatch_t);
src = NewtRefToString(str);
err = regexec((regex_t*)NewtRefToBinary(preg), src, nmatch, pmatch, eflags);
if (err != 0)
return kNewtRefNIL;
r = NewtMakeArray(kNewtRefUnbind, nmatch);
for (i = 0; i < nmatch; i++)
{
if (pmatch[i].rm_so != -1)
{
substr = NewtMakeString2(src + pmatch[i].rm_so, pmatch[i].rm_eo - pmatch[i].rm_so, false);
NewtSetArraySlot(r, i, substr);
}
}
return r;
}
newtRef NsIsString(newtRefArg rcvr, newtRefArg r)
{
return NewtMakeBoolean(NewtRefIsString(r));
}
