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 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 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 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 NsStrCat(newtRefArg rcvr, newtRefArg str, newtRefArg v) { char wk[32]; char * s = NULL; switch (NewtGetRefType(v, true)) { case kNewtInt30: case kNewtInt32: { int n; n = (int)NewtRefToInteger(v); sprintf(wk, "%d", n); s = wk; } break; case kNewtReal: { double n; n = NewtRefToReal(v); sprintf(wk, "%f", n); s = wk; } break; case kNewtCharacter: { int c; c = NewtRefToCharacter(v); sprintf(wk, "%c", c); s = wk; } break; case kNewtSymbol: { newtSymDataRef sym; sym = NewtRefToSymbol(v); s = sym->name; } break; case kNewtString: s = NewtRefToString(v); break; } if (s != NULL) NewtStrCat(str, s); return str; }
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 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; }
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; }