hg/stx-libbasic: comparison LargeInteger.st

equal deleted inserted replaced

-:295e8bb99fde
+:75c9deec4a70
 "
 this is the common case, multiplying with SmallInteger.
 Use a special method for this case ...
 "
 ((numberClass := aNumber class) == SmallInteger) ifTrue:[
-^ self productFromInteger:aNumber
+	^ self productFromInteger:aNumber
 ].
 "
 if the argument is not a largeInteger, coerce
 "
 (numberClass == self class) ifFalse:[
-^ self retry:#* coercing:aNumber
+	^ self retry:#* coercing:aNumber
 ].
 otherSign := aNumber sign.
 (sign == otherSign) ifTrue:[^ self absMul:aNumber].
 (otherSign == 0) ifTrue:[^ 0].
 "
 this is the common case, subtracting a SmallInteger.
 Use a special method for this case ...
 "
 ((numberClass := aNumber class) == SmallInteger) ifTrue:[
-sign > 0 ifTrue:[
+	sign > 0 ifTrue:[
-aNumber > 0 ifTrue:[
+	    aNumber > 0 ifTrue:[
-^ self absFastMinus:aNumber sign:1
+		^ self absFastMinus:aNumber sign:1
-].
+	    ].
-^ self absFastPlus:aNumber sign:1
+	    ^ self absFastPlus:aNumber sign:1
-].
+	].
-aNumber > 0 ifTrue:[
+	aNumber > 0 ifTrue:[
-^ self absFastPlus:aNumber sign:-1
+	    ^ self absFastPlus:aNumber sign:-1
-].
+	].
-^ self absFastMinus:aNumber sign:-1
+	^ self absFastMinus:aNumber sign:-1
 ].
 "
 if the argument is not a largeInteger, coerce
 "
 (numberClass == self class) ifFalse:[
-^ self retry:#- coercing:aNumber
+	^ self retry:#- coercing:aNumber
 ].
 otherSign := aNumber sign.
 (sign > 0) ifTrue:[
-"I am positive"
+	"I am positive"
-(otherSign > 0) ifTrue:[
+	(otherSign > 0) ifTrue:[
-"+large - +large"
+	    "+large - +large"
-^ self absMinus:aNumber sign:1
+	    ^ self absMinus:aNumber sign:1
-].
+	].
-(otherSign < 0) ifTrue:[
+	(otherSign < 0) ifTrue:[
-"+large - -large"
+	    "+large - -large"
-^ self absPlus:aNumber sign:1
+	    ^ self absPlus:aNumber sign:1
-].
+	].
-"should not happen"
+	"should not happen"
-^ self
+	^ self
 ].
 "I am negative"
 (otherSign > 0) ifTrue:[
-"-large - +large"
+	"-large - +large"
-^ self absPlus:aNumber sign:-1
+	^ self absPlus:aNumber sign:-1
 ].
 (otherSign < 0) ifTrue:[
-"-large - -large"
+	"-large - -large"
-^ self absMinus:aNumber sign:-1
+	^ self absMinus:aNumber sign:-1
 ].
 ^ self
 "
 12345678901234567890 - 0
 bitAnd:anInteger
 "return the bitwise-and of the receiver and the argument, anInteger"
 %{  /* NOCONTEXT */
 if (__isSmallInteger(anInteger)) {
-INT v2 = __intVal(anInteger);
+	INT v2 = __intVal(anInteger);
-INT v1;
+	INT v1;
 #if defined(__LSBFIRST__)
-v1 = *(INT *)(__byteArrayVal(__INST(digitByteArray)));
+	v1 = *(INT *)(__byteArrayVal(__INST(digitByteArray)));
 #else
-unsigned char *digits = (unsigned char *)(__byteArrayVal(__INST(digitByteArray)));
+	unsigned char *digits = (unsigned char *)(__byteArrayVal(__INST(digitByteArray)));
-v1 = digits[0] & 0xFF;
+	v1 = digits[0] & 0xFF;
-v1 = v1 | ((digits[1] & 0xFF)<<8);
+	v1 = v1 | ((digits[1] & 0xFF)<<8);
-v1 = v1 | ((digits[2] & 0xFF)<<16);
+	v1 = v1 | ((digits[2] & 0xFF)<<16);
-v1 = v1 | ((digits[3] & 0xFF)<<24);
+	v1 = v1 | ((digits[3] & 0xFF)<<24);
 # if (__POINTER_SIZE__ == 8)
-v1 = v1 | ((digits[4] & 0xFF)<<32);
+	v1 = v1 | ((digits[4] & 0xFF)<<32);
-v1 = v1 | ((digits[5] & 0xFF)<<40);
+	v1 = v1 | ((digits[5] & 0xFF)<<40);
-v1 = v1 | ((digits[6] & 0xFF)<<48);
+	v1 = v1 | ((digits[6] & 0xFF)<<48);
-v1 = v1 | ((digits[7] & 0xFF)<<56);
+	v1 = v1 | ((digits[7] & 0xFF)<<56);
 #endif
 #endif
-RETURN ( __mkSmallInteger(v1 & v2) );
+	RETURN ( __mkSmallInteger(v1 & v2) );
 }
 %}.
 ^ super bitAnd:anInteger
 "
 !
 bitAt:anIntegerIndex
 "return the value of the index's bit (index starts at 1) as 0 or 1.
 Notice: the result of bitAt: on negative receivers is not
-defined in the language standard (since the implementation
+	     defined in the language standard (since the implementation
-is free to choose any internal representation for integers)"
+	     is free to choose any internal representation for integers)"
 %{  /* NOCONTEXT */
 if (__isSmallInteger(anIntegerIndex)) {
-INT idx = __smallIntegerVal(anIntegerIndex) - 1;
+	INT idx = __smallIntegerVal(anIntegerIndex) - 1;
-if (idx >= 0) {
+	if (idx >= 0) {
-int v1;
+	    int v1;
-int byteOffset = idx / 8;
+	    int byteOffset = idx / 8;
-int digitLen   = __stringSize(__INST(digitByteArray));
+	    int digitLen   = __stringSize(__INST(digitByteArray));
-if (digitLen < byteOffset) {
+	    if (digitLen < byteOffset) {
-RETURN(__mkSmallInteger(0));
+		RETURN(__mkSmallInteger(0));
-}
+	    }
-v1 = (__byteArrayVal(__INST(digitByteArray)))[byteOffset];
+	    v1 = (__byteArrayVal(__INST(digitByteArray)))[byteOffset];
-if (v1 & (1 << (idx % 8))) {
+	    if (v1 & (1 << (idx % 8))) {
-RETURN(__mkSmallInteger(1));
+		RETURN(__mkSmallInteger(1));
-} else {
+	    } else {
-RETURN(__mkSmallInteger(0));
+		RETURN(__mkSmallInteger(0));
-}
+	    }
-}
+	}
 }
 %}.
 ^ super bitAt:anIntegerIndex
 "
 %{
 /*
 * quickly advance over full 0-words
 */
 if (__isByteArray(__INST(digitByteArray))) {
-int __sz = __intVal(sz);
+	int __sz = __intVal(sz);
-unsigned char *__bP = __byteArrayVal(__INST(digitByteArray));
+	unsigned char *__bP = __byteArrayVal(__INST(digitByteArray));
-unsigned char *__bP0 = __bP;
+	unsigned char *__bP0 = __bP;
 #ifdef __UNROLL_LOOPS__
-while (__sz > (sizeof(INT) * 4)) {
+	while (__sz > (sizeof(INT) * 4)) {
-if ( ((INT *)__bP)[0] != 0 ) break;
+	    if ( ((INT *)__bP)[0] != 0 ) break;
-if ( ((INT *)__bP)[1] != 0 ) {
+	    if ( ((INT *)__bP)[1] != 0 ) {
-__sz -= sizeof(INT);
+		__sz -= sizeof(INT);
-__bP += sizeof(INT);
+		__bP += sizeof(INT);
-break;
+		break;
-}
+	    }
-if ( ((INT *)__bP)[2] != 0 ) {
+	    if ( ((INT *)__bP)[2] != 0 ) {
-__sz -= sizeof(INT) * 2;
+		__sz -= sizeof(INT) * 2;
-__bP += sizeof(INT) * 2;
+		__bP += sizeof(INT) * 2;
-break;
+		break;
-}
+	    }
-if ( ((INT *)__bP)[3] != 0 ) {
+	    if ( ((INT *)__bP)[3] != 0 ) {
-__sz -= sizeof(INT) * 3;
+		__sz -= sizeof(INT) * 3;
-__bP += sizeof(INT) * 3;
+		__bP += sizeof(INT) * 3;
-break;
+		break;
-}
+	    }
-__sz -= sizeof(INT) * 4;
+	    __sz -= sizeof(INT) * 4;
-__bP += sizeof(INT) * 4;
+	    __bP += sizeof(INT) * 4;
-}
+	}
 #endif
-while (__sz > sizeof(INT)) {
+	while (__sz > sizeof(INT)) {
-if ( ((INT *)__bP)[0] != 0 ) break;
+	    if ( ((INT *)__bP)[0] != 0 ) break;
-__sz -= sizeof(INT);
+	    __sz -= sizeof(INT);
-__bP += sizeof(INT);
+	    __bP += sizeof(INT);
-}
+	}
-while (__sz > 0) {
+	while (__sz > 0) {
-unsigned int c;
+	    unsigned int c;
-if ( (c = *__bP) != 0 ) {
+	    if ( (c = *__bP) != 0 ) {
-int bitIdx = (__bP - __bP0) * 8;
+		int bitIdx = (__bP - __bP0) * 8;
 #ifdef __BSF
-{
+		{
-int index;
+		    int index;
-int t = c;
+		    int t = c;
-index = __BSF(t);
+		    index = __BSF(t);
-RETURN ( __mkSmallInteger(index + 1 + bitIdx) );
+		    RETURN ( __mkSmallInteger(index + 1 + bitIdx) );
-}
+		}
 #else
-if (c & 0x0F) {
+		if (c & 0x0F) {
-if (c & 0x03) {
+		    if (c & 0x03) {
-if (c & 0x01) {
+			if (c & 0x01) {
-RETURN ( __mkSmallInteger( bitIdx + 1) );
+			    RETURN ( __mkSmallInteger( bitIdx + 1) );
-} else {
+			} else {
-RETURN ( __mkSmallInteger( bitIdx + 2) );
+			    RETURN ( __mkSmallInteger( bitIdx + 2) );
-}
+			}
-} else {
+		    } else {
-if (c & 0x04) {
+			if (c & 0x04) {
-RETURN ( __mkSmallInteger( bitIdx + 3) );
+			    RETURN ( __mkSmallInteger( bitIdx + 3) );
-} else {
+			} else {
-RETURN ( __mkSmallInteger( bitIdx + 4) );
+			    RETURN ( __mkSmallInteger( bitIdx + 4) );
-}
+			}
-}
+		    }
-} else {
+		} else {
-if (c & 0x30) {
+		    if (c & 0x30) {
-if (c & 0x10) {
+			if (c & 0x10) {
-RETURN ( __mkSmallInteger( bitIdx + 5) );
+			    RETURN ( __mkSmallInteger( bitIdx + 5) );
-} else {
+			} else {
-RETURN ( __mkSmallInteger( bitIdx + 6) );
+			    RETURN ( __mkSmallInteger( bitIdx + 6) );
-}
+			}
-} else {
+		    } else {
-if (c & 0x40) {
+			if (c & 0x40) {
-RETURN ( __mkSmallInteger( bitIdx + 7) );
+			    RETURN ( __mkSmallInteger( bitIdx + 7) );
-} else {
+			} else {
-RETURN ( __mkSmallInteger( bitIdx + 8) );
+			    RETURN ( __mkSmallInteger( bitIdx + 8) );
-}
+			}
-}
+		    }
-}
+		}
 #endif
-break;
+		break;
-}
+	    }
-__sz--;
+	    __sz--;
-__bP++;
+	    __bP++;
-}
+	}
-idx0 = __mkSmallInteger( __bP - __bP0 + 1 );
+	idx0 = __mkSmallInteger( __bP - __bP0 + 1 );
 }
 %}.
 "/ never actually reached
 idx0 to:sz do:[:digitIndex |
-(byte := digitByteArray at:digitIndex) ~~ 0 ifTrue:[
+	(byte := digitByteArray at:digitIndex) ~~ 0 ifTrue:[
-^ (digitIndex-1)*8 + (byte lowBit)
+	    ^ (digitIndex-1)*8 + (byte lowBit)
-]
+	]
 ].
 ^ 0 "/ should not happen
 "
 (1 bitShift:0) lowBit
 (1 bitShift:10) lowBit
 (1 bitShift:20) lowBit
 (1 bitShift:30) lowBit
 (1 bitShift:30) highBit
 (1 bitShift:31) lowBit
 (1 bitShift:32) lowBit
 (1 bitShift:32) highBit
 (1 bitShift:33) lowBit
 (1 bitShift:33) highBit
 (1 bitShift:64) lowBit
 (1 bitShift:64) highBit
 (1 bitShift:1000) lowBit
 (1 bitShift:1000) highBit
 ((1 bitShift:64)-1) lowBit
 ((1 bitShift:64)-1) highBit
 1 to:1000 do:[:idx |
-self assert:(( 1 bitShift:idx) lowBit = (idx+1)).
+	self assert:(( 1 bitShift:idx) lowBit = (idx+1)).
-self assert:(( 1 bitShift:idx) lowBit = ( 1 bitShift:idx) highBit).
+	self assert:(( 1 bitShift:idx) lowBit = ( 1 bitShift:idx) highBit).
-self assert:(( 3 bitShift:idx) lowBit = (idx+1)).
+	self assert:(( 3 bitShift:idx) lowBit = (idx+1)).
-self assert:(( 7 bitShift:idx) lowBit = (idx+1)).
+	self assert:(( 7 bitShift:idx) lowBit = (idx+1)).
-self assert:(( 15 bitShift:idx) lowBit = (idx+1)).
+	self assert:(( 15 bitShift:idx) lowBit = (idx+1)).
-self assert:(( 31 bitShift:idx) lowBit = (idx+1)).
+	self assert:(( 31 bitShift:idx) lowBit = (idx+1)).
-self assert:(( 63 bitShift:idx) lowBit = (idx+1)).
+	self assert:(( 63 bitShift:idx) lowBit = (idx+1)).
-self assert:(( 127 bitShift:idx) lowBit = (idx+1)).
+	self assert:(( 127 bitShift:idx) lowBit = (idx+1)).
-self assert:(( 255 bitShift:idx) lowBit = (idx+1)).
+	self assert:(( 255 bitShift:idx) lowBit = (idx+1)).
 ]
 |num|
 num := (1 bitShift:1000).
 Time millisecondsToRun:[
-100000 timesRepeat:[
+	100000 timesRepeat:[
-num lowBit
+	    num lowBit
-]
+	]
 ]
 "
 "Modified: 14.8.1997 / 11:55:34 / cg"
 !
 but a new number is returned. Should be named #withBitSet:"
 |myDigitLength newDigitLength newDigitBytes byteIndexOfBitToSet|
 index <= 0 ifTrue:[
-^ SubscriptOutOfBoundsSignal
+	^ SubscriptOutOfBoundsSignal
-raiseRequestWith:index
+		raiseRequestWith:index
-errorString:'index out of bounds'
+		errorString:'index out of bounds'
 ].
 myDigitLength := digitByteArray size.
 byteIndexOfBitToSet := ((index-1)//8)+1.
 byteIndexOfBitToSet > myDigitLength ifTrue:[
-newDigitLength := myDigitLength max:byteIndexOfBitToSet.
+	newDigitLength := myDigitLength max:byteIndexOfBitToSet.
-newDigitBytes := ByteArray new:newDigitLength.
+	newDigitBytes := ByteArray new:newDigitLength.
-newDigitBytes replaceFrom:1 to:myDigitLength with:digitByteArray startingAt:1.
+	newDigitBytes replaceFrom:1 to:myDigitLength with:digitByteArray startingAt:1.
 ] ifFalse:[
-newDigitBytes := digitByteArray copy
+	newDigitBytes := digitByteArray copy
 ].
 newDigitBytes
-at:byteIndexOfBitToSet
+	at:byteIndexOfBitToSet
-put:((newDigitBytes at:byteIndexOfBitToSet) setBit:(((index-1)\\8)+1)).
+	put:((newDigitBytes at:byteIndexOfBitToSet) setBit:(((index-1)\\8)+1)).
 ^ (self class digitBytes:newDigitBytes) sign:sign
 "
 TestCase assert:( 16r80000000 setBit:3  ) = 16r80000004
 TestCase assert:( 16r80000000 setBit:33 ) = 16r180000000
 "
 ! !
 !LargeInteger methodsFor:'byte access'!
 "return true, if the argument, aNumber is greater than the receiver"
 |otherSign|
 (aNumber class == self class) ifTrue:[
-otherSign := aNumber sign.
+	otherSign := aNumber sign.
-(sign > 0) ifTrue:[
+	(sign > 0) ifTrue:[
-"I am positive"
+	    "I am positive"
-(otherSign > 0) ifTrue:[^ self absLess:aNumber].
+	    (otherSign > 0) ifTrue:[^ self absLess:aNumber].
-^ false "aNumber is <= 0"
+	    ^ false "aNumber is <= 0"
-].
+	].
-"I am negative"
+	"I am negative"
-(otherSign > 0) ifTrue:[^ true].
+	(otherSign > 0) ifTrue:[^ true].
-(otherSign == 0) ifTrue:[^ true].
+	(otherSign == 0) ifTrue:[^ true].
-^ (aNumber absLess:self)
+	^ (aNumber absLess:self)
 ].
 (aNumber class == SmallInteger) ifTrue:[
-otherSign := aNumber sign.
+	otherSign := aNumber sign.
-(sign > 0) ifTrue:[
+	(sign > 0) ifTrue:[
-"I am positive"
+	    "I am positive"
-^ false "aNumber is <= 0"
+	    ^ false "aNumber is <= 0"
-].
+	].
-(sign == 0) ifTrue:[
+	(sign == 0) ifTrue:[
-(otherSign > 0) ifTrue:[^ true].
+	    (otherSign > 0) ifTrue:[^ true].
-^ false
+	    ^ false
-].
+	].
-"I am negative"
+	"I am negative"
-^ true
+	^ true
 ].
 ^ aNumber lessFromInteger:self
 "Modified: / 31.7.2002 / 10:08:19 / cg"
 as the receiver, false otherwise"
 "/ speed up compare to 0
 (aNumber == 0) ifTrue:[
-^ sign == 0
+	^ sign == 0
 ].
 (aNumber class == self class) ifFalse:[
-"/
+	"/
-"/ here, we depend on the fact, that largeinteger
+	"/ here, we depend on the fact, that largeinteger
-"/ results are always converted to smallInts, if possible.
+	"/ results are always converted to smallInts, if possible.
-"/ therefore, a largeInt in the smallInt range is not allowed (possible)
+	"/ therefore, a largeInt in the smallInt range is not allowed (possible)
-"/
+	"/
-aNumber class == SmallInteger ifTrue:[^ false ].
+	aNumber class == SmallInteger ifTrue:[^ false ].
-^ aNumber equalFromInteger:self
+	^ aNumber equalFromInteger:self
 ].
 (aNumber sign == sign) ifFalse:[^ false].
 ^ digitByteArray = aNumber digitBytes "/ ^ self absEq:aNumber
 h := self bitAnd:16r3FFFFFFF.
 l := digitByteArray size.
 l >= 8 ifTrue:[
-h := h bitXor:(digitByteArray at:l).
+	h := h bitXor:(digitByteArray at:l).
-h := h bitXor:((digitByteArray at:l-1) bitShift:8).
+	h := h bitXor:((digitByteArray at:l-1) bitShift:8).
-h := h bitXor:((digitByteArray at:l-2) bitShift:16).
+	h := h bitXor:((digitByteArray at:l-2) bitShift:16).
-h := h bitXor:((digitByteArray at:l-3) bitShift:22).
+	h := h bitXor:((digitByteArray at:l-3) bitShift:22).
-l >= 12 ifTrue:[
+	l >= 12 ifTrue:[
-m := l // 2.
+	    m := l // 2.
-h := h bitXor:(digitByteArray at:m-1).
+	    h := h bitXor:(digitByteArray at:m-1).
-h := h bitXor:((digitByteArray at:m) bitShift:8).
+	    h := h bitXor:((digitByteArray at:m) bitShift:8).
-h := h bitXor:((digitByteArray at:m+1) bitShift:16).
+	    h := h bitXor:((digitByteArray at:m+1) bitShift:16).
-h := h bitXor:((digitByteArray at:m+2) bitShift:22).
+	    h := h bitXor:((digitByteArray at:m+2) bitShift:22).
-].
+	].
-^ h
+	^ h
 ].
 ^ (h bitShift:3) + l
 "
 16r80000000 hash
 16r80000008 hash
 16r8000000000008 hash
 "
 ! !
 !LargeInteger methodsFor:'double dispatching'!
 differenceFromInteger:anInteger
 "sent, when anInteger does not know how to subtract the receiver.
 Return the result of 'anInteger - self'. The argument must be a SmallInteger."
 anInteger > 0 ifTrue:[
-sign > 0 ifTrue:[
+	sign > 0 ifTrue:[
-^ self absFastMinus:anInteger sign:-1
+	    ^ self absFastMinus:anInteger sign:-1
-].
+	].
-^ self absFastPlus:anInteger sign:1
+	^ self absFastPlus:anInteger sign:1
 ].
 anInteger == 0 ifTrue:[
-^ self negated
+	^ self negated
 ].
 sign > 0 ifTrue:[
-^ self absFastPlus:anInteger negated sign:-1
+	^ self absFastPlus:anInteger negated sign:-1
 ].
 self > anInteger ifTrue:[
-^ self absFastMinus:anInteger asLargeInteger sign:-1
+	^ self absFastMinus:anInteger asLargeInteger sign:-1
 ] ifFalse:[
-^ anInteger asLargeInteger absFastMinus:self sign:-1
+	^ anInteger asLargeInteger absFastMinus:self sign:-1
 ].
 "
 12345678901234567890
 -12345678901234567890
 "/ results are always converted to smallInts, if possible.
 "/ therefore, a largeInt in the smallInt range is not allowed (possible)
 "/
 anInteger class == SmallInteger ifTrue:[^ false ].
 anInteger class == self class ifFalse:[
-^ super equalFromInteger:anInteger
+	^ super equalFromInteger:anInteger
 ].
 (anInteger sign == sign) ifFalse:[^ false].
 ^ self absEq:anInteger
 !
 "/ here, we depend on the fact, that largeinteger
 "/ results are always converted to smallInts, if possible.
 "/ therefore, a largeInt in the smallInt range is not allowed (possible)
 "/
 (anInteger class == SmallInteger) ifTrue:[
-otherSign := anInteger sign.
+	otherSign := anInteger sign.
-(sign > 0) ifTrue:[
+	(sign > 0) ifTrue:[
-"I am positive"
+	    "I am positive"
-^ true "aNumber is <= 0"
+	    ^ true "aNumber is <= 0"
-].
+	].
-"I am negative"
+	"I am negative"
-^ false
+	^ false
 ].
 ^ super lessFromInteger:anInteger
 !
 productFromInteger:anInteger
 %{  /* NOCONTEXT */
 OBJ _digitByteArray = __INST(digitByteArray);
 if (__isLargeInteger(aLargeInteger)) {
-OBJ _otherDigitByteArray = __LargeIntegerInstPtr(aLargeInteger)->l_digits;
+	OBJ _otherDigitByteArray = __LargeIntegerInstPtr(aLargeInteger)->l_digits;
-if (__isByteArray(_digitByteArray)
+	if (__isByteArray(_digitByteArray)
-&& __isByteArray(_otherDigitByteArray)) {
+	 && __isByteArray(_otherDigitByteArray)) {
-INT _myLen = __byteArraySize(_digitByteArray);
+	    INT _myLen = __byteArraySize(_digitByteArray);
-INT _otherLen = __byteArraySize(_otherDigitByteArray);
+	    INT _otherLen = __byteArraySize(_otherDigitByteArray);
-unsigned char *_otherDigits = __ByteArrayInstPtr(_otherDigitByteArray)->ba_element;
+	    unsigned char *_otherDigits = __ByteArrayInstPtr(_otherDigitByteArray)->ba_element;
-unsigned char *_myDigits = __ByteArrayInstPtr(_digitByteArray)->ba_element;
+	    unsigned char *_myDigits = __ByteArrayInstPtr(_digitByteArray)->ba_element;
-if (_myLen == _otherLen) {
+	    if (_myLen == _otherLen) {
 tryAgain:
-while (_myLen >= (sizeof(INT))) {
+		while (_myLen >= (sizeof(INT)*4)) {
-if ( *(unsigned INT *)_myDigits != *(unsigned INT *)_otherDigits) {
+		    if ( (unsigned INT *)_myDigits[0] != (unsigned INT *)_otherDigits[0]) {
-RETURN(false);
+			RETURN(false);
-}
+		    }
-_myDigits += sizeof(INT);
+		    if ( (unsigned INT *)_myDigits[1] != (unsigned INT *)_otherDigits[1]) {
-_otherDigits += sizeof(INT);
+			RETURN(false);
-_myLen -= sizeof(INT);
+		    }
-}
+		    if ( (unsigned INT *)_myDigits[2] != (unsigned INT *)_otherDigits[2]) {
-while (_myLen > 0) {
+			RETURN(false);
-if ( *_myDigits != *_otherDigits) {
+		    }
-RETURN(false);
+		    if ( (unsigned INT *)_myDigits[3] != (unsigned INT *)_otherDigits[3]) {
-}
+			RETURN(false);
-_myDigits++;
+		    }
-_otherDigits++;
+		    _myDigits += sizeof(INT)*4;
-_myLen--;
+		    _otherDigits += sizeof(INT)*4;
-}
+		    _myLen -= sizeof(INT)*4;
-RETURN(true);
+		}
-}
+		while (_myLen >= (sizeof(INT))) {
-/* care for unnormalized ints */
+		    if ( *(unsigned INT *)_myDigits != *(unsigned INT *)_otherDigits) {
-while ((_myLen > 0) && (_myDigits[_myLen-1] == 0)) _myLen--;
+			RETURN(false);
-while ((_otherLen > 0) && (_otherDigits[_otherLen-1] == 0)) _otherLen--;
+		    }
-if (_myLen == _otherLen) goto tryAgain;
+		    _myDigits += sizeof(INT);
-RETURN(false);
+		    _otherDigits += sizeof(INT);
-}
+		    _myLen -= sizeof(INT);
+		}
+		while (_myLen > 0) {
+		    if ( *_myDigits != *_otherDigits) {
+			RETURN(false);
+		    }
+		    _myDigits++;
+		    _otherDigits++;
+		    _myLen--;
+		}
+		RETURN(true);
+	    }
+	    /* care for unnormalized ints */
+	    while ((_myLen > 0) && (_myDigits[_myLen-1] == 0)) _myLen--;
+	    while ((_otherLen > 0) && (_otherDigits[_otherLen-1] == 0)) _otherLen--;
+	    if (_myLen == _otherLen) goto tryAgain;
+	    RETURN(false);
+	}
 }
 %}.
 len1 := digitByteArray size.
 otherDigitByteArray := aLargeInteger digitBytes.
 "/ when properly normalized;
 "/ but we are tolerant here, to allow for unnormalized
 "/ numbers to be compared ...
 [(digitByteArray basicAt:len1) == 0] whileTrue:[
-len1 := len1 - 1
+	len1 := len1 - 1
 ].
 [(otherDigitByteArray basicAt:len2) == 0] whileTrue:[
-len2 := len2 - 1
+	len2 := len2 - 1
 ].
 (len1 ~~ len2) ifTrue:[^ false].
 [len1 > 0] whileTrue:[
-d1 := digitByteArray basicAt:len1.
+	d1 := digitByteArray basicAt:len1.
-d2 := otherDigitByteArray basicAt:len1.
+	d2 := otherDigitByteArray basicAt:len1.
-(d1 ~~ d2) ifTrue:[^ false].
+	(d1 ~~ d2) ifTrue:[^ false].
-len1 := len1 - 1
+	len1 := len1 - 1
 ].
 ^ true
 "Modified: / 8.5.1999 / 18:37:02 / cg"
 !
 count    "{ Class: SmallInteger }"
 newDigitByteArray result
 ok|
 aPositiveSmallInteger == 0 ifTrue:[
-^ ZeroDivide raiseRequestWith:thisContext
+	^ ZeroDivide raiseRequestWith:thisContext
 ].
 "This cannot happen (if always normalized)
 self < aPositiveSmallInteger ifTrue:[
-^ Array with:0 with:self
+	^ Array with:0 with:self
 ].
 "
 count := digitByteArray size.
 result := self class basicNew numberOfDigits:count.
 newDigitByteArray := result digitBytes.
 __digits = __INST(digitByteArray);
 if (__isByteArray(__digits)
 && __isByteArray(newDigitByteArray)
 && __bothSmallInteger(count, aPositiveSmallInteger)) {
-unsigned INT rest = 0;
+	unsigned INT rest = 0;
-int index = __intVal(count);
+	int index = __intVal(count);
-int index0;
+	int index0;
-unsigned INT divisor = __intVal(aPositiveSmallInteger);
+	unsigned INT divisor = __intVal(aPositiveSmallInteger);
-unsigned char *digitBytes = __ByteArrayInstPtr(__digits)->ba_element;
+	unsigned char *digitBytes = __ByteArrayInstPtr(__digits)->ba_element;
-unsigned char *resultBytes = __ByteArrayInstPtr(newDigitByteArray)->ba_element;
+	unsigned char *resultBytes = __ByteArrayInstPtr(newDigitByteArray)->ba_element;
-index0 = index - 1;
+	index0 = index - 1;
-/*
+	/*
-* divide short-wise
+	 * divide short-wise
-*/
+	 */
-if (divisor <= 0xFFFF) {
+	if (divisor <= 0xFFFF) {
-if ((index & 1) == 0) { /* even number of bytes */
+	    if ((index & 1) == 0) { /* even number of bytes */
-while (index > 1) {
+		while (index > 1) {
-unsigned INT t;
+		    unsigned INT t;
-unsigned INT div;
+		    unsigned INT div;
-index -= 2;
+		    index -= 2;
 #if defined(__LSBFIRST__)
-t = *((unsigned short *)(&digitBytes[index]));
+		    t = *((unsigned short *)(&digitBytes[index]));
 #else
-t = digitBytes[index+1];
+		    t = digitBytes[index+1];
-t = (t << 8) | digitBytes[index];
+		    t = (t << 8) | digitBytes[index];
 #endif
-t = t | (rest << 16);
+		    t = t | (rest << 16);
-div = t / divisor;
+		    div = t / divisor;
-rest = t % divisor;
+		    rest = t % divisor;
 #if defined(__LSBFIRST__)
-*((unsigned short *)(&resultBytes[index])) = (div & 0xFFFF);
+		    *((unsigned short *)(&resultBytes[index])) = (div & 0xFFFF);
 #else
-resultBytes[index+1] = div >> 8;
+		    resultBytes[index+1] = div >> 8;
-resultBytes[index] = div /* & 0xFF */;
+		    resultBytes[index] = div /* & 0xFF */;
 #endif
-}
+		}
-}
+	    }
-}
+	}
-while (index > 0) {
+	while (index > 0) {
-unsigned INT t;
+	    unsigned INT t;
-index--;
+	    index--;
-t = digitBytes[index];
+	    t = digitBytes[index];
-t = t | (rest << 8);
+	    t = t | (rest << 8);
-resultBytes[index] = t / divisor;
+	    resultBytes[index] = t / divisor;
-rest = t % divisor;
+	    rest = t % divisor;
-}
+	}
-prevRest = __mkSmallInteger(rest);
+	prevRest = __mkSmallInteger(rest);
-/*
+	/*
-* no need to normalize ?
+	 * no need to normalize ?
-*/
+	 */
-index = index0;
+	index = index0;
-while ((index >= sizeof(INT)) && (resultBytes[index]==0)) {
+	while ((index >= sizeof(INT)) && (resultBytes[index]==0)) {
-index--;
+	    index--;
-}
+	}
-if (index == index0) {
+	if (index == index0) {
-if (index > sizeof(INT)) {
+	    if (index > sizeof(INT)) {
-RETURN ( __ARRAY_WITH2(result, prevRest));
+		RETURN ( __ARRAY_WITH2(result, prevRest));
-}
+	    }
-if ((index == sizeof(INT))
+	    if ((index == sizeof(INT))
-&& resultBytes[index0] >= 0x40) {
+	    && resultBytes[index0] >= 0x40) {
-RETURN ( __ARRAY_WITH2(result, prevRest));
+		RETURN ( __ARRAY_WITH2(result, prevRest));
-}
+	    }
-}
+	}
-/*
+	/*
-* must compress
+	 * must compress
-*/
+	 */
-ok = true;
+	ok = true;
 }
 %}.
 "
 slow code - not normally reached
 (could also do a primitiveFailure here)
 "
 ok ifFalse:[
-^ self absDivMod:(LargeInteger value:aPositiveSmallInteger).
+	^ self absDivMod:(LargeInteger value:aPositiveSmallInteger).
 ].
 ^ Array with:(result compressed) with:prevRest
 "
 %{  /* NOCONTEXT */
 #if defined(__LSBFIRST__)
 if (__isByteArray(__INST(digitByteArray))
 && __isLargeInteger(aLargeInteger)) {
-OBJ _otherDigitByteArray = __LargeIntegerInstPtr(aLargeInteger)->l_digits;
+	OBJ _otherDigitByteArray = __LargeIntegerInstPtr(aLargeInteger)->l_digits;
-if (__isByteArray(_otherDigitByteArray)) {
+	if (__isByteArray(_otherDigitByteArray)) {
-unsigned char *_myDigits = __ByteArrayInstPtr(__INST(digitByteArray))->ba_element;
+	    unsigned char *_myDigits = __ByteArrayInstPtr(__INST(digitByteArray))->ba_element;
-unsigned char *_otherDigits = __ByteArrayInstPtr(_otherDigitByteArray)->ba_element;
+	    unsigned char *_otherDigits = __ByteArrayInstPtr(_otherDigitByteArray)->ba_element;
-INT _myLen = __byteArraySize(__INST(digitByteArray));
+	    INT _myLen = __byteArraySize(__INST(digitByteArray));
-if (_myLen == __POINTER_SIZE__) {
+	    if (_myLen == __POINTER_SIZE__) {
-INT _otherLen = __byteArraySize(_otherDigitByteArray);
+		INT _otherLen = __byteArraySize(_otherDigitByteArray);
-if (_otherLen == __POINTER_SIZE__) {
+		if (_otherLen == __POINTER_SIZE__) {
-unsigned INT _myVal = *((unsigned INT *)_myDigits);
+		    unsigned INT _myVal = *((unsigned INT *)_myDigits);
-unsigned INT _otherVal = *((unsigned INT *)_otherDigits);
+		    unsigned INT _otherVal = *((unsigned INT *)_otherDigits);
-RETURN( (_myVal < _otherVal) ? true : false );
+		    RETURN( (_myVal < _otherVal) ? true : false );
-}
+		}
-}
+	    }
 # if defined(UINT64) && (__POINTER_SIZE__ != 8)
-if (_myLen == __POINTER_SIZE__) {
+	    if (_myLen == __POINTER_SIZE__) {
-INT _otherLen = __byteArraySize(_otherDigitByteArray);
+		INT _otherLen = __byteArraySize(_otherDigitByteArray);
-if (_otherLen <= 8) {
+		if (_otherLen <= 8) {
-UINT64 _myVal = (UINT64)(*((UINT *)_myDigits));
+		    UINT64 _myVal = (UINT64)(*((UINT *)_myDigits));
-UINT64 _otherVal = *((UINT64 *)_otherDigits);
+		    UINT64 _otherVal = *((UINT64 *)_otherDigits);
-RETURN( (_myVal < _otherVal) ? true : false );
+		    RETURN( (_myVal < _otherVal) ? true : false );
-}
+		}
-} else {
+	    } else {
-if (_myLen <= 8) {
+		if (_myLen <= 8) {
-INT _otherLen = __byteArraySize(_otherDigitByteArray);
+		    INT _otherLen = __byteArraySize(_otherDigitByteArray);
-if (_otherLen <= 8) {
+		    if (_otherLen <= 8) {
-UINT64 _myVal = (*((UINT64 *)_myDigits));
+			UINT64 _myVal = (*((UINT64 *)_myDigits));
-UINT64 _otherVal = *((UINT64 *)_otherDigits);
+			UINT64 _otherVal = *((UINT64 *)_otherDigits);
-RETURN( (_myVal < _otherVal) ? true : false );
+			RETURN( (_myVal < _otherVal) ? true : false );
-}
+		    }
-if (_otherLen == __POINTER_SIZE__) {
+		    if (_otherLen == __POINTER_SIZE__) {
-UINT64 _myVal = (*((UINT64 *)_myDigits));
+			UINT64 _myVal = (*((UINT64 *)_myDigits));
-UINT64 _otherVal = (UINT64) *((UINT *)_otherDigits);
+			UINT64 _otherVal = (UINT64) *((UINT *)_otherDigits);
-RETURN( (_myVal < _otherVal) ? true : false );
+			RETURN( (_myVal < _otherVal) ? true : false );
-}
+		    }
-}
+		}
-}
+	    }
 # endif /* UINT64 */
-}
+	}
 }
 #endif /* LSBFIRST */
 %}.
 myLen := digitByteArray size.
 "/ when properly normalized;
 "/ but we are tolerant here, to allow for unnormalized
 "/ numbers to be compared ...
 [myLen > 0 and:[(digitByteArray basicAt:myLen) == 0]] whileTrue:[
-myLen := myLen - 1
+	myLen := myLen - 1
 ].
 [otherLen > 0 and:[(otherDigitByteArray basicAt:otherLen) == 0]] whileTrue:[
-otherLen := otherLen - 1
+	otherLen := otherLen - 1
 ].
 (myLen < otherLen) ifTrue:[^ true].
 (myLen > otherLen) ifTrue:[^ false].
 [myLen > 0] whileTrue:[
-d1 := digitByteArray basicAt:myLen.
+	d1 := digitByteArray basicAt:myLen.
-d2 := otherDigitByteArray basicAt:myLen.
+	d2 := otherDigitByteArray basicAt:myLen.
-d1 == d2 ifFalse:[
+	d1 == d2 ifFalse:[
-(d1 < d2) ifTrue:[^ true].
+	    (d1 < d2) ifTrue:[^ true].
-^ false
+	    ^ false
-].
+	].
-myLen := myLen - 1
+	myLen := myLen - 1
 ].
 ^ false
 "
 |a b|
 a := 16rFEFFFFFF.
 b := 16rFFFFFFFF.
 Time millisecondsToRun:[
 10000000 timesRepeat:[ a absLess_n:b ]
 ] 686 655 702 702
 16rEFFFFFFF  absLess_n: 16rFFFFFFFF
 16rEFFFFFFF  absLess: 16rFFFFFFFF
 "
 "Modified: / 3.5.1999 / 08:06:28 / stefan"
 "Modified: / 8.5.1999 / 18:37:11 / cg"
 !
 %{  /* NOCONTEXT */
 #if defined(__LSBFIRST__)
 if (__isByteArray(__INST(digitByteArray))
 && __isLargeInteger(aLargeInteger)) {
-OBJ _otherDigitByteArray = __LargeIntegerInstPtr(aLargeInteger)->l_digits;
+	OBJ _otherDigitByteArray = __LargeIntegerInstPtr(aLargeInteger)->l_digits;
-if (__isByteArray(_otherDigitByteArray)) {
+	if (__isByteArray(_otherDigitByteArray)) {
-unsigned char *_myDigits = __ByteArrayInstPtr(__INST(digitByteArray))->ba_element;
+	    unsigned char *_myDigits = __ByteArrayInstPtr(__INST(digitByteArray))->ba_element;
-unsigned char *_otherDigits = __ByteArrayInstPtr(_otherDigitByteArray)->ba_element;
+	    unsigned char *_otherDigits = __ByteArrayInstPtr(_otherDigitByteArray)->ba_element;
-INT _myLen = __byteArraySize(__INST(digitByteArray));
+	    INT _myLen = __byteArraySize(__INST(digitByteArray));
-if (_myLen == __POINTER_SIZE__) {
+	    if (_myLen == __POINTER_SIZE__) {
-INT _otherLen = __byteArraySize(_otherDigitByteArray);
+		INT _otherLen = __byteArraySize(_otherDigitByteArray);
-if (_otherLen == __POINTER_SIZE__) {
+		if (_otherLen == __POINTER_SIZE__) {
-unsigned INT _myVal = *((unsigned INT *)_myDigits);
+		    unsigned INT _myVal = *((unsigned INT *)_myDigits);
-unsigned INT _otherVal = *((unsigned INT *)_otherDigits);
+		    unsigned INT _otherVal = *((unsigned INT *)_otherDigits);
-RETURN( (_myVal <= _otherVal) ? true : false );
+		    RETURN( (_myVal <= _otherVal) ? true : false );
-}
+		}
-}
+	    }
 # if defined(UINT64) && (__POINTER_SIZE__ != 8)
-if (_myLen == __POINTER_SIZE__) {
+	    if (_myLen == __POINTER_SIZE__) {
-INT _otherLen = __byteArraySize(_otherDigitByteArray);
+		INT _otherLen = __byteArraySize(_otherDigitByteArray);
-if (_otherLen <= 8) {
+		if (_otherLen <= 8) {
-UINT64 _myVal = (UINT64)(*((UINT *)_myDigits));
+		    UINT64 _myVal = (UINT64)(*((UINT *)_myDigits));
-UINT64 _otherVal = *((UINT64 *)_otherDigits);
+		    UINT64 _otherVal = *((UINT64 *)_otherDigits);
-RETURN( (_myVal <= _otherVal) ? true : false );
+		    RETURN( (_myVal <= _otherVal) ? true : false );
-}
+		}
-} else {
+	    } else {
-if (_myLen <= 8) {
+		if (_myLen <= 8) {
-INT _otherLen = __byteArraySize(_otherDigitByteArray);
+		    INT _otherLen = __byteArraySize(_otherDigitByteArray);
-if (_otherLen <= 8) {
+		    if (_otherLen <= 8) {
-UINT64 _myVal = (*((UINT64 *)_myDigits));
+			UINT64 _myVal = (*((UINT64 *)_myDigits));
-UINT64 _otherVal = *((UINT64 *)_otherDigits);
+			UINT64 _otherVal = *((UINT64 *)_otherDigits);
-RETURN( (_myVal <= _otherVal) ? true : false );
+			RETURN( (_myVal <= _otherVal) ? true : false );
-}
+		    }
-if (_otherLen == __POINTER_SIZE__) {
+		    if (_otherLen == __POINTER_SIZE__) {
-UINT64 _myVal = (*((UINT64 *)_myDigits));
+			UINT64 _myVal = (*((UINT64 *)_myDigits));
-UINT64 _otherVal = (UINT64) *((UINT *)_otherDigits);
+			UINT64 _otherVal = (UINT64) *((UINT *)_otherDigits);
-RETURN( (_myVal <= _otherVal) ? true : false );
+			RETURN( (_myVal <= _otherVal) ? true : false );
-}
+		    }
-}
+		}
-}
+	    }
 # endif /* UINT64 */
-}
+	}
 }
 #endif /* LSBFIRST */
 %}.
 myLen := digitByteArray size.
 "/ when properly normalized;
 "/ but we are tolerant here, to allow for unnormalized
 "/ numbers to be compared ...
 [(digitByteArray basicAt:myLen) == 0] whileTrue:[
-myLen := myLen - 1
+	myLen := myLen - 1
 ].
 [(otherDigitByteArray basicAt:otherLen) == 0] whileTrue:[
-otherLen := otherLen - 1
+	otherLen := otherLen - 1
 ].
 (myLen < otherLen) ifTrue:[^ true].
 (myLen > otherLen) ifTrue:[^ false].
 [myLen > 0] whileTrue:[
-d1 := digitByteArray basicAt:myLen.
+	d1 := digitByteArray basicAt:myLen.
-d2 := otherDigitByteArray basicAt:myLen.
+	d2 := otherDigitByteArray basicAt:myLen.
-d1 == d2 ifFalse:[
+	d1 == d2 ifFalse:[
-(d1 < d2) ifTrue:[^ true].
+	    (d1 < d2) ifTrue:[^ true].
-^ false.
+	    ^ false.
-].
+	].
-myLen := myLen - 1
+	myLen := myLen - 1
 ].
 ^ true
 "Created: / 13.2.1998 / 12:19:45 / stefan"
 "Modified: / 30.4.1999 / 12:46:31 / stefan"
 len1 := digitByteArray size.
 otherDigitByteArray := aLargeInteger digitBytes.
 len2 := otherDigitByteArray size.
 len1 > len2 ifTrue:[
-lResult := len1
+	lResult := len1
 ] ifFalse:[
-lResult := (len1 max: len2) + 1.
+	lResult := (len1 max: len2) + 1.
 ].
 result := self class basicNew numberOfDigits:lResult.
 result sign:newSign.
 resultDigitByteArray := result digitBytes.
 OBJ _digitByteArray = __INST(digitByteArray);
 if (__isByteArray(_digitByteArray)
 && __isByteArray(otherDigitByteArray)
 && __isByteArray(resultDigitByteArray)) {
-int __len1 = __intVal(len1);
+	int __len1 = __intVal(len1);
-int __len2 = __intVal(len2);
+	int __len2 = __intVal(len2);
-int __minLen = __len1 < __len2 ? __len1 : __len2;
+	int __minLen = __len1 < __len2 ? __len1 : __len2;
-int __index, __borrow = 0;
+	int __index, __borrow = 0;
-INT __diff;
+	INT __diff;
-unsigned char *__myDigits, *__otherDigits, *__resultDigits;
+	unsigned char *__myDigits, *__otherDigits, *__resultDigits;
-ok = true;
+	ok = true;
-__resultDigits = __ByteArrayInstPtr(resultDigitByteArray)->ba_element;
+	__resultDigits = __ByteArrayInstPtr(resultDigitByteArray)->ba_element;
-__otherDigits = __ByteArrayInstPtr(otherDigitByteArray)->ba_element;
+	__otherDigits = __ByteArrayInstPtr(otherDigitByteArray)->ba_element;
-__myDigits = __ByteArrayInstPtr(_digitByteArray)->ba_element;
+	__myDigits = __ByteArrayInstPtr(_digitByteArray)->ba_element;
-__index = 1;
+	__index = 1;
 #if defined(__LSBFIRST__)
 # if __POINTER_SIZE__ == 8
-/*
+	/*
-* subtract int-wise
+	 * subtract int-wise
-*/
+	 */
-while ((__index+3) <= __minLen) {
+	while ((__index+3) <= __minLen) {
-/* do not make this into one expression - ask cg why */
+	    /* do not make this into one expression - ask cg why */
-__diff = ((unsigned int *)(__myDigits+__index-1))[0];
+	    __diff = ((unsigned int *)(__myDigits+__index-1))[0];
-__diff -= ((unsigned int *)(__otherDigits+__index-1))[0];
+	    __diff -= ((unsigned int *)(__otherDigits+__index-1))[0];
-__diff -= __borrow;
+	    __diff -= __borrow;
-if (__diff >= 0) {
+	    if (__diff >= 0) {
-__borrow = 0;
+		__borrow = 0;
-} else {
+	    } else {
-__borrow = 1;
+		__borrow = 1;
-/* __diff += 0x10000; */
+		/* __diff += 0x10000; */
-}
+	    }
-((unsigned int *)(__resultDigits+__index-1))[0] = __diff;
+	    ((unsigned int *)(__resultDigits+__index-1))[0] = __diff;
-__index += 4;
+	    __index += 4;
-}
+	}
 # endif /* 64bit */
-/*
+	/*
-* subtract short-wise
+	 * subtract short-wise
-*/
+	 */
-while (__index < __minLen) {   /* i.e. index+1 <= minLen */
+	while (__index < __minLen) {   /* i.e. index+1 <= minLen */
-/* do not make this into one expression - ask cg why */
+	    /* do not make this into one expression - ask cg why */
-__diff = ((unsigned short *)(__myDigits+__index-1))[0];
+	    __diff = ((unsigned short *)(__myDigits+__index-1))[0];
-__diff -= ((unsigned short *)(__otherDigits+__index-1))[0];
+	    __diff -= ((unsigned short *)(__otherDigits+__index-1))[0];
-__diff -= __borrow;
+	    __diff -= __borrow;
-if (__diff >= 0) {
+	    if (__diff >= 0) {
-__borrow = 0;
+		__borrow = 0;
-} else {
+	    } else {
-__borrow = 1;
+		__borrow = 1;
-/* __diff += 0x10000; */
+		/* __diff += 0x10000; */
-}
+	    }
-((unsigned short *)(__resultDigits+__index-1))[0] = __diff;
+	    ((unsigned short *)(__resultDigits+__index-1))[0] = __diff;
-__index += 2;
+	    __index += 2;
-}
+	}
-if (__index == __minLen) {
+	if (__index == __minLen) {
-/* one of the operands has odd length - cannot continue short-wise */
+	    /* one of the operands has odd length - cannot continue short-wise */
-} else {
+	} else {
-if (__len1 > __len2) {
+	    if (__len1 > __len2) {
-while (__index < __len1) {
+		while (__index < __len1) {
-/* do not make this into one expression - ask cg why */
+		    /* do not make this into one expression - ask cg why */
-__diff = ((unsigned short *)(__myDigits+__index-1))[0];
+		    __diff = ((unsigned short *)(__myDigits+__index-1))[0];
-__diff -= __borrow;
+		    __diff -= __borrow;
-if (__diff >= 0) {
+		    if (__diff >= 0) {
-__borrow = 0;
+			__borrow = 0;
-((unsigned short *)(__resultDigits+__index-1))[0] = __diff;
+			((unsigned short *)(__resultDigits+__index-1))[0] = __diff;
-__index += 2;
+			__index += 2;
-/* copy over rest */
+			/* copy over rest */
-while (__index < __len1) {
+			while (__index < __len1) {
-((unsigned short *)(__resultDigits+__index-1))[0] = ((unsigned short *)(__myDigits+__index-1))[0];
+			    ((unsigned short *)(__resultDigits+__index-1))[0] = ((unsigned short *)(__myDigits+__index-1))[0];
-__index+=2;
+			    __index+=2;
-}
+			}
-if (__index <= __len1) {
+			if (__index <= __len1) {
-__resultDigits[__index-1] = __myDigits[__index-1];
+			    __resultDigits[__index-1] = __myDigits[__index-1];
-__index++;
+			    __index++;
-}
+			}
-break;
+			break;
-}
+		    }
-__borrow = 1;
+		    __borrow = 1;
-/* __diff += 0x10000; */
+		    /* __diff += 0x10000; */
-((unsigned short *)(__resultDigits+__index-1))[0] = __diff;
+		    ((unsigned short *)(__resultDigits+__index-1))[0] = __diff;
-__index += 2;
+		    __index += 2;
-}
+		}
-} else {
+	    } else {
-if (__len2 > __len1) {
+		if (__len2 > __len1) {
-while (__index < __len2) {
+		    while (__index < __len2) {
-/* do not make this into one expression - ask cg why */
+			/* do not make this into one expression - ask cg why */
-__diff = 0;
+			__diff = 0;
-__diff -= ((unsigned short *)(__otherDigits+__index-1))[0];
+			__diff -= ((unsigned short *)(__otherDigits+__index-1))[0];
-__diff -= __borrow;
+			__diff -= __borrow;
-if (__diff >= 0) {
+			if (__diff >= 0) {
-__borrow = 0;
+			    __borrow = 0;
-} else {
+			} else {
-__borrow = 1;
+			    __borrow = 1;
-/* __diff += 0x10000; */
+			    /* __diff += 0x10000; */
-}
+			}
-((unsigned short *)(__resultDigits+__index-1))[0] = __diff;
+			((unsigned short *)(__resultDigits+__index-1))[0] = __diff;
-__index += 2;
+			__index += 2;
-}
+		    }
-}
+		}
-}
+	    }
-}
+	}
 #endif
-/*
+	/*
-* subtract byte-wise
+	 * subtract byte-wise
-*/
+	 */
-while (__index <= __minLen) {
+	while (__index <= __minLen) {
-/* do not make this into one expression - ask cg why */
+	    /* do not make this into one expression - ask cg why */
-__diff = __myDigits[__index-1];
+	    __diff = __myDigits[__index-1];
-__diff -= __otherDigits[__index-1];
+	    __diff -= __otherDigits[__index-1];
-__diff -= __borrow;
+	    __diff -= __borrow;
-if (__diff >= 0) {
+	    if (__diff >= 0) {
-__borrow = 0;
+		__borrow = 0;
-} else {
+	    } else {
-__borrow = 1;
+		__borrow = 1;
-/* __diff += 0x100; */
+		/* __diff += 0x100; */
-}
+	    }
-__resultDigits[__index-1] = __diff;
+	    __resultDigits[__index-1] = __diff;
-__index++;
+	    __index++;
-}
+	}
-if (__len1 > __len2) {
+	if (__len1 > __len2) {
-while (__index <= __len1) {
+	    while (__index <= __len1) {
-/* do not make this into one expression - ask cg why */
+		/* do not make this into one expression - ask cg why */
-__diff = __myDigits[__index-1];
+		__diff = __myDigits[__index-1];
-__diff -= __borrow;
+		__diff -= __borrow;
-if (__diff >= 0) {
+		if (__diff >= 0) {
-__borrow = 0;
+		    __borrow = 0;
-/* copy over rest */
+		    /* copy over rest */
-__resultDigits[__index-1] = __diff;
+		    __resultDigits[__index-1] = __diff;
-__index++;
+		    __index++;
-while (__index <= __len1) {
+		    while (__index <= __len1) {
-__resultDigits[__index-1] = __myDigits[__index-1];
+			__resultDigits[__index-1] = __myDigits[__index-1];
-__index++;
+			__index++;
-}
+		    }
-break;
+		    break;
-}
+		}
-__borrow = 1;
+		__borrow = 1;
-/* __diff += 0x100; */
+		/* __diff += 0x100; */
-__resultDigits[__index-1] = __diff;
+		__resultDigits[__index-1] = __diff;
-__index++;
+		__index++;
-}
+	    }
-} else {
+	} else {
-if (__len2 > __len1) {
+	    if (__len2 > __len1) {
-while (__index <= __len2) {
+		while (__index <= __len2) {
-/* do not make this into one expression - ask cg why */
+		    /* do not make this into one expression - ask cg why */
-__diff = 0;
+		    __diff = 0;
-__diff -= __otherDigits[__index-1];
+		    __diff -= __otherDigits[__index-1];
-__diff -= __borrow;
+		    __diff -= __borrow;
-if (__diff >= 0) {
+		    if (__diff >= 0) {
-__borrow = 0;
+			__borrow = 0;
-} else {
+		    } else {
-__borrow = 1;
+			__borrow = 1;
-/* __diff += 0x100; */
+			/* __diff += 0x100; */
-}
+		    }
-__resultDigits[__index-1] = __diff;
+		    __resultDigits[__index-1] = __diff;
-__index++;
+		    __index++;
-}
+		}
-}
+	    }
-}
+	}
-borrow = __mkSmallInteger(__borrow);
+	borrow = __mkSmallInteger(__borrow);
-index = __mkSmallInteger(__index);
+	index = __mkSmallInteger(__index);
-lastDigit = __mkSmallInteger(__resultDigits[__intVal(lResult)-1]);
+	lastDigit = __mkSmallInteger(__resultDigits[__intVal(lResult)-1]);
 }
 %}.
 ok == true ifFalse:[
-index := 1.
+	index := 1.
-borrow := 0.
+	borrow := 0.
-done := false.
+	done := false.
-[done] whileFalse:[
+	[done] whileFalse:[
-diff := borrow.
+	    diff := borrow.
-(index <= len1) ifTrue:[
+	    (index <= len1) ifTrue:[
-diff := diff + (digitByteArray basicAt:index).
+		diff := diff + (digitByteArray basicAt:index).
-(index <= len2) ifTrue:[
+		(index <= len2) ifTrue:[
-diff := diff - (otherDigitByteArray basicAt:index)
+		    diff := diff - (otherDigitByteArray basicAt:index)
-]
+		]
-] ifFalse:[
+	    ] ifFalse:[
-(index <= len2) ifTrue:[
+		(index <= len2) ifTrue:[
-diff := diff - (otherDigitByteArray basicAt:index)
+		    diff := diff - (otherDigitByteArray basicAt:index)
-] ifFalse:[
+		] ifFalse:[
-"end reached"
+		    "end reached"
-done := true
+		    done := true
-]
+		]
-].
+	    ].
-"/ workaround for
+	    "/ workaround for
-"/ gcc code generator bug
+	    "/ gcc code generator bug
-(diff >= 0) ifTrue:[
+	    (diff >= 0) ifTrue:[
-borrow := 0
+		borrow := 0
-] ifFalse:[
+	    ] ifFalse:[
-borrow := -1.
+		borrow := -1.
-diff := diff + 16r100
+		diff := diff + 16r100
-].
+	    ].
 "/        (diff < 0) ifTrue:[
 "/            borrow := -1.
 "/            diff := diff + 16r100
 "/        ] ifFalse:[
 "/            borrow := 0
 "/        ].
-resultDigitByteArray basicAt:index put:diff.
+	    resultDigitByteArray basicAt:index put:diff.
-index := index + 1
+	    index := index + 1
-].
+	].
-lastDigit := resultDigitByteArray basicAt:lResult.
+	lastDigit := resultDigitByteArray basicAt:lResult.
 ].
 (borrow ~~ 0) ifTrue:[
-"/ must generate 255's complement
+	"/ must generate 255's complement
-result sign:newSign negated.
+	result sign:newSign negated.
-[index <= lResult] whileTrue:[
+	[index <= lResult] whileTrue:[
-resultDigitByteArray basicAt:index put:16rFF.
+	    resultDigitByteArray basicAt:index put:16rFF.
-index := index + 1.
+	    index := index + 1.
-].
+	].
-index := lResult.
+	index := lResult.
-[index > 0] whileTrue:[
+	[index > 0] whileTrue:[
-resultDigitByteArray basicAt:index put:(255 - (resultDigitByteArray at:index)).
+	    resultDigitByteArray basicAt:index put:(255 - (resultDigitByteArray at:index)).
-index := index - 1.
+	    index := index - 1.
-].
+	].
-index := 1.
+	index := 1.
-carry := 1.
+	carry := 1.
-[carry ~~ 0] whileTrue:[
+	[carry ~~ 0] whileTrue:[
-(index <= lResult) ifTrue:[
+	    (index <= lResult) ifTrue:[
-carry := (resultDigitByteArray basicAt:index) + carry.
+		carry := (resultDigitByteArray basicAt:index) + carry.
-].
+	    ].
-resultDigitByteArray basicAt:index put:(carry bitAnd:16rFF).
+	    resultDigitByteArray basicAt:index put:(carry bitAnd:16rFF).
-carry := carry bitShift:-8.
+	    carry := carry bitShift:-8.
-index := index + 1
+	    index := index + 1
-].
+	].
-lastDigit := resultDigitByteArray basicAt:lResult.
+	lastDigit := resultDigitByteArray basicAt:lResult.
 ].
 (lastDigit ~~ 0 and:[lResult > SmallInteger maxBytes]) ifTrue:[
-^ result
+	^ result
 ].
 ^ result compressed
 "Modified: 5.11.1996 / 14:09:25 / cg"
 !
 ! !
 !LargeInteger class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/LargeInteger.st,v 1.194 2009-05-26 06:37:56 cg Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/LargeInteger.st,v 1.195 2009-09-14 22:16:50 cg Exp $'
 ! !

changeset 11927	75c9deec4a70
parent 11731	f3adbab61060
child 11959	1ff0e6f908d9