"

 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.

"

"{ Package: 'stx:libbasic' }"

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:[

	^ SubscriptOutOfBoundsSignal

		raiseRequestWith:index

		errorString:'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 ( __mkSmallInteger(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 ( __mkSmallInteger(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 ( __mkSmallInteger(_MAX_INT) );

%}

    "SmallInteger maxVal"

!

minVal

    "return the smallest Integer representable as SmallInteger.

     For very special uses only - not constant across implementations"

%{  /* NOCONTEXT */

    RETURN ( __mkSmallInteger(_MIN_INT) );

%}

    "SmallInteger minVal"

! !

!SmallInteger class methodsFor:'queries'!

canBeSubclassed

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

     Return false here - since it is NOT possible for SmallInteger

     (due to the tagged representation of SmallIntegers)"

    ^ false

    "Modified: / 5.11.1998 / 16:11:27 / cg"

!

hasImmediateInstances

    "return true if this class has immediate instances

     i.e. if the instances are represented in the pointer itself and

     no real object header/storage is used for the object.

     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 receiver and the argument"

%{  /* NOCONTEXT */

    /*

     * notice:

     * the following inline code handles some common cases,

     * and exists as an optimization, to speed up those cases.

     *

     * Conceptionally, (and for most other argument types),

     * mixed arithmetic is implemented by double dispatching

     * (see the message send at the bottom)

     */

    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 ?

     *

     * long-long arithmetic seems to be buggy with some systems

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

     * (try 10000 * 10000)

     */

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

# define USE_LONGLONG_FOR_MUL

#endif

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

# define USE_LONGLONG_FOR_MUL

#endif

    if (__isSmallInteger(aNumber)) {

        myValue = __intVal(self);

        otherValue = __intVal(aNumber);

#if defined(USE_LONGLONG_FOR_MUL)

        {

# 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 ( __mkSmallInteger((INT)product) );

            }

            if (product < 0) {

                negative = -1;

                product = -product;

            } else {

                negative = 1;

            }

            productHi = product >> 32;

            productLow = product & 0xFFFFFFFFL;

        }

#else /* no long-long */

        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

#   if defined(WIN32) && defined(__BORLANDC__)

        asm {

            mov   eax, myValue

            mov   edx, otherValue

            mul   edx

            mov   productLow, eax

            mov   productHi, edx

        }

#   else /* generic */

        {

            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

             */

#    if __POINTER_SIZE__ == 8

            low1 = low32Bits((unsigned INT)myValue);

            hi1 = hi32Bits((unsigned INT)myValue);

            low2 = low32Bits((unsigned INT)otherValue);

            hi2 = hi32Bits((unsigned INT)otherValue);

#     define LLMASK 0xC000000000000000L

#    else

            low1 = low16Bits((unsigned INT)myValue);

            hi1 = hi16Bits((unsigned INT)myValue);

            low2 = low16Bits((unsigned INT)otherValue);

            hi2 = hi16Bits((unsigned INT)otherValue);

#     define LLMASK 0xC0000000

#    endif

            pLH = low1 * hi2;

            pHL = hi1 * low2;

            pLL = low1 * low2;

            pHH = hi1 * hi2;

            /*

             * the common case ...

             */

            if ((pHL == 0)

             && (pLH == 0)

             && (pHH == 0)

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

                if (negative < 0) {

                    RETURN ( __mkSmallInteger(- ((INT)pLL)) );

                }

                RETURN ( __mkSmallInteger((INT)pLL) );

            }

            /*

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

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

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

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

             */

#    if __POINTER_SIZE__ == 8

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

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

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

#    else

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

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

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

#    endif

        }

#   endif /* ! WIN32 */

#  endif /* ! (__GNUC__ && __i386__) */

# endif /* ! (__GNUC__ && __mc68k__) */

        if (productHi == 0) {

            if (negative < 0) {

                if (productLow <= -(_MIN_INT)) {

                    RETURN ( __mkSmallInteger(-((INT)productLow)) );

                }

            } else {

                if (productLow <= _MAX_INT) {

                    RETURN ( __mkSmallInteger(productLow) );

                }

            }

        }

#endif /* ! USE_LONGLONG */

#if __POINTER_SIZE__ == 8

        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 */

    /*

     * notice:

     * the following inline code handles some common cases,

     * and exists as an optimization, to speed up those cases.

     *

     * Conceptionally, (and for most other argument types),

     * mixed arithmetic is implemented by double dispatching

     * (see the message send at the bottom)

     */

    if (__isSmallInteger(aNumber)) {

#ifdef _ADD_IO_IO

	RETURN ( _ADD_IO_IO(self, aNumber) );

#else

	REGISTER INT sum;

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

	if (__ISVALIDINTEGER(sum)) {

	    RETURN ( __mkSmallInteger(sum) );

	}

	RETURN ( __MKLARGEINT(sum) );

#endif

    }

    if (__isFloatLike(aNumber)) {

	OBJ newFloat;

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

	__qMKFLOAT(newFloat, val);

	RETURN ( newFloat );

    }

    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 */

    /*

     * notice:

     * the following inline code handles some common cases,

     * and exists as an optimization, to speed up those cases.

     *

     * Conceptionally, (and for most other argument types),

     * mixed arithmetic is implemented by double dispatching

     * (see the message send at the bottom)

     */

    if (__isSmallInteger(aNumber)) {

#ifdef _SUB_IO_IO

	RETURN ( _SUB_IO_IO(self, aNumber) );

#else

	REGISTER INT diff;

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

	if (__ISVALIDINTEGER(diff)) {

	    RETURN ( __mkSmallInteger(diff) );

	}

	RETURN ( __MKLARGEINT(diff) );

#endif

    }

    if (__isFloatLike(aNumber)) {

	OBJ newFloat;

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

	__qMKFLOAT(newFloat, val);

	RETURN ( newFloat );

    }

    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 */

    /*

     * notice:

     * the following inline code handles some common cases,

     * and exists as an optimization, to speed up those cases.

     *

     * Conceptionally, (and for most other argument types),

     * mixed arithmetic is implemented by double dispatching

     * (see the message send at the bottom)

     */

    INT me, t, val;

    double dval;

    if (__isSmallInteger(aNumber)) {

	val = __intVal(aNumber);

	if (val != 0) {

	    me = __intVal(self);