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 NcDivide(newtRefArg r1, newtRefArg r2)
{
bool real;
if (! NewtArgsIsNumber(r1, r2, &real))
return NewtThrow0(kNErrNotANumber);
if (real)
{
double real1;
double real2;
real1 = NewtRefToReal(r1);
real2 = NewtRefToReal(r2);
if (real2 == 0.0)
return NewtThrow(kNErrDiv0, r2);
return NewtMakeReal(real1 / real2);
}
else
{
int32_t int1;
int32_t int2;
int1 = NewtRefToInteger(r1);
int2 = NewtRefToInteger(r2);
if (int2 == 0)
return NewtThrow(kNErrDiv0, r2);
return NewtMakeInteger(int1 / int2);
}
}
newtRef NsSetLength(newtRefArg rcvr, newtRefArg r, newtRefArg len)
{
int32_t n;
if (NewtRefIsReadonly(r))
return NewtThrow(kNErrObjectReadOnly, r);
if (! NewtRefIsInteger(len))
return NewtThrow(kNErrNotAnInteger, len);
n = NewtRefToInteger(len);
switch (NewtGetRefType(r, true))
{
case kNewtBinary:
case kNewtString:
NewtBinarySetLength(r, n);
break;
case kNewtArray:
NewtSlotsSetLength(r, n, kNewtRefUnbind);
break;
case kNewtFrame:
return NewtThrow(kNErrUnexpectedFrame, r);
default:
return NewtThrow(kNErrNotAnArrayOrString, r);
}
return r;
}
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 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 NsSymbolCompareLex(newtRefArg rcvr, newtRefArg r1, newtRefArg r2)
{
if (! NewtRefIsSymbol(r1))
return NewtThrow(kNErrNotASymbol, r1);
if (! NewtRefIsSymbol(r2))
return NewtThrow(kNErrNotASymbol, r2);
return NewtMakeInteger(NewtSymbolCompareLex(r1, r2));
}
newtRef NcBOr(newtRefArg r1, newtRefArg r2)
{
if (! NewtRefIsInteger(r1))
return NewtThrow(kNErrNotAnInteger, r1);
if (! NewtRefIsInteger(r2))
return NewtThrow(kNErrNotAnInteger, r2);
return (r1 | r2);
}
newtRef NsExtractByte(newtRefArg rcvr, newtRefArg r, newtRefArg offset)
{
if (! NewtRefIsBinary(r))
return NewtThrow(kNErrNotABinaryObject, r);
if (! NewtRefIsInteger(offset))
return NewtThrow(kNErrNotAnInteger, offset);
return NewtGetBinarySlot(r, NewtRefToInteger(offset));
}
newtRef NcDiv(newtRefArg r1, newtRefArg r2)
{
if (! NewtRefIsInteger(r1))
return NewtThrow(kNErrNotAnInteger, r1);
if (! NewtRefIsInteger(r2))
return NewtThrow(kNErrNotAnInteger, r2);
return NewtMakeInteger(NewtRefToInteger(r1) / NewtRefToInteger(r2));
}
newtRef NsShiftRight(newtRefArg rcvr, newtRefArg r1, newtRefArg r2)
{
if (! NewtRefIsInteger(r1))
return NewtThrow(kNErrNotAnInteger, r1);
if (! NewtRefIsInteger(r2))
return NewtThrow(kNErrNotAnInteger, r2);
return NewtMakeInteger(NewtRefToInteger(r1) >> NewtRefToInteger(r2));
}
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 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 NsOrd(newtRefArg rcvr, newtRefArg r)
{
if (! NewtRefIsCharacter(r))
return NewtThrow(kNErrNotAnInteger, r);
return NewtMakeInteger(NewtRefToCharacter(r));
}
newtRef NcBNot(newtRefArg r)
{
if (! NewtRefIsInteger(r))
return NewtThrow(kNErrNotAnInteger, r);
return NewtMakeInteger(~ NewtRefToInteger(r));
}
newtRef NsMakeBinary(newtRefArg rcvr, newtRefArg length, newtRefArg klass)
{
if (! NewtRefIsInteger(length))
return NewtThrow(kNErrNotAnInteger, length);
return NewtMakeBinary(klass, NULL, NewtRefToInteger(length), false);
}
bool protoREGEX_refIsPreg(newtRefArg r)
{
if (! NewtRefIsBinary(r))
{
NewtThrow(kNErrNotABinaryObject, r);
return false;
}
if (NewtLength(r) != sizeof(regex_t))
{
NewtThrow(kNErrNegativeLength, r);
return false;
}
return true;
}
newtRef NsMakeBinaryFromHex(newtRefArg rcvr, newtRefArg hex, newtRefArg klass)
{
if (! NewtRefIsString(hex))
return NewtThrow(kNErrNotAString, hex);
return NewtMakeBinaryFromHex(klass, NewtRefToString(hex), false);
}
newtRef NewtObjSetClass(newtRefArg r, newtRefArg c)
{
newtObjRef obj;
obj = NewtRefToPointer(r);
if (obj != NULL)
{
if (NewtObjIsFrame(obj))
{
if (NewtRefIsReadonly(r))
{
NewtThrow(kNErrObjectReadOnly, r);
return r;
}
NewtObjSetSlot(obj, NS_CLASS, c);
}
else
{
obj->as.klass = c;
}
}
return r;
}
newtRef NcARef(newtRefArg r, newtRefArg p)
{
if (! NewtRefIsInteger(p))
return NewtThrow(kNErrNotAnInteger, p);
return NewtARef(r, NewtRefToInteger(p));
}
newtRef NcSetARef(newtRefArg r, newtRefArg p, newtRefArg v)
{
if (! NewtRefIsInteger(p))
return NewtThrow(kNErrNotAnInteger, p);
return NewtSetARef(r, NewtRefToInteger(p), v);
}
newtRef NsNegate(newtRefArg rcvr, newtRefArg integer)
{
if (! NewtRefIsInteger(integer))
return NewtThrow(kNErrNotAnInteger, integer);
return NewtMakeInt32(- (NewtRefToInteger(integer)));
}
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 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);
}
/** Call a function with an array of parameters
*
* @param rcvr [in] レシーバ
* @param func [in] Function
* @param params [in] Parameters
*
* @return Return value
*/
newtRef NsApply(newtRefArg rcvr, newtRefArg func, newtRefArg params)
{
if (! NewtRefIsFunction(func))
{
return NewtThrow(kNErrNotAFunction, func);
}
newtRef ary = NewtRefIsNIL(params) ? NewtMakeArray(kNewtRefUnbind, 0) : params;
return NcCallWithArgArray(func, ary);
}
newtRef NsMakeSymbol(newtRefArg rcvr, newtRefArg r)
{
char * s;
if (! NewtRefIsString(r))
return NewtThrow(kNErrNotAString, r);
s = NewtRefToString(r);
return NewtMakeSymbol(s);
}
newtRef NsRef(newtRefArg rcvr, newtRefArg integer)
{
if (! NewtRefIsInteger(integer))
return NewtThrow(kNErrNotAnInteger, integer);
newtRef result = (newtRef)NewtRefToInteger(integer);
if (NewtRefIsPointer(result) == false) {
//result = NSSYM0(weird_immediate);
}
return result;
}
newtRef NsExtractWord(newtRefArg rcvr, newtRefArg r, newtRefArg offset)
{
if (! NewtRefIsBinary(r))
return NewtThrow(kNErrNotABinaryObject, r);
if (! NewtRefIsInteger(offset))
return NewtThrow(kNErrNotAnInteger, offset);
uint32_t len = NewtBinaryLength(r);
uint32_t p = NewtRefToInteger(offset);
if (p < len && p + 1 < len)
{
uint8_t * data = NewtRefToBinary(r);
uint32_t value = (data[p] << 8) | (data[p+1]);
return NewtMakeInteger(value);
}
return kNewtRefUnbind;
}
newtRef NsMakeArray(newtRefArg rcvr, newtRefArg size, newtRefArg initialValue) {
if (!NewtRefIsInteger(size)) {
return NewtThrow(kNErrNotAnInteger, size);
}
int length = NewtRefToInteger(size);
newtRef result = NewtMakeArray(kNewtRefUnbind, length);
int i;
for (i = 0; i<length; i++) {
NewtSlotsSetSlot(result, i, initialValue);
}
return result;
}
