hg/stx-libbasic: comparison SmallInteger.st

equal deleted inserted replaced

-:22c7071ff004
+:8c0f47cf59e3
 INT me, t, val;
 double dval;
 if (__isSmallInteger(aNumber)) {
-	val = __intVal(aNumber);
+val = __intVal(aNumber);
-	if (val != 0) {
+if (val != 0) {
-	    me = __intVal(self);
+me = __intVal(self);
-	    t = me / val;
+t = me / val;
 #ifdef GOOD_OPTIMIZER
-	    if (me % val) {
+if (me % val) {
 #else
-	    /* this is stupid - all I want is to look for a remainder ...
+/* this is stupid - all I want is to look for a remainder ...
-	       but most compilers are too stupid and generate an extra modulu
+but most compilers are too stupid and generate an extra modulus
-	       instruction for "if (me % val)".
+instruction for "if (me % val)".
-	       Even if most divide instructions already leave the remainder in
+Even if most divide instructions already leave the remainder in
-	       some register.
+some register.
-	       Therefore I use a multiplication which is faster than a modulu
+Therefore I use a multiplication which is faster than a modulo
-	       on most machines. Hint to GNU people :-)
+on most machines. Hint to GNU people :-)
-	    */
+*/
-	    if ((t * val) == me) {
+if ((t * val) == me) {
 #endif
-		RETURN ( __MKSMALLINT(t) );
+RETURN ( __MKSMALLINT(t) );
-	    }
+}
-	}
+}
 } else {
-	if (__isFloatLike(aNumber)) {
+if (__isFloatLike(aNumber)) {
-	    dval = __floatVal(aNumber);
+dval = __floatVal(aNumber);
-	    if (dval != 0.0) {
+if (dval != 0.0) {
-		OBJ newFloat;
+OBJ newFloat;
-		double val = (double)__intVal(self) / dval;
+double val = (double)__intVal(self) / dval;
-		__qMKFLOAT(newFloat, val);
+__qMKFLOAT(newFloat, val);
-		RETURN ( newFloat );
+RETURN ( newFloat );
-	    }
+}
-	}
+}
 }
 %}.
 aNumber isInteger ifTrue:[
-	aNumber == 0 ifTrue:[
+aNumber == 0 ifTrue:[
-	    ^ DivisionByZeroSignal raise.
+^ DivisionByZeroSignal raise.
-	].
+].
-	^ Fraction numerator:self denominator:aNumber
+^ Fraction numerator:self denominator:aNumber
 ].
 ^ aNumber quotientFromInteger:self
 "
 8 / 4
 selfInt = ttt;
 ttt = temp;
 }
 /*
 * since its not defined in C, what the sign of
-* a modulu result is when the arg is negative,
+* a modulus result is when the arg is negative,
 * change it explicitely here ...
 */
 if (orgArg < 0) {
 /* result should be negative */
 if (orgSelfInt > 0) selfInt = -selfInt;
 self < 100000000 ifTrue:[^ 8].
 self < 1000000000 ifTrue:[^ 9].
 ^ 10
 ! !
-!SmallInteger methodsFor:'modulu arithmetic'!
+!SmallInteger methodsFor:'modulo arithmetic'!
 plus:aNumber
 "return the sum of the receiver and the argument, as SmallInteger.
 The argument must be another SmallInteger.
-If the result overflows the smallInteger range, the value modulu the
+If the result overflows the smallInteger range, the value modulo the
 smallInteger range is returned (i.e. the low bits of the sum).
-This is of course not always correct, but some code does a modulu anyway
+This is of course not always correct, but some code does a modulo anyway
 and can therefore speed things up by not going through LargeIntegers."
 %{  /* NOCONTEXT */
 if (__isSmallInteger(aNumber)) {
-	INT sum;
+INT sum;
-	sum = __intVal(self) + __intVal(aNumber);
+sum = __intVal(self) + __intVal(aNumber);
 #ifdef alpha64
-	sum &= 0x7FFFFFFFFFFFFFFFL;
+sum &= 0x7FFFFFFFFFFFFFFFL;
 #else
-	sum &= 0x7FFFFFFF;
+sum &= 0x7FFFFFFF;
 #endif
-	RETURN ( __MKSMALLINT(sum));
+RETURN ( __MKSMALLINT(sum));
 }
 %}.
 self primitiveFailed
 !
 subtract:aNumber
 "return the difference of the receiver and the argument, as SmallInteger.
 The argument must be another SmallInteger.
-If the result overflows the smallInteger range, the value modulu the
+If the result overflows the smallInteger range, the value modulo the
 smallInteger range is returned (i.e. the low bits of the sum).
-This is of course not always correct, but some code does a modulu anyway
+This is of course not always correct, but some code does a modulo anyway
 and can therefore speed things up by not going through LargeIntegers."
 %{  /* NOCONTEXT */
 if (__isSmallInteger(aNumber)) {
-	INT diff;
+INT diff;
-	diff = __intVal(self) - __intVal(aNumber);
+diff = __intVal(self) - __intVal(aNumber);
 #ifdef alpha64
-	diff &= 0x7FFFFFFFFFFFFFFFL;
+diff &= 0x7FFFFFFFFFFFFFFFL;
 #else
-	diff &= 0x7FFFFFFF;
+diff &= 0x7FFFFFFF;
 #endif
-	RETURN ( __MKSMALLINT(diff));
+RETURN ( __MKSMALLINT(diff));
 }
 %}.
 self primitiveFailed
 !
 times:aNumber
 "return the product of the receiver and the argument, as SmallInteger.
 The argument must be another SmallInteger.
-If the result overflows the smallInteger range, the value modulu the
+If the result overflows the smallInteger range, the value modulo the
 smallInteger range is returned (i.e. the low bits of the product).
-This is of course not always correct, but some code does a modulu anyway
+This is of course not always correct, but some code does a modulo anyway
 and can therefore speed things up by not going through LargeIntegers."
 %{  /* NOCONTEXT */
 if (__isSmallInteger(aNumber)) {
-	INT prod;
+INT prod;
-	prod = __intVal(self) * __intVal(aNumber);
+prod = __intVal(self) * __intVal(aNumber);
 #ifdef alpha64
-	prod &= 0x7FFFFFFFFFFFFFFFL;
+prod &= 0x7FFFFFFFFFFFFFFFL;
 #else
-	prod &= 0x7FFFFFFF;
+prod &= 0x7FFFFFFF;
 #endif
-	RETURN ( __MKSMALLINT(prod));
+RETURN ( __MKSMALLINT(prod));
 }
 %}.
 self primitiveFailed
 ! !
 ! !
 !SmallInteger class methodsFor:'documentation'!
 version
-^ '$Header: /cvs/stx/stx/libbasic/SmallInteger.st,v 1.90 1997-12-17 21:20:10 cg Exp $'
+^ '$Header: /cvs/stx/stx/libbasic/SmallInteger.st,v 1.91 1997-12-19 08:38:23 stefan Exp $'
 ! !

changeset 3135	8c0f47cf59e3
parent 3131	8170f7412e90
child 3156	3d63afe752e5