"

 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

!

!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 guaranteed; it could be more on 64 bit cpus).

    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.

"

! !

!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:'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"

! !

!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

!

    ^ true

! !

!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 lowBits(foo)  ((foo) & 0xFFFF)

#   define hiBits(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

#   define _LONGLONG

# endif

#endif

    if (__isSmallInteger(aNumber)) {

	myValue = _intVal(self);

	otherValue = _intVal(aNumber);

#if defined(_LONGLONG)

	{

	    long long product;

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

	    if ((product >= (long long)_MIN_INT) 

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

		RETURN ( _MKSMALLINT((int)product) );

	    }

	    if (product < 0) {

		negative = 1;

		product = -product;

	    } else {

		negative = 0;

	    }

	    productHi = product >> 32;

	    productLow = product & 0xFFFFFFFF;

	}

#else

	negative = 0;

	if (myValue < 0) {

	    negative = 1;

	    myValue = -myValue;

	}

	if (otherValue < 0) {

	    negative = (1 - 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 = lowBits(myValue);

	    hi1 = hiBits(myValue);

	    low2 = lowBits(otherValue);

	    hi2 = hiBits(otherValue);

	    pLH = low1 * hi2;

	    pHL = hi1 * low2;

	    pLL = low1 * low2;

	    /*

	     * the common case ...

	     */

	    if ((pHL == 0)

	     && (pLH == 0)

	     && ((pLL & 0xC0000000) == 0)) {

		if (negative) {

		    RETURN ( _MKSMALLINT(- ((INT)pLL)) );

		}

		RETURN ( _MKSMALLINT((INT)pLL) );

	    }

	    pHH = hi1 * hi2;

	    /*

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

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

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

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

	     */

	    t = lowBits(pLH) + lowBits(pHL) + hiBits(pLL);

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

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

	}

#  endif

# endif

	if (productHi == 0) {

	    if (negative) {

		if (productLow <= -(_MIN_INT)) {

		    RETURN ( _MKSMALLINT(-((INT)productLow)) );

		}

	    } else {

		if (productLow <= _MAX_INT) {

		    RETURN ( _MKSMALLINT(productLow) );

		}

	    }

	}

#endif

	{

	    extern OBJ LargeInteger;

	    static struct inlineCache val = _ILC5;

	    OBJ aLarge;

	    aLarge = (*val.ilc_func)(LargeInteger, 

				     @symbol(sign:value16:value16:value16:value16:),

				     CON_COMMA nil, &val, 

				     negative ? _MKSMALLINT(-1) : _MKSMALLINT(1),

				     _MKSMALLINT(lowBits(productLow)),

				     _MKSMALLINT(hiBits(productLow)),

				     _MKSMALLINT(lowBits(productHi)),

				     _MKSMALLINT(hiBits(productHi)) );

	    RETURN(aLarge);

	}

    } else if (__isFloatLike(aNumber)) {

	OBJ newFloat;

	double val = (double)_intVal(self) * _floatVal(aNumber);

	_qMKFLOAT(newFloat, val, SENDER);

	RETURN ( newFloat );

    }

%}

.

    ^ aNumber productFromInteger: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, SENDER);

		RETURN ( newFloat );

	    }

	}

    }

%}

.

    aNumber isInteger ifTrue:[

	aNumber == 0 ifTrue:[

	    ^ DivisionByZeroSignal raise.

	].

	^ Fraction numerator:self denominator:aNumber

    ].

    ^ aNumber quotientFromInteger:self

!

// aNumber

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

     and the arguments value"

%{  /* NOCONTEXT */

    INT val;

    if (__isSmallInteger(aNumber)) {

	val = _intVal(aNumber);

	if (val != 0) {

	    RETURN ( _MKSMALLINT(_intVal(self) / val) );

	}

    } else {

	if (__isFraction(aNumber)) {

	    OBJ t;

	    INT num, den;

	    t = _FractionInstPtr(aNumber)->f_numerator;

	    if (__isSmallInteger(t)) {

		num = _intVal(t);

		t = _FractionInstPtr(aNumber)->f_denominator;

		if (__isSmallInteger(t)) {

		    den = _intVal(t);

		    RETURN ( _MKSMALLINT(_intVal(self) * den / num ));

		}

	    }

	}

    }

%}

.

    (aNumber = 0) ifTrue:[

	^ DivisionByZeroSignal raise.

    ].

    ^ self retry:#// coercing:aNumber

!

\\ aNumber

    "return the integer rest of the receivers value

     divided by the arguments value"

%{  /* NOCONTEXT */

    INT mySelf, val;

    if (__isSmallInteger(aNumber)) {

	mySelf = _intVal(self);

	if (mySelf < 0) mySelf = -mySelf;

	val = _intVal(aNumber);

	if (val != 0) {

	    if (val < 0) {

		RETURN ( _MKSMALLINT(-(mySelf % -val)) );

	    }

	    RETURN ( _MKSMALLINT(mySelf % val) );

	}

    }

%}

.

    (aNumber = 0) ifTrue:[

	^ DivisionByZeroSignal raise.

    ].

    ^ self retry:#\\ coercing:aNumber