bool NewtArgsIsNumber(newtRefArg r1, newtRefArg r2, bool * real)
{
*real = false;
if (NewtRefIsReal(r1))
{
*real = true;
}
else
{
if (! NewtRefIsInteger(r1))
return false;
}
if (NewtRefIsReal(r2))
{
*real = true;
}
else
{
if (! NewtRefIsInteger(r2))
return false;
}
return true;
}
newtRef NcBOr(newtRefArg r1, newtRefArg r2)
{
if (! NewtRefIsInteger(r1))
return NewtThrow(kNErrNotAnInteger, r1);
if (! NewtRefIsInteger(r2))
return NewtThrow(kNErrNotAnInteger, r2);
return (r1 | 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 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 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 NcSetARef(newtRefArg r, newtRefArg p, newtRefArg v)
{
if (! NewtRefIsInteger(p))
return NewtThrow(kNErrNotAnInteger, p);
return NewtSetARef(r, NewtRefToInteger(p), v);
}
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 NcARef(newtRefArg r, newtRefArg p)
{
if (! NewtRefIsInteger(p))
return NewtThrow(kNErrNotAnInteger, p);
return NewtARef(r, NewtRefToInteger(p));
}
newtRef NsDefMagicPointer(newtRefArg rcvr, newtRefArg r, newtRefArg v)
{
int32_t table = 0;
int32_t index;
if (NewtRefIsNumberedMP(r))
{
table = NewtMPToTable(r);
index = NewtMPToIndex(r);
if (table != 0)
{ // テーブル番号 0 以外は未サポート
return kNewtRefUnbind;
}
}
else if (NewtRefIsInteger(r))
{
index = NewtRefToInteger(r);
}
else
{
#ifdef __NAMED_MAGIC_POINTER__
return NsDefNamedMP(rcvr, r, v);
#else
return kNewtRefUnbind;
#endif
}
if (NewtLength(MAGIC_POINTERS) <= index)
{ // テーブルの長さを拡張
NewtSetLength(MAGIC_POINTERS, index + 1);
}
return NewtSetArraySlot(MAGIC_POINTERS, index, v);
}
newtRef NsNegate(newtRefArg rcvr, newtRefArg integer)
{
if (! NewtRefIsInteger(integer))
return NewtThrow(kNErrNotAnInteger, integer);
return NewtMakeInt32(- (NewtRefToInteger(integer)));
}
newtRef NsChr(newtRefArg rcvr, newtRefArg r)
{
if (! NewtRefIsInteger(r))
return NewtThrow(kNErrNotAnInteger, r);
return NewtMakeCharacter(NewtRefToInteger(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);
}
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 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 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;
}
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 NsIsInteger(newtRefArg rcvr, newtRefArg r)
{
return NewtMakeBoolean(NewtRefIsInteger(r));
}
newtRef NsIsNumber(newtRefArg rcvr, newtRefArg r)
{
return NewtMakeBoolean(NewtRefIsInteger(r) || NewtRefIsReal(r));
}
