NewtFns.c

説明を見る。

/*------------------------------------------------------------------------*/
/* ヘッダファイル */
#include <string.h>

#include "NewtErrs.h"
#include "NewtFns.h"
#include "NewtEnv.h"
#include "NewtObj.h"
#include "NewtVM.h"
#include "NewtBC.h"
#include "NewtPrint.h"


/* 関数プロトタイプ */
static newtRef      NewtRefTypeToClass(uint16_t type);
static newtRef      NewtObjClassOf(newtRefArg r);
static newtRef      NewtObjSetClass(newtRefArg r, newtRefArg c);
static bool         NewtArgsIsNumber(newtRefArg r1, newtRefArg r2, bool * real);


#pragma mark -
/*------------------------------------------------------------------------*/
newtRef NcProtoLookupFrame(newtRefArg start, newtRefArg name)
{
    newtRefVar  current = start;

    while (NewtRefIsNotNIL(current))
    {
        current = NcResolveMagicPointer(current);

        if (NewtRefIsMagicPointer(current))
            return kNewtRefUnbind;

        if (NewtHasSlot(current, name))
            return current;

        current = NcGetSlot(current, NSSYM0(_proto));
    }

    return kNewtRefUnbind;
}


/*------------------------------------------------------------------------*/
newtRef NcProtoLookup(newtRefArg start, newtRefArg name)
{
    newtRefVar  current;

    current = NcProtoLookupFrame(start, name);

    if (current != kNewtRefUnbind)
        return NcGetSlot(current, name);
    else
        return kNewtRefUnbind;
}


/*------------------------------------------------------------------------*/
newtRef NcLexicalLookup(newtRefArg start, newtRef name)
{
    newtRefVar  current = start;

    while (NewtRefIsNotNIL(current))
    {
        current = NcResolveMagicPointer(current);

        if (NewtRefIsMagicPointer(current))
            return kNewtRefUnbind;

        if (NewtHasSlot(current, name))
            return NcGetSlot(current, name);

        current = NcGetSlot(current, NSSYM0(_nextArgFrame));
    }

    return kNewtRefUnbind;
}


/*------------------------------------------------------------------------*/
newtRef NcFullLookupFrame(newtRefArg start, newtRefArg name)
{
    newtRefVar  current;
    newtRefVar  left = start;

    if (! NewtRefIsFrame(start))
        return kNewtRefUnbind;

    while (NewtRefIsNotNIL(left))
    {
        current = left;

        while (NewtRefIsNotNIL(current))
        {
            current = NcResolveMagicPointer(current);

            if (NewtRefIsMagicPointer(current))
                return kNewtRefUnbind;

            if (NewtHasSlot(current, name))
                return current;
    
            current = NcGetSlot(current, NSSYM0(_proto));
        }

        left = NcGetSlot(left, NSSYM0(_parent));
    }

    return kNewtRefUnbind;
}


/*------------------------------------------------------------------------*/
newtRef NcFullLookup(newtRefArg start, newtRefArg name)
{
    newtRefVar  current;

    current = NcFullLookupFrame(start, name);

    if (current != kNewtRefUnbind)
        return NcGetSlot(current, name);
    else
        return kNewtRefUnbind;
}


#pragma mark -
/*------------------------------------------------------------------------*/
newtRef NcLookupSymbol(newtRefArg r, newtRefArg name)
{
    return NewtLookupSymbolArray(r, name, 0);
}


/*------------------------------------------------------------------------*/
newtRef NsThrow(newtRefArg rcvr, newtRefArg name, newtRefArg data)
{
    NVMThrow(name, data);
    return kNewtRefNIL;
}


/*------------------------------------------------------------------------*/
newtRef NsRethrow(newtRefArg rcvr)
{
    NVMRethrow();
    return kNewtRefNIL;
}


/*------------------------------------------------------------------------*/
newtRef NcClone(newtRefArg r)
{
    if (NewtRefIsPointer(r))
        return NewtObjClone(r);
    else
        return (newtRef)r;
}


/*------------------------------------------------------------------------*/
newtRef NsTotalClone(newtRefArg rcvr, newtRefArg r)
{
    newtRefVar  result;

    result = NcClone(r);

    if (NewtRefIsFrameOrArray(result))
    {
        newtRef *   slots;
        uint32_t    n;
        uint32_t    i;
    
        slots = NewtRefToSlots(result);
        n = NewtLength(result);
    
        for (i = 0; i < n; i++)
        {
            slots[i] = NsTotalClone(rcvr, slots[i]);
        }
    }

    return result;
}


/*------------------------------------------------------------------------*/
newtRef NcLength(newtRefArg r)
{
    return NewtMakeInteger(NewtLength(r));
}


/*------------------------------------------------------------------------*/
newtRef NsDeeplyLength(newtRefArg rcvr, newtRefArg r)
{
    return NewtMakeInteger(NewtDeeplyLength(r));
}


/*------------------------------------------------------------------------*/
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 NsHasSlot(newtRefArg rcvr, newtRefArg frame, newtRefArg slot)
{
    return NewtMakeBoolean(NewtHasSlot(frame, slot));
}


/*------------------------------------------------------------------------*/
newtRef NsGetSlot(newtRefArg rcvr, newtRefArg frame, newtRefArg slot)
{
    newtObjRef  obj;

    obj = NewtRefToPointer(frame);

    if (obj != NULL)
        return NcResolveMagicPointer(NewtObjGetSlot(obj, slot));
    else
        return kNewtRefUnbind;
}


/*------------------------------------------------------------------------*/
newtRef NsSetSlot(newtRefArg rcvr, newtRefArg frame, newtRefArg slot, newtRefArg v)
{
    newtObjRef  obj;

    obj = NewtRefToPointer(frame);

    if (obj != NULL)
    {
        if (NewtRefIsReadonly(frame))
            return NewtThrow(kNErrObjectReadOnly, frame);

        return NewtObjSetSlot(obj, slot, v);
    }

   return kNewtRefNIL;
}


/*------------------------------------------------------------------------*/
newtRef NsRemoveSlot(newtRefArg rcvr, newtRefArg frame, newtRefArg slot)
{
    newtObjRef  obj;

    obj = NewtRefToPointer(frame);
    NewtObjRemoveSlot(obj, slot);

    return frame;
}


/*------------------------------------------------------------------------*/
newtRef NcSetArraySlot(newtRefArg r, newtRefArg p, newtRefArg v)
{
    if (! NewtRefIsInteger(p))
        return NewtThrow(kNErrNotAnInteger, p);

    return NewtSetArraySlot(r, NewtRefToInteger(p), v);
}


/*------------------------------------------------------------------------*/
newtRef NcHasPath(newtRefArg r, newtRefArg p)
{
    return NewtMakeBoolean(NewtHasPath(r, p));
}


/*------------------------------------------------------------------------*/
newtRef NcGetPath(newtRefArg r, newtRefArg p)
{
    return NewtGetPath(r, p, NULL);
}


/*------------------------------------------------------------------------*/
newtRef NcSetPath(newtRefArg r, newtRefArg p, newtRefArg v)
{
    newtRefVar  slot;
    newtRefVar  target;

    target = NewtGetPath(r, p, &slot);

    if (target == kNewtRefUnbind)
        NewtThrow(kNErrOutOfBounds, r);

    if (NewtRefIsArray(target))
        return NcSetArraySlot(target, slot, v);
    else
        return NcSetSlot(target, slot, v);
}


/*------------------------------------------------------------------------*/
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 NsHasVariable(newtRefArg rcvr, newtRefArg r, newtRefArg name)
{
    return NewtMakeBoolean(NewtHasVariable(r, name));
}


/*------------------------------------------------------------------------*/
newtRef NsGetVariable(newtRefArg rcvr, newtRefArg frame, newtRefArg slot)
{
    return NcFullLookup(frame, slot);
}


/*------------------------------------------------------------------------*/
newtRef NsSetVariable(newtRefArg rcvr, newtRefArg frame, newtRefArg slot, newtRefArg v)
{
    if (NewtAssignment(frame, slot, v))
        return v;
    else
        return kNewtRefUnbind;
}


/*------------------------------------------------------------------------*/
newtRef NsHasVar(newtRefArg rcvr, newtRefArg name)
{
    return NewtMakeBoolean(NewtHasVar(name));
}


#pragma mark -
/*------------------------------------------------------------------------*/
newtRef NewtRefTypeToClass(uint16_t type)
{
    newtRefVar  klass = kNewtRefUnbind;

    switch (type)
    {
        case kNewtInt30:
        case kNewtInt32:
            klass = NS_INT;
            break;

        case kNewtCharacter:
            klass = NS_CHAR;
            break;

        case kNewtTrue:
            klass = NSSYM0(boolean);
            break;

        case kNewtSpecial:
        case kNewtNil:
        case kNewtUnbind:
            klass = NSSYM0(weird_immediate);
            break;

        case kNewtFrame:
            klass = NSSYM0(frame);
            break;

        case kNewtArray:
            klass = NSSYM0(array);
            break;

        case kNewtReal:
            klass = NSSYM0(real);
            break;

        case kNewtSymbol:
            klass = NSSYM0(symbol);
            break;

        case kNewtString:
            klass = NSSYM0(string);
            break;

        case kNewtBinary:
            klass = NSSYM0(binary);
            break;
    }

    return klass;
}


/*------------------------------------------------------------------------*/
newtRef NewtObjClassOf(newtRefArg r)
{
    newtObjRef  obj;
    newtRefVar  klass = kNewtRefNIL;

    obj = NewtRefToPointer(r);

    if (obj != NULL)
    {
        if (NewtObjIsFrame(obj))
        {
//            klass = NewtObjGetSlot(obj, NS_CLASS);
            klass = NcProtoLookup(r, NS_CLASS);

            if (NewtRefIsNIL(klass))
                klass = NSSYM0(frame);
        }
        else
        {
            klass = obj->as.klass;

            if (klass == kNewtSymbolClass)
                klass = NSSYM0(symbol);
            else if (NewtRefIsNIL(klass))
                klass = NewtRefTypeToClass(NewtGetObjectType(obj, true));
        }
    }

    return klass;
}


/*------------------------------------------------------------------------*/
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 NsPrimClassOf(newtRefArg rcvr, newtRefArg r)
{
    newtRefVar  klass;

    if (NewtRefIsPointer(r))
    {
        switch (NewtGetRefType(r, true))
        {
            case kNewtFrame:
                klass = NSSYM0(frame);
                break;

            case kNewtArray:
                klass = NSSYM0(array);
                break;

            default:
                klass = NSSYM0(binary);
                break;
        }
    }
    else
    {
        klass = NSSYM(immediate);
    }

    return klass;
}


/*------------------------------------------------------------------------*/
newtRef NcClassOf(newtRefArg r)
{
    if (NewtRefIsPointer(r))
        return NewtObjClassOf(r);
    else
        return NewtRefTypeToClass(NewtGetRefType(r, false));
}


/*------------------------------------------------------------------------*/
newtRef NcSetClass(newtRefArg r, newtRefArg c)
{
    if (NewtRefIsPointer(r))
        return NewtObjSetClass(r, c);
    else
        return kNewtRefNIL;;
}


/*------------------------------------------------------------------------*/
newtRef NcRefEqual(newtRefArg r1, newtRefArg r2)
{
    return NewtMakeBoolean(NewtRefEqual(r1, r2));
}


/*------------------------------------------------------------------------*/
newtRef NsObjectEqual(newtRefArg rcvr, newtRefArg r1, newtRefArg r2)
{
    return NewtMakeBoolean(NewtObjectEqual(r1, r2));
}


/*------------------------------------------------------------------------*/
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 NsHasSubclass(newtRefArg rcvr, newtRefArg sub, newtRefArg supr)
{
    return NewtMakeBoolean(NewtHasSubclass(sub, supr));
}


/*------------------------------------------------------------------------*/
newtRef NsIsSubclass(newtRefArg rcvr, newtRefArg sub, newtRefArg supr)
{
    return NewtMakeBoolean(NewtIsSubclass(sub, supr));
}


/*------------------------------------------------------------------------*/
newtRef NsIsInstance(newtRefArg rcvr, newtRefArg obj, newtRefArg r)
{
    return NewtMakeBoolean(NewtIsInstance(obj, r));
}


#pragma mark -
/*------------------------------------------------------------------------*/
newtRef NsIsArray(newtRefArg rcvr, newtRefArg r)
{
    return NewtMakeBoolean(NewtRefIsArray(r));
}


/*------------------------------------------------------------------------*/
newtRef NsIsFrame(newtRefArg rcvr, newtRefArg r)
{
    return NewtMakeBoolean(NewtRefIsFrame(r));
}


/*------------------------------------------------------------------------*/
newtRef NsIsBinary(newtRefArg rcvr, newtRefArg r)
{
    return NewtMakeBoolean(NewtRefIsBinary(r));
}


/*------------------------------------------------------------------------*/
newtRef NsIsSymbol(newtRefArg rcvr, newtRefArg r)
{
    return NewtMakeBoolean(NewtRefIsSymbol(r));
}


/*------------------------------------------------------------------------*/
newtRef NsIsString(newtRefArg rcvr, newtRefArg r)
{
    return NewtMakeBoolean(NewtRefIsString(r));
}


/*------------------------------------------------------------------------*/
newtRef NsIsCharacter(newtRefArg rcvr, newtRefArg r)
{
    return NewtMakeBoolean(NewtRefIsCharacter(r));
}


/*------------------------------------------------------------------------*/
newtRef NsIsInteger(newtRefArg rcvr, newtRefArg r)
{
    return NewtMakeBoolean(NewtRefIsInteger(r));
}


/*------------------------------------------------------------------------*/
newtRef NsIsReal(newtRefArg rcvr, newtRefArg r)
{
    return NewtMakeBoolean(NewtRefIsReal(r));
}


/*------------------------------------------------------------------------*/
newtRef NsIsNumber(newtRefArg rcvr, newtRefArg r)
{
    return NewtMakeBoolean(NewtRefIsInteger(r) || NewtRefIsReal(r));
}


/*------------------------------------------------------------------------*/
newtRef NsIsImmediate(newtRefArg rcvr, newtRefArg r)
{
    return NewtMakeBoolean(NewtRefIsImmediate(r));
}


/*------------------------------------------------------------------------*/
newtRef NsIsFunction(newtRefArg rcvr, newtRefArg r)
{
    return NewtMakeBoolean(NewtRefIsFunction(r));
}


/*------------------------------------------------------------------------*/
newtRef NsIsReadonly(newtRefArg rcvr, newtRefArg r)
{
    return NewtMakeBoolean(NewtRefIsReadonly(r));
}


#pragma mark -
/*------------------------------------------------------------------------*/
newtRef NcAddArraySlot(newtRefArg r, newtRefArg v)
{
    newtObjRef  obj;

    obj = NewtRefToPointer(r);

    if (obj != NULL)
        NewtObjAddArraySlot(obj, v);

    return v;
}


/*------------------------------------------------------------------------*/
newtRef NcStringer(newtRefArg r)
{
    newtRef *   slots;
    newtRefVar  str;
    uint32_t    len;
    uint32_t    i;

    if (! NewtRefIsArray(r))
        return NewtThrow(kNErrNotAnArray, r);

    str = NSSTR("");

    len = NewtArrayLength(r);
    slots = NewtRefToSlots(r);

    for (i = 0; i < len; i++)
    {
        NcStrCat(str, slots[i]);
    }

    return str;
}


/*------------------------------------------------------------------------*/
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 NsMakeSymbol(newtRefArg rcvr, newtRefArg r)
{
    char *  s;

    if (! NewtRefIsString(r))
        return NewtThrow(kNErrNotAString, r);

    s = NewtRefToString(r);

    return NewtMakeSymbol(s);
}


/*------------------------------------------------------------------------*/
newtRef NsMakeFrame(newtRefArg rcvr)
{
    return NewtMakeFrame(kNewtRefUnbind, 0);
}


/*------------------------------------------------------------------------*/
newtRef NsMakeBinary(newtRefArg rcvr, newtRefArg length, newtRefArg klass)
{
    if (! NewtRefIsInteger(length))
        return NewtThrow(kNErrNotAnInteger, length);

    return NewtMakeBinary(klass, NULL, NewtRefToInteger(length), false);
}


#pragma mark -
/*------------------------------------------------------------------------*/
newtRef NcBAnd(newtRefArg r1, newtRefArg r2)
{
    if (! NewtRefIsInteger(r1))
        return NewtThrow(kNErrNotAnInteger, r1);

    if (! NewtRefIsInteger(r2))
        return NewtThrow(kNErrNotAnInteger, r2);

    return (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 NcBNot(newtRefArg r)
{
    if (! NewtRefIsInteger(r))
        return NewtThrow(kNErrNotAnInteger, r);

    return NewtMakeInteger( NewtRefToInteger(r));
}


#pragma mark -
/*------------------------------------------------------------------------*/
newtRef NsAnd(newtRefArg rcvr, newtRefArg r1, newtRefArg r2)
{
    bool    result;

    result = (NewtRefIsNotNIL(r1) && NewtRefIsNotNIL(r2));

    return NewtMakeBoolean(result);
}


/*------------------------------------------------------------------------*/
newtRef NsOr(newtRefArg rcvr, newtRefArg r1, newtRefArg r2)
{
    bool    result;

    result = (NewtRefIsNotNIL(r1) || NewtRefIsNotNIL(r2));

    return NewtMakeBoolean(result);
}


#pragma mark -
/*------------------------------------------------------------------------*/
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 NcAdd(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);

        return NewtMakeReal(real1 + real2);
    }
    else
    {
        int32_t int1;
        int32_t int2;

        int1 = NewtRefToInteger(r1);
        int2 = NewtRefToInteger(r2);

        return NewtMakeInteger(int1 + int2);
    }
}


/*------------------------------------------------------------------------*/
newtRef NcSubtract(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);

        return NewtMakeReal(real1 - real2);
    }
    else
    {
        int32_t int1;
        int32_t int2;

        int1 = NewtRefToInteger(r1);
        int2 = NewtRefToInteger(r2);

        return NewtMakeInteger(int1 - int2);
    }
}


/*------------------------------------------------------------------------*/
newtRef NcMultiply(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);

        return NewtMakeReal(real1 * real2);
    }
    else
    {
        int32_t int1;
        int32_t int2;

        int1 = NewtRefToInteger(r1);
        int2 = NewtRefToInteger(r2);

        return NewtMakeInteger(int1 * int2);
    }
}


/*------------------------------------------------------------------------*/
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 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 NsMod(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 NsShiftLeft(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 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));
}


#pragma mark -
/*------------------------------------------------------------------------*/
newtRef NcLessThan(newtRefArg r1, newtRefArg r2)
{
    return NewtMakeBoolean(NewtObjectCompare(r1, r2) < 0);
}


/*------------------------------------------------------------------------*/
newtRef NcGreaterThan(newtRefArg r1, newtRefArg r2)
{
    return NewtMakeBoolean(NewtObjectCompare(r1, r2) > 0);
}


/*------------------------------------------------------------------------*/
newtRef NcGreaterOrEqual(newtRefArg r1, newtRefArg r2)
{
    return NewtMakeBoolean(NewtObjectCompare(r1, r2) >= 0);
}


/*------------------------------------------------------------------------*/
newtRef NcLessOrEqual(newtRefArg r1, newtRefArg r2)
{