"

 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' }"

"{ NameSpace: Smalltalk }"

Integer subclass:#SmallInteger

	instanceVariableNames:''

	classVariableNames:'ZeroString'

	poolDictionaries:''

	category:'Magnitude-Numbers'

!

!SmallInteger primitiveDefinitions!

%{

#include <stdio.h>

%}

! !

!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, but this is not a guaranteed:

        on an alpha or x86_64, 63 bits are used, if the system was configured for 64bit mode.

        under the Schteam-VM, 64 bits are used (i.e. a full long integer)

    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:'class initialization'!

initialize

    ZeroString := '0'

! !

!SmallInteger class methodsFor:'constants'!

maxBits

    "return the number of bits in instances of me.

     For very special uses only - not constant across implementations"

%{  /* NOCONTEXT */

#ifdef __SCHTEAM__

    // longs are always 64bits

    return context._RETURN ( STInteger._new(64) );

#else

    RETURN ( __mkSmallInteger(N_INT_BITS) );

#endif

%}

    "

     SmallInteger maxBits

    "

!

maxBytes

    "return the number of bytes in instances of me.

     For very special uses only - not constant across implementations.

     Notice: this is inlined by the compiler(s) as a constant,

     therefore, a query like 'SmallInteger maxBytes == 8'

     costs nothing; it is compiled in as a constant."

%{  /* NOCONTEXT */

#ifdef __SCHTEAM__

    // longs are always 8 bytes

    return context._RETURN ( STInteger._new(8) );

#else

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

#endif

%}

    "

     SmallInteger maxBytes

    "

!

maxVal

    "return the largest Integer representable as SmallInteger.

     For very special uses only - not constant across implementations"

%{  /* NOCONTEXT */

#ifdef __SCHTEAM__

    return context._RETURN ( STInteger._MAX_INTVAL );

#else

    RETURN ( __mkSmallInteger(_MAX_INT) );

#endif

%}

    "

     SmallInteger maxVal

    "

!

minVal

    "return the smallest Integer representable as SmallInteger.

     For very special uses only - not constant across implementations"

%{  /* NOCONTEXT */

#ifdef __SCHTEAM__

    return context._RETURN ( STInteger._MIN_INTVAL );

#else

    RETURN ( __mkSmallInteger(_MIN_INT) );

#endif

%}

    "

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

#ifdef __SCHTEAM__

    return context._RETURN( self.times( aNumber ));

#else

    /*

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

    myValue = __intVal(self);

#   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)) {

        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 & 0xFFFFFFFFLL;

        }

# 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(__x86__)

        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 0xC000000000000000LL

#     else

            low1 = low16Bits((unsigned INT)myValue);

            hi1 = hi16Bits((unsigned INT)myValue);

            low2 = low16Bits((unsigned INT)otherValue);

            hi2 = hi16Bits((unsigned INT)otherValue);

#      define LLMASK 0xC0000000L

#     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__ && __x86__) */

#  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)myValue * __floatVal(aNumber);

        __qMKFLOAT(newFloat, val);

        RETURN ( newFloat );

    } else if (__isShortFloat(aNumber)) {

        OBJ newFloat;

        float val = (float)myValue * __shortFloatVal(aNumber);

        __qMKSFLOAT(newFloat, val);

        RETURN ( newFloat );

    } else if (__isFractionLike(aNumber)) {

        OBJ t = __FractionInstPtr(aNumber)->f_numerator;

        if (myValue == 0) {

            RETURN(__mkSmallInteger(0));

        }

        if (__isSmallInteger(t)) {

            INT num = __intVal(t);

            t = __FractionInstPtr(aNumber)->f_denominator;

            if (__isSmallInteger(t)) {

                INT prod = myValue * num;

                if (prod / myValue == num) { // check for overflow

                    INT den = __intVal(t);

                    INT quo = prod / den;

                    if (quo * den == prod) {        // check for integer result

                        RETURN ( __mkSmallInteger(quo) );

                    }

                }

            }

        }

    }

#endif /* not __SCHTEAM__ */

%}.

    ^ aNumber productFromInteger:self

    "

        3 * (1/2)

        6 * (1/2)

        6 * (-1/2)

   "

!

+ aNumber

    "return the sum of the receiver's value and the argument's value"

%{  /* NOCONTEXT */

#ifdef __SCHTEAM__

    return context._RETURN( self.plus( aNumber ));

#else

    /*

     * 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 );