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)); }