14        instanceVariableNames:''

    14 	 instanceVariableNames:''

    15        classVariableNames:''

    15 	 classVariableNames:''

    16        poolDictionaries:''

    16 	 poolDictionaries:''

    17        category:'Magnitude-Numbers'

    17 	 category:'Magnitude-Numbers'

   886 !SmallInteger methodsFor:'modulu arithmetic'!

   533 !SmallInteger methodsFor:'binary storage'!

   887 

   534 

   888 times:aNumber

   535 hasSpecialBinaryRepresentation

   889     "return the product of the receiver and the argument, as SmallInteger.

   536     "return true, if the receiver has a special binary representation"

   890      The argument must be another SmallInteger.

   537 

   891      If the result overflows the smallInteger range, the value modulu the 

   538     ^ true

   892      smallInteger range is returned (i.e. the low bits of the product).

   539 !

   893      This is of course not always correct, but some code does a modulu anyway

   540 

   894      and can therefore speed things up by not going through LargeIntegers."

   541 storeBinaryOn: stream manager: manager

   895 

   542     "append a binary representation onto stream.

   896 %{  /* NOCONTEXT */

   543      Redefined since SmallIntegers are stored as their value with the 32nd bit 

   897 

   544      set as a tag.

   898     if (__isSmallInteger(aNumber)) {

   545      To make the binary file a bit more compact, zeros and single byte ints

   899 	RETURN ( _MKSMALLINT((_intVal(self) * _intVal(aNumber)) & 0x7FFFFFFF) );

   546      are stored with a more compact representation (using special type-codes)."

   900     }

   547 

   901 %}

   548     self == 0 ifTrue:[

   902 .

   549 	stream nextPut: manager codeForZero.

   903     self primitiveFailed

   550 	^ self

   904 !

   551     ].

   905 

   552     (self between:0 and:255) ifTrue:[

   906 plus:aNumber

   553 	stream nextPut: manager codeForByteInteger.

   907     "return the sum of the receiver and the argument, as SmallInteger.

   554 	stream nextPut: self.

   908      The argument must be another SmallInteger.

   555 	^ self

   909      If the result overflows the smallInteger range, the value modulu the 

   556     ].

   910      smallInteger range is returned (i.e. the low bits of the sum).

   557     stream nextPut: (((self bitShift: -24) bitAnd: 16rFF) bitOr: 16r80).

   911      This is of course not always correct, but some code does a modulu anyway

   558     stream nextPut: ((self bitShift: -16) bitAnd: 16rFF).

   912      and can therefore speed things up by not going through LargeIntegers."

   559     stream nextPut: ((self bitShift: -8) bitAnd: 16rFF).

   913 

   560     stream nextPut: (self bitAnd: 16rFF)

   914 %{  /* NOCONTEXT */

   915 

   916     if (__isSmallInteger(aNumber)) {

   917 	RETURN ( _MKSMALLINT((_intVal(self) + _intVal(aNumber)) & 0x7FFFFFFF) );

   918     }

   919 %}

   920 .

   921     self primitiveFailed

   922 ! 

   923 

   924 subtract:aNumber

   925     "return the difference of the receiver and the argument, as SmallInteger.

   926      The argument must be another SmallInteger.

   927      If the result overflows the smallInteger range, the value modulu the 

   928      smallInteger range is returned (i.e. the low bits of the sum).

   929      This is of course not always correct, but some code does a modulu anyway

   930      and can therefore speed things up by not going through LargeIntegers."

   931 

   932 %{  /* NOCONTEXT */

   933 

   934     if (__isSmallInteger(aNumber)) {

   935 	RETURN ( _MKSMALLINT((_intVal(self) - _intVal(aNumber)) & 0x7FFFFFFF) );

   936     }

   937 %}

   938 .

   939     self primitiveFailed

   971 allMask:anInteger

   617 bitInvert

   972     "return true if all 1-bits in anInteger are also 1 in the receiver"

   618     "return the value of the receiver with all bits inverted"

   973 

   619 

   974     ^ (self bitAnd:anInteger) == anInteger

   620 %{  /* NOCONTEXT */

   975 

   621 

   976     "2r00001111 allMask:2r00000001"

   622     /* invert anything except tag bits */

   977     "2r00001111 allMask:2r00011110"

   623     RETURN ( ((OBJ) ((INT)self ^ ~TAG_MASK)) );

   978     "2r00001111 allMask:2r00000000"

   624 %}

   979 !

   625 !

   980 

   626 

   981 anyMask:anInteger

   627 bitOr:anInteger

   982     "return true if any 1-bits in anInteger is also 1 in the receiver.

   628     "return the bitwise-or of the receiver and the argument, anInteger"

   983      (somewhat incorrect, if the mask is zero)"

   629 

   984 

   630 %{  /* NOCONTEXT */

   985     ^ (self bitAnd:anInteger) ~~ 0

   631 

   986 

   632     /* oring the tags doesn't change it */

   987     "2r00001111 anyMask:2r00000001"

   633     if (__isSmallInteger(anInteger)) {

   988     "2r00001111 anyMask:2r11110000"

   634 	RETURN ( ((OBJ) ((INT)self | (INT)anInteger)) );

   989 !

   635     }

   990 

   636 %}

   991 noMask:anInteger

   637 .

   992     "return true if no 1-bit in anInteger is 1 in the receiver"

   638     ^ self retry:#bitOr coercing:anInteger

   993 

   639 

   994     ^ (self bitAnd:anInteger) == 0

   640     "(2r000000100 bitOr:2r00000011) radixPrintStringRadix:2"

   995 

   996     "2r00001111 noMask:2r00000001"

   997     "2r00001111 noMask:2r11110000"

   998 !

   999 

  1000 highBit

  1001     "return the bitIndex of the highest bit set. The returned bitIndex

  1002      starts at 1 for the least significant bit. Returns -1 if no bit is set."

  1003 

  1004 %{  /* NOCONTEXT */

  1005 

  1006     INT mask, index, bits;

  1007 

  1008     bits = _intVal(self);

  1009     if (bits == 0) {

  1010 	RETURN ( _MKSMALLINT(-1) );

  1011     }

  1012 #ifdef alpha

  1013     mask = 0x2000000000000000;

  1014     index = 62;

  1015 #else

  1016     mask = 0x20000000;

  1017     index = 30;

  1018 #endif

  1019     while (index) {

  1020 	if (bits & mask) break;

  1021 	mask = mask >> 1;

  1022 	index--;

  1023     }

  1024     RETURN ( _MKSMALLINT(index) );

  1025 %}

  1026     "2r000100 highBit"

  1027     "2r010100 highBit"

  1028     "2r000001 highBit"

  1029     "0 highBit"

  1030     "SmallInteger maxVal highBit"

  1031 !

  1032 

  1033 lowBit

  1034     "return the bitIndex of the lowest bit set. The returned bitIndex

  1035      starts at 1 for the least significant bit. Returns -1 if no bit is set."

  1036 

  1037 %{  /* NOCONTEXT */

  1038 

  1039     INT mask, index, bits;

  1040 

  1041     bits = _intVal(self);

  1042     if (bits == 0) {

  1043 	RETURN ( _MKSMALLINT(-1) );

  1044     }

  1045     mask = 1;

  1046     index = 1;

  1047 #ifdef alpha

  1048     while (index != 63) {

  1049 #else

  1050     while (index != 31) {

  1051 #endif

  1052 	if (bits & mask) {

  1053 	    RETURN ( _MKSMALLINT(index) );

  1054 	}

  1055 	mask = mask << 1;

  1056 	index++;

  1057     }

  1058     RETURN ( _MKSMALLINT(-1) );

  1059 %}

  1060     "2r000100 lowBit"

  1061     "2r010010 lowBit"

  1062     "2r100001 lowBit"

  1063     "0 lowBit"

  1144 bitOr:anInteger

   721 bitTest:aMask

  1145     "return the bitwise-or of the receiver and the argument, anInteger"

   722     "return true, if any bit from aMask is set in the receiver"

  1146 

   723 

  1147 %{  /* NOCONTEXT */

   724 %{  /* NOCONTEXT */

  1148 

   725 

  1149     /* oring the tags doesn't change it */

   726     /* and all bits except tag */

  1150     if (__isSmallInteger(anInteger)) {

   727     if (__isSmallInteger(aMask)) {

  1151 	RETURN ( ((OBJ) ((INT)self | (INT)anInteger)) );

   728 	RETURN ( ((INT)self & ((INT)aMask & ~TAG_MASK)) ? true : false );

  1152     }

   729     }

  1153 %}

   730 %}

  1154 .

   731 .

  1155     ^ self retry:#bitOr coercing:anInteger

   732     ^ self retry:#bitTest coercing:aMask

  1156 

  1157     "(2r000000100 bitOr:2r00000011) radixPrintStringRadix:2"

  1158 !

  1159 

  1160 bitAnd:anInteger

  1161     "return the bitwise-and of the receiver and the argument, anInteger"

  1162 

  1163 %{  /* NOCONTEXT */

  1164 

  1165     /* anding the tags doesn't change it */

  1166     if (__isSmallInteger(anInteger)) {

  1167 	RETURN ( ((OBJ) ((INT)self & (INT)anInteger)) );

  1168     }

  1169 %}

  1170 .

  1171     ^ self retry:#bitAnd coercing:anInteger

  1172 

  1173     "(2r001010100 bitAnd:2r00001111) radixPrintStringRadix:2"

  1190 bitInvert

   749 highBit

  1191     "return the value of the receiver with all bits inverted"

   750     "return the bitIndex of the highest bit set. The returned bitIndex

  1192 

   751      starts at 1 for the least significant bit. Returns -1 if no bit is set."

  1193 %{  /* NOCONTEXT */

   752 

  1194 

   753 %{  /* NOCONTEXT */

  1195     /* invert anything except tag bits */

   754 

  1196     RETURN ( ((OBJ) ((INT)self ^ ~TAG_MASK)) );

   755     INT mask, index, bits;

  1197 %}

   756 

  1198 !

   757     bits = _intVal(self);

  1199 

   758     if (bits == 0) {

  1200 bitTest:aMask

   759 	RETURN ( _MKSMALLINT(-1) );

  1201     "return true, if any bit from aMask is set in the receiver"

   760     }

  1202 

   761 #ifdef alpha

  1203 %{  /* NOCONTEXT */

   762     mask = 0x2000000000000000;

  1204 

   763     index = 62;

  1205     /* and all bits except tag */

   764 #else

  1206     if (__isSmallInteger(aMask)) {

   765     mask = 0x20000000;

  1207 	RETURN ( ((INT)self & ((INT)aMask & ~TAG_MASK)) ? true : false );

   766     index = 30;

  1208     }

   767 #endif

  1209 %}

   768     while (index) {

  1210 .

   769 	if (bits & mask) break;

  1211     ^ self retry:#bitTest coercing:aMask

   770 	mask = mask >> 1;

   771 	index--;

   772     }

   773     RETURN ( _MKSMALLINT(index) );

   774 %}

   775     "2r000100 highBit"

   776     "2r010100 highBit"

   777     "2r000001 highBit"

   778     "0 highBit"

   779     "SmallInteger maxVal highBit"

   780 !

   781 

   782 lowBit

   783     "return the bitIndex of the lowest bit set. The returned bitIndex

   784      starts at 1 for the least significant bit. Returns -1 if no bit is set."

   785 

   786 %{  /* NOCONTEXT */

   787 

   788     INT mask, index, bits;

   789 

   790     bits = _intVal(self);

   791     if (bits == 0) {

   792 	RETURN ( _MKSMALLINT(-1) );

   793     }

   794     mask = 1;

   795     index = 1;

   796 #ifdef alpha

   797     while (index != 63) {

   798 #else

   799     while (index != 31) {

   800 #endif

   801 	if (bits & mask) {

   802 	    RETURN ( _MKSMALLINT(index) );

   803 	}

   804 	mask = mask << 1;

   805 	index++;

   806     }

   807     RETURN ( _MKSMALLINT(-1) );

   808 %}

   809     "2r000100 lowBit"

   810     "2r010010 lowBit"

   811     "2r100001 lowBit"

   812     "0 lowBit"

   813 !

   814 

   815 noMask:anInteger

   816     "return true if no 1-bit in anInteger is 1 in the receiver"

   817 

   818     ^ (self bitAnd:anInteger) == 0

   819 

   820     "2r00001111 noMask:2r00000001"

   821     "2r00001111 noMask:2r11110000"

  1287 !SmallInteger methodsFor:'misc math'!

   897 !SmallInteger methodsFor:'catching messages'!

  1288 

   898 

  1289 gcd:anInteger

   899 basicAt:index

  1290     "return the greatest common divisor (Euclid's algorithm).

   900     "catch indexed access - report an error

  1291      This has been redefined here for more speed since due to the

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

  1292      use of gcd in Fraction code, it has become time-critical for

   902 

  1293      some code. (thanx to MessageTally)"

   903     self notIndexed

  1294 

   904 !

  1295 %{  /* NOCONTEXT */

   905 

  1296 

   906 basicAt:index put:anObject

  1297     if (__isSmallInteger(anInteger)) {

   907     "catch indexed access - report an error

  1298 	INT orgArg, ttt, selfInt, temp;

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

  1299 

   909 

  1300 	ttt = orgArg = _intVal(anInteger);

   910     self notIndexed

  1301 	if (ttt) {

   911 !

  1302 	    selfInt = _intVal(self);

   912 

  1303 	    while (ttt != 0) {

   913 basicSize

  1304 		temp = selfInt % ttt;

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

  1305 		selfInt = ttt;

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

  1306 		ttt = temp;

   916 

  1307 	    }

   917     ^ 0

  1308 	    /*

   918 !

  1309 	     * since its not defined in what the sign of

   919 

  1310 	     * a modulu result is when the arg is negative,

   920 size

  1311 	     * change it explicitely here ...

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

  1312 	     */

   922 

  1313 	    if (orgArg < 0) {

   923     ^ 0

  1314 		/* result should be negative */

  1315 		if (selfInt > 0) selfInt = -selfInt;

  1316 	    } else {

  1317 		/* result should be positive */

  1318 		if (selfInt < 0) selfInt = -selfInt;

  1319 	    }

  1320 	    RETURN ( _MKSMALLINT(selfInt) );

  1321 	}

  1322     }

  1323 %}

  1324 .

  1325     ^ super gcd:anInteger

  1326 !

  1327 

  1328 intlog10

  1329     "return the truncation of log10 of the receiver -

  1330      stupid implementation; used to find out the number of digits needed

  1331      to print a number/and for conversion to a LargeInteger.

  1332      Implemented that way, to allow for tiny systems without a Float class

  1333      (i.e. without log)."

  1334 

  1335     self <= 0 ifTrue:[

  1336 	self error:'logarithm of negative integer'

  1337     ].

  1338     self < 10 ifTrue:[^ 1].

  1339     self < 100 ifTrue:[^ 2].

  1340     self < 1000 ifTrue:[^ 3].

  1341     self < 10000 ifTrue:[^ 4].

  1342     self < 100000 ifTrue:[^ 5].

  1343     self < 1000000 ifTrue:[^ 6].

  1344     self < 10000000 ifTrue:[^ 7].

  1345     self < 100000000 ifTrue:[^ 8].

  1346     self < 1000000000 ifTrue:[^ 9].

  1347     ^ 10

  1362 !

   963 ! !

  1363 

   964 

  1364 asFloat

   965 !SmallInteger methodsFor:'comparing'!

  1365     "return a Float with same value as receiver"

   966 

  1366 

   967 < aNumber

  1367 %{  /* NOCONTEXT */

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

  1368 

   969 

  1369     OBJ newFloat;

   970 %{  /* NOCONTEXT */

  1370     double dVal = (double)_intVal(self);

   971 

  1371 

   972     if (__isSmallInteger(aNumber)) {

  1372     _qMKFLOAT(newFloat, dVal, SENDER);

   973 #ifdef POSITIVE_ADDRESSES

  1373     RETURN ( newFloat );

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

  1374 %}

   975 #else

  1375 !

   976 	/* tag bit does not change ordering */

  1376 

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

  1377 asLargeInteger

   978 #endif

  1378     "return a LargeInteger with same value as receiver"

   979     }

  1379 

   980     if (__isFloatLike(aNumber)) {

  1380     ^ LargeInteger value:self

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

  1381 !

   982     }

  1382 

   983 %}

  1383 asCharacter

   984 .

  1384     "Return a character with the receiver as ascii value"

   985     ^ aNumber lessFromInteger:self

  1385 

   986     "^ self retry:#< coercing:aNumber"

  1386     ^ Character value:self

   987 !

   988 

   989 <= aNumber

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

   991 

   992 %{  /* NOCONTEXT */