"

 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 

    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)

    /*

     * 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

# endif

#endif

    if (__isSmallInteger(aNumber)) {

	myValue = __intVal(self);

	otherValue = __intVal(aNumber);

	{

		RETURN ( __MKSMALLINT((INT)product) );

	    }

	    if (product < 0) {

		negative = -1;

		product = -product;

	    } else {

		negative = 1;

	    }

	    productHi = product >> 32;

	}

#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 

	     */

	    low1 = low16Bits(myValue);

	    hi1 = hi16Bits(myValue);

	    low2 = low16Bits(otherValue);

	    hi2 = hi16Bits(otherValue);

	    pLH = low1 * hi2;

	    pHL = hi1 * low2;

	    pLL = low1 * low2;

	    /*

	     * the common case ...

	     */

	    if ((pHL == 0)

	     && (pLH == 0)

		if (negative < 0) {

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

		}

		RETURN ( __MKSMALLINT((INT)pLL) );

	    }

	    pHH = hi1 * hi2;

	    /*

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

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

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

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

	     */

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

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

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

	}

#  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

	{

	    extern OBJ __MKLARGEINT64();

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

	}

    } else if (__isFloatLike(aNumber)) {

	OBJ newFloat;

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

	__qMKFLOAT(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

    }

    if (__isFloatLike(aNumber)) {

	OBJ newFloat;

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

	__qMKFLOAT(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

    }

    if (__isFloatLike(aNumber)) {

	OBJ newFloat;

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

	__qMKFLOAT(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 modulu

	       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 modulu

	       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

    "

!

// aNumber

    "return the integer part of the quotient of the receivers value

     and the arguments value. The result is truncated toward negative infinity

     and negative, if the operands signs differ.

     Be careful with negative results: 9 // 4 = 2, 

     while -9 // 4 = -3.