"

 COPYRIGHT (c) 1988 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

Integer subclass:#SmallInteger

	instanceVariableNames:''

	classVariableNames:''

	poolDictionaries:''

	category:'Magnitude-Numbers'

!

!SmallInteger class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1988 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    SmallIntegers are Integers in the range of at least +/- 2^30 

    (i.e. 31 bits, which is not a guaranteed: on an alpha, 63 bits are used,

     if the system was configured for 64bit mode).

    These are no real objects - they have no instances (not even storage !!)

    and cannot be subclassed.

    The reason is to save both storage and runtime by not collecting

    SmallIntegers in the system. SmallInts are marked by having the TAG_INT 

    bit set, in contrast to all other objects which do not. 

    Since this knowledge is hardwired into the system (and there is no 

    class-field stored with SmallIntegers) there can be no subclass of 

    SmallInteger (sorry).

    If you really need this kind of thing, create a subclass of Integer,

    with an instance variable holding the value.

    [author:]

	Claus Gittinger

    [see also:]

	Number

	Float Fraction FixedPoint

	LargeInteger

"

! !

!SmallInteger class methodsFor:'instance creation'!

basicNew

    "catch instance creation

     - SmallIntegers cannot be created with new"

    self error:'instances of SmallInteger cannot be created with new'

!

basicNew:size

    "catch instance creation

     - SmallIntegers cannot be created with new"

    self error:'instances of SmallInteger cannot be created with new'

! !

!SmallInteger class methodsFor:'bit mask constants'!

bitMaskFor:index

    "return a bitmask for the index's bit (index starts at 1)"

    (index between:1 and:SmallInteger maxBits) ifFalse:[

	^ self error:'index out of bounds'

    ].

    ^ 1 bitShift:(index - 1)

! !

!SmallInteger class methodsFor:'constants'!

maxBits

    "return the number of bits in instances of me.

     For very special uses only - not constant across implementations"

%{  /* NOCONTEXT */

    RETURN ( __MKSMALLINT(N_INT_BITS) );

%}

    "SmallInteger maxBits"

!

maxBytes

    "return the number of bytes in instances of me.

     For very special uses only - not constant across implementations"

%{  /* NOCONTEXT */

    RETURN ( __MKSMALLINT(N_INT_BITS / 8 + 1) );

%}

    "

     SmallInteger maxBytes

    "

!

maxVal

    "return the largest Integer representable as SmallInteger.

     For very special uses only - not constant across implementations"

%{  /* NOCONTEXT */

    RETURN ( __MKSMALLINT(_MAX_INT) );

%}

    "SmallInteger maxVal"

!

minVal

    "return the smallest Integer representable as SmallInteger.

     For very special uses only - not constant across implementations"

%{  /* NOCONTEXT */

    RETURN ( __MKSMALLINT(_MIN_INT) );

%}

    "SmallInteger minVal"

! !

!SmallInteger class methodsFor:'queries'!

canBeSubclassed

    "return true, if its allowed to create subclasses of the receiver.

     Return nil here - since it is NOT possible for SmallInteger"

    ^ false

!

hasImmediateInstances

    "return true if this class has immediate instances.

     Redefined from Behavior"

    ^ true

    "Created: 3.6.1997 / 12:01:26 / cg"

!

isBuiltInClass

    "return true if this class is known by the run-time-system.

     Here, true is returned."

    ^ true

    "Modified: 23.4.1996 / 16:00:33 / cg"

! !

!SmallInteger methodsFor:'arithmetic'!

* aNumber

    "return the product of the receivers value and the arguments value"

%{  /* NOCONTEXT */

    INT myValue, otherValue;

    unsigned INT productLow, productHi;

    int negative;

#   define low16Bits(foo)  ((foo) & 0xFFFF)

#   define hi16Bits(foo)   ((foo) >> 16)

#   define low32Bits(foo)  ((foo) & 0xFFFFFFFFL)

#   define hi32Bits(foo)   ((foo) >> 32)

    /*

     * can we use long long arithmetic ?

     */

#if defined(__GNUC__) && (__GNUC__ >= 2)

    /*

     * commented, since long-long arithmetic seems to

     * be buggy in some implementations (sparc) ...

     * (took me a while to find this out :-(

     */

# ifdef NOTDEF

#   define USE_LONGLONG

# endif

#endif

    if (__isSmallInteger(aNumber)) {

        myValue = __intVal(self);

        otherValue = __intVal(aNumber);

#if defined(INT64) 

# if !defined(alpha64)

#  define USE_LONGLONG

# else

#  undef USE_LONGLONG

# endif

#endif

#if defined(USE_LONGLONG)

        {

# if defined(alpha) && !defined(alpha64)

#  define LONGLONG      INT64

# else

#  define LONGLONG      long long

# endif

            LONGLONG product;

            product = (LONGLONG)myValue * (LONGLONG)otherValue;

            if ((product >= (LONGLONG)_MIN_INT) 

             && (product <= (LONGLONG)_MAX_INT)) {

                RETURN ( __MKSMALLINT((INT)product) );

            }

            if (product < 0) {

                negative = -1;

                product = -product;

            } else {

                negative = 1;

            }

            productHi = product >> 32;

            productLow = product & 0xFFFFFFFFL;

        }

#else

        negative = 1;

        if (myValue < 0) {

            negative = -1;

            myValue = -myValue;

        }

        if (otherValue < 0) {

            negative = -negative;

            otherValue = -otherValue;

        }

# if defined(__GNUC__) && defined(mc68k)

        asm ("mulu%.l %3,%1:%0"

                : "=d"  ((unsigned long)(productLow)),

                  "=d"  ((unsigned long)(productHi))

                : "%0"  ((unsigned long)(myValue)),

                  "dmi" ((unsigned long)(otherValue)));

# else

#  if defined (__GNUC__) && defined(i386)

        asm ("mull %3"

                : "=a"  ((unsigned long)(productLow)),

                  "=d"  ((unsigned long)(productHi))

                : "%0"  ((unsigned long)(myValue)),

                  "rm"  ((unsigned long)(otherValue)));

#  else

        {

            unsigned INT pHH, pHL, pLH, pLL;

            unsigned INT low1, low2, hi1, hi2;

            unsigned INT t;

            /* unsigned multiply myValue * otherValue -> productHi, productLow

             *

             * this is too slow:

             * since most machines can do 32*32 to 64 bit multiply,

             * (or at least 32*32 with Overflow check)

             * - need more assembler (inline) functions here 

             */

#   ifdef alpha64

            low1 = low32Bits(myValue);

            hi1 = hi32Bits(myValue);

            low2 = low32Bits(otherValue);

            hi2 = hi32Bits(otherValue);

#    define LLMASK 0xC000000000000000L

#   else

            low1 = low16Bits(myValue);

            hi1 = hi16Bits(myValue);

            low2 = low16Bits(otherValue);

            hi2 = hi16Bits(otherValue);

#    define LLMASK 0xC0000000

#   endif

            pLH = low1 * hi2;

            pHL = hi1 * low2;

            pLL = low1 * low2;

            /*

             * the common case ...

             */

            if ((pHL == 0)

             && (pLH == 0)

             && ((pLL & LLMASK) == 0)) {

                if (negative < 0) {

                    RETURN ( __MKSMALLINT(- ((INT)pLL)) );

                }

                RETURN ( __MKSMALLINT((INT)pLL) );

            }

            pHH = hi1 * hi2;

            /*

             *   pHH |--------|--------|

             *   pLH          |--------|--------|

             *   pHL          |--------|--------|

             *   pLL                   |--------|--------|

             */

#   ifdef alpha64

            t = low32Bits(pLH) + low32Bits(pHL) + hi32Bits(pLL);

            productLow = (t << 32) + low32Bits(pLL);

            productHi = pHH + hi32Bits(t) + hi32Bits(pHL) + hi32Bits(pLH);

            if (t >= 0x100000000L) {

                productHi += t >> 32;

            }

#   else

            t = low16Bits(pLH) + low16Bits(pHL) + hi16Bits(pLL);

            productLow = (t << 16) + low16Bits(pLL);

            productHi = pHH + hi16Bits(t) + hi16Bits(pHL) + hi16Bits(pLH);

            if (t >= 0x10000L) {

                productHi += t >> 16;

            }

#   endif

        }

#  endif

# endif

        if (productHi == 0) {

            if (negative < 0) {

                if (productLow <= -(_MIN_INT)) {

                    RETURN ( __MKSMALLINT(-((INT)productLow)) );

                }

            } else {

                if (productLow <= _MAX_INT) {

                    RETURN ( __MKSMALLINT(productLow) );

                }

            }

        }

#endif

        {

# ifdef alpha64

            RETURN (__MKLARGEINT128(negative, productLow, productHi));

# else

            RETURN (__MKLARGEINT64(negative, productLow, productHi));

# endif

        }

    } else if (__isFloatLike(aNumber)) {

        OBJ newFloat;

        double val = (double)__intVal(self) * __floatVal(aNumber);

        __qMKFLOAT(newFloat, val);

        RETURN ( newFloat );

    } else if (__isShortFloat(aNumber)) {

        OBJ newFloat;

        float val = (float)__intVal(self) * __shortFloatVal(aNumber);

        __qMKSFLOAT(newFloat, val);

        RETURN ( newFloat );

    }

%}.

    ^ aNumber productFromInteger:self

!

+ aNumber

    "return the sum of the receivers value and the arguments value"

%{  /* NOCONTEXT */

    if (__isSmallInteger(aNumber)) {

#ifdef _ADD_IO_IO

        RETURN ( _ADD_IO_IO(self, aNumber) );

#else

        REGISTER INT sum;

        sum =  __intVal(self) + __intVal(aNumber);

        if ((sum >= _MIN_INT) && (sum <= _MAX_INT)) {

            RETURN ( __MKSMALLINT(sum) );

        }

        RETURN ( __MKLARGEINT(sum) );

#endif

    } else if (__isFloatLike(aNumber)) {

        OBJ newFloat;

        double val = (double)__intVal(self) + __floatVal(aNumber);

        __qMKFLOAT(newFloat, val);

        RETURN ( newFloat );

    } else if (__isShortFloat(aNumber)) {

        OBJ newFloat;

        float val = (float)__intVal(self) + __shortFloatVal(aNumber);

        __qMKSFLOAT(newFloat, val);

        RETURN ( newFloat );

    }

%}.

    ^ aNumber sumFromInteger:self

!

- aNumber

    "return the difference of the receivers value and the arguments value"

%{  /* NOCONTEXT */

    if (__isSmallInteger(aNumber)) {

#ifdef _SUB_IO_IO

        RETURN ( _SUB_IO_IO(self, aNumber) );

#else

        REGISTER INT diff;

        diff =  __intVal(self) - __intVal(aNumber);

        if ((diff >= _MIN_INT) && (diff <= _MAX_INT)) {

            RETURN ( __MKSMALLINT(diff) );

        }

        RETURN ( __MKLARGEINT(diff) );

#endif

    } else if (__isFloatLike(aNumber)) {

        OBJ newFloat;

        double val = (double)__intVal(self) - __floatVal(aNumber);

        __qMKFLOAT(newFloat, val);

        RETURN ( newFloat );

    } else if (__isShortFloat(aNumber)) {

        OBJ newFloat;

        float val = (float)__intVal(self) - __shortFloatVal(aNumber);

        __qMKSFLOAT(newFloat, val);

        RETURN ( newFloat );

    }

%}.

    ^ aNumber differenceFromInteger:self

!

/ aNumber

    "return the quotient of the receivers value and the arguments value"

%{  /* NOCONTEXT */

    INT me, t, val;

    double dval;

    if (__isSmallInteger(aNumber)) {

        val = __intVal(aNumber);

        if (val != 0) {

            me = __intVal(self);

            t = me / val;

#ifdef GOOD_OPTIMIZER

            if (me % val) {

#else

            /* this is stupid - all I want is to look for a remainder ... 

               but most compilers are too stupid and generate an extra modulus

               instruction for "if (me % val)".

               Even if most divide instructions already leave the remainder in

               some register.

               Therefore I use a multiplication which is faster than a modulo

               on most machines. Hint to GNU people :-)

            */

            if ((t * val) == me) {

#endif

                RETURN ( __MKSMALLINT(t) );

            }

        }

    } else {

        if (__isFloatLike(aNumber)) {

            dval = __floatVal(aNumber);

            if (dval != 0.0) {

                OBJ newFloat;

                double val = (double)__intVal(self) / dval;

                __qMKFLOAT(newFloat, val);

                RETURN ( newFloat );

            }

        }

    }

%}.

    aNumber isInteger ifTrue:[

        aNumber == 0 ifTrue:[

            ^ DivisionByZeroSignal raise.

        ].

        ^ Fraction numerator:self denominator:aNumber

    ].

    ^ aNumber quotientFromInteger:self

    "

     8 / 4

     9 / 4

     9 // 4

     9 quo:4

     -8 / 4

     -9 / 4

     -9 // 4

     -9 quo:4

    "