"

 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.

"

!

version

!

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"

!

minVal

    "return the smallest Integer representable as SmallInteger.

     For very special uses only - not constant across implementations"

%{  /* NOCONTEXT */

    RETURN ( _MKSMALLINT(_MIN_INT) );

%}

    "SmallInteger minVal"

!

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

isBuiltInClass

    "this class is known by the run-time-system"

    ^ true

!

canBeSubclassed

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

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

    ^ false

! !

!SmallInteger methodsFor:'catching messages'!

basicAt:index

    "catch indexed access - report an error

     defined here since basicAt: in Object ommits the SmallInteger check."

    self notIndexed

!

basicAt:index put:anObject

    "catch indexed access - report an error

     defined here since basicAt:put: in Object ommits the SmallInteger check."

    self notIndexed

!

size

    "return the number of indexed instvars - SmallIntegers have none."

    ^ 0

!

basicSize

    "return the number of indexed instvars - SmallIntegers have none.

     Defined here since basicSize in Object ommits the SmallInteger check."

    ^ 0

! !

!SmallInteger methodsFor:'copying'!

shallowCopy

    "return a shallow copy of myself

     - reimplemented here since smallintegers are unique"

    ^ self

!

simpleDeepCopy

    "return a deep copy of myself

     - reimplemented here since smallintegers are unique"

    ^ self

!

deepCopyUsing:aDictionary

    "return a deep copy of myself

     - reimplemented here since smallintegers are unique"

    ^ self

!

deepCopy

    "return a deep copy of myself

     - reimplemented here since smallintegers are unique"

    ^ self

! !

!SmallInteger methodsFor:'comparing'!

= aNumber

    "return true, if the arguments value is equal to mine"

%{  /* NOCONTEXT */

    if (aNumber == self) {

	RETURN ( true );

    }

    if (! __isNonNilObject(aNumber)) {

	/* a smallint or nil */

	RETURN ( false );

    }

    if (__isFloatLike(aNumber)) {

	RETURN ( ((double)_intVal(self) == _floatVal(aNumber)) ? true : false );

    }

%}

.

    aNumber respondsToArithmetic ifFalse:[^ false].

    ^ self retry:#= coercing:aNumber

!

~= aNumber

    "return true, if the arguments value is not equal to mine"

%{  /* NOCONTEXT */

    if (aNumber == self) {

	RETURN ( false );

    }

    if (! __isNonNilObject(aNumber)) {

	/* a smallint or nil */

	RETURN ( true );

    }

    if (__isFloatLike(aNumber)) {

	RETURN ( ((double)_intVal(self) == _floatVal(aNumber)) ? false : true );

    }

%}

.

    aNumber respondsToArithmetic ifFalse:[^ true].

    ^ self retry:#~= coercing:aNumber

!

< aNumber

    "return true, if the argument is greater than the receiver"

%{  /* NOCONTEXT */

    if (__isSmallInteger(aNumber)) {

#ifdef POSITIVE_ADDRESSES

	RETURN ( (_intVal(self) < _intVal(aNumber)) ? true : false );

#else

	/* tag bit does not change ordering */

	RETURN ( ((INT)self < (INT)aNumber) ? true : false );

#endif

    }

    if (__isFloatLike(aNumber)) {

	RETURN ( ((double)_intVal(self) < _floatVal(aNumber)) ? true : false );

    }

%}

.

    ^ aNumber lessFromInteger:self

    "^ self retry:#< coercing:aNumber"

!

> aNumber

    "return true, if the argument is less than the receiver"

%{  /* NOCONTEXT */

    if (__isSmallInteger(aNumber)) {

#ifdef POSITIVE_ADDRESSES

	RETURN ( (_intVal(self) > _intVal(aNumber)) ? true : false );

#else

	/* tag bit does not change ordering */

	RETURN ( ((INT)self > (INT)aNumber) ? true : false );

#endif

    }

    if (__isFloatLike(aNumber)) {

	RETURN ( ((double)_intVal(self) > _floatVal(aNumber)) ? true : false );

    }

%}

.

    ^ self retry:#> coercing:aNumber

!

>= aNumber

    "return true, if the argument is less or equal"

%{  /* NOCONTEXT */

    if (__isSmallInteger(aNumber)) {

#ifdef POSITIVE_ADDRESSES

	RETURN ( (_intVal(self) >= _intVal(aNumber)) ? true : false );

#else

	/* tag bit does not change ordering */

	RETURN ( ((INT)self >= (INT)aNumber) ? true : false );

#endif

    }

    if (__isFloatLike(aNumber)) {

	RETURN ( ((double)_intVal(self) >= _floatVal(aNumber)) ? true : false );

    }

%}

.

    ^ self retry:#>= coercing:aNumber

!

<= aNumber

    "return true, if the argument is greater or equal"

%{  /* NOCONTEXT */

    if (__isSmallInteger(aNumber)) {

#ifdef POSITIVE_ADDRESSES

	RETURN ( (_intVal(self) <= _intVal(aNumber)) ? true : false );

#else

	/* tag bit does not change ordering */

	RETURN ( ((INT)self <= (INT)aNumber) ? true : false );

#endif

    }

    if (__isFloatLike(aNumber)) {

	RETURN ( ((double)_intVal(self) <= _floatVal(aNumber)) ? true : false );

    }

%}

.

    ^ self retry:#<= coercing:aNumber

!

hash

    "return an integer useful for hashing on value"

    self >= 0 ifTrue:[^ self].

    ^ self negated

!

identityHash

    "return an integer useful for hashing on identity"

    self >= 0 ifTrue:[^ self].

    ^ self negated

!

min:aNumber

    "return the receiver or the argument, whichever is smaller"

%{  /* NOCONTEXT */

    if (__isSmallInteger(aNumber)) {

#ifdef POSITIVE_ADDRESSES

	if (_intVal(self) < _intVal(aNumber)) {

#else

	/* tag bit does not change ordering */

	if ((INT)(self) < (INT)(aNumber)) {

#endif

	    RETURN ( self );

	}

	RETURN ( aNumber );

    }

    if (__isFloatLike(aNumber)) {

	if ( (double)_intVal(self) < _floatVal(aNumber) ) {

	    RETURN ( self );

	}

	RETURN ( aNumber );

    }

%}

.

    (self < aNumber) ifTrue:[^ self].

    ^ aNumber

!

max:aNumber

    "return the receiver or the argument, whichever is greater"

%{  /* NOCONTEXT */

    if (__isSmallInteger(aNumber)) {

#ifdef POSITIVE_ADDRESSES

	if (_intVal(self) > _intVal(aNumber)) {

#else

	/* tag bit does not change ordering */

	if ((INT)(self) > (INT)(aNumber)) {

#endif

	    RETURN ( self );

	}

	RETURN ( aNumber );

    }

    if (__isFloatLike(aNumber)) {

	if ( (double)_intVal(self) > _floatVal(aNumber) ) {

	    RETURN ( self );

	}

	RETURN ( aNumber );

    }

%}

.

    (self > aNumber) ifTrue:[^ self].

    ^ aNumber

! !

!SmallInteger methodsFor:'testing'!

negative

    "return true, if the receiver is less than zero

     reimplemented here for speed"

%{  /* NOCONTEXT */

#ifdef POSITIVE_ADDRESSES

    RETURN ( (_intVal(self) < 0) ? true : false );

#else

    /* tag bit does not change sign */

    RETURN ( ((INT)(self) < 0) ? true : false );

#endif

%}

!

positive

    "return true, if the receiver is not negative

     reimplemented here for speed"

%{  /* NOCONTEXT */

#ifdef POSITIVE_ADDRESSES

    RETURN ( (_intVal(self) >= 0) ? true : false );

#else

    /* tag bit does not change sign */

    RETURN ( ((INT)(self) >= 0) ? true : false );

#endif

%}

!

strictlyPositive

    "return true, if the receiver is greater than zero

     reimplemented here for speed"

%{  /* NOCONTEXT */

#ifdef POSITIVE_ADDRESSES

    RETURN ( (_intVal(self) > 0) ? true : false );

#else

    /* tag bit does not change sign */

    RETURN ( ((INT)(self) > 0) ? true : false );

#endif

%}

!

sign

    "return the sign of the receiver

     reimplemented here for speed"

%{  /* NOCONTEXT */

    INT val = _intVal(self);

    if (val < 0) {

	RETURN ( _MKSMALLINT(-1) ); 

    }

    if (val > 0) {

	RETURN ( _MKSMALLINT(1) );

    }

    RETURN ( _MKSMALLINT(0) );

%}

!

between:min and:max

    "return true if the receiver is less than or equal to the argument max

     and greater than or equal to the argument min.

     - reimplemented here for speed"

%{  /* NOCONTEXT */

    if (__bothSmallInteger(min, max)) {

	REGISTER INT selfVal;

	selfVal = _intVal(self);

	if (selfVal < _intVal(min)) {

	     RETURN ( false );

	}

	if (selfVal > _intVal(max)) {

	     RETURN ( false );

	}

	RETURN ( true );

    }

%}

.

    (self < min) ifTrue:[^ false].

    (self > max) ifTrue:[^ false].

    ^ true

!

even

    "return true, if the receiver is even"

%{  /* NOCONTEXT */

#ifdef POSITIVE_ADDRESSES

    RETURN ( ((INT)self & 1) ? false : true );

#else    

    RETURN ( ((INT)self & ((INT)_MKSMALLINT(1) & ~TAG_INT)) ? false : true );

#endif

%}

!

odd

    "return true, if the receiver is odd"

%{  /* NOCONTEXT */

#ifdef POSITIVE_ADDRESSES

    RETURN ( ((INT)self & 1) ? true : false );

#else