--- a/SmallInteger.st Mon May 10 15:13:07 1999 +0200
+++ b/SmallInteger.st Mon May 10 15:45:48 1999 +0200
@@ -199,8 +199,8 @@
#endif
if (__isSmallInteger(aNumber)) {
- myValue = __intVal(self);
- otherValue = __intVal(aNumber);
+ myValue = __intVal(self);
+ otherValue = __intVal(aNumber);
#if defined(INT64)
# if !defined(alpha64)
@@ -211,155 +211,163 @@
#endif
#if defined(USE_LONGLONG)
- {
+ {
# if defined(alpha) && !defined(alpha64)
# define LONGLONG INT64
# else
# define LONGLONG long long
# endif
- LONGLONG product;
-
- product = (LONGLONG)myValue * (LONGLONG)otherValue;
- if ((product >= (LONGLONG)_MIN_INT)
- && (product <= (LONGLONG)_MAX_INT)) {
- RETURN ( __MKSMALLINT((INT)product) );
- }
- if (product < 0) {
- negative = -1;
- product = -product;
- } else {
- negative = 1;
- }
- productHi = product >> 32;
- productLow = product & 0xFFFFFFFFL;
- }
+ LONGLONG product;
+
+ product = (LONGLONG)myValue * (LONGLONG)otherValue;
+ if ((product >= (LONGLONG)_MIN_INT)
+ && (product <= (LONGLONG)_MAX_INT)) {
+ RETURN ( __MKSMALLINT((INT)product) );
+ }
+ if (product < 0) {
+ negative = -1;
+ product = -product;
+ } else {
+ negative = 1;
+ }
+ productHi = product >> 32;
+ productLow = product & 0xFFFFFFFFL;
+ }
#else
- negative = 1;
- if (myValue < 0) {
- negative = -1;
- myValue = -myValue;
- }
- if (otherValue < 0) {
- negative = -negative;
- otherValue = -otherValue;
- }
+ negative = 1;
+ if (myValue < 0) {
+ negative = -1;
+ myValue = -myValue;
+ }
+ if (otherValue < 0) {
+ negative = -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)));
+ 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)));
+ 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
- */
-# ifdef alpha64
- low1 = low32Bits(myValue);
- hi1 = hi32Bits(myValue);
- low2 = low32Bits(otherValue);
- hi2 = hi32Bits(otherValue);
-# define LLMASK 0xC000000000000000L
-# else
- low1 = low16Bits(myValue);
- hi1 = hi16Bits(myValue);
- low2 = low16Bits(otherValue);
- hi2 = hi16Bits(otherValue);
-# define LLMASK 0xC0000000
-# endif
-
- pLH = low1 * hi2;
- pHL = hi1 * low2;
- pLL = low1 * low2;
- pHH = hi1 * hi2;
+# if defined(WIN32)
+ asm {
+ mov eax, myValue
+ mov edx, otherValue
+ mul edx
+ mov productLow, eax
+ mov productHi, edx
+ }
+# else /* generic */
+ {
+ 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
+ */
+# ifdef alpha64
+ low1 = low32Bits(myValue);
+ hi1 = hi32Bits(myValue);
+ low2 = low32Bits(otherValue);
+ hi2 = hi32Bits(otherValue);
+# define LLMASK 0xC000000000000000L
+# else
+ low1 = low16Bits(myValue);
+ hi1 = hi16Bits(myValue);
+ low2 = low16Bits(otherValue);
+ hi2 = hi16Bits(otherValue);
+# define LLMASK 0xC0000000
+# endif
+
+ pLH = low1 * hi2;
+ pHL = hi1 * low2;
+ pLL = low1 * low2;
+ pHH = hi1 * hi2;
- /*
- * the common case ...
- */
- if ((pHL == 0)
- && (pLH == 0)
- && (pHH == 0)
- && ((pLL & LLMASK) == 0)) {
- if (negative < 0) {
- RETURN ( __MKSMALLINT(- ((INT)pLL)) );
- }
- RETURN ( __MKSMALLINT((INT)pLL) );
- }
-
- /*
- * pHH |--------|--------|
- * pLH |--------|--------|
- * pHL |--------|--------|
- * pLL |--------|--------|
- */
-
-# ifdef alpha64
- t = low32Bits(pLH) + low32Bits(pHL) + hi32Bits(pLL);
- productLow = (t << 32) + low32Bits(pLL);
- productHi = pHH + hi32Bits(t) + hi32Bits(pHL) + hi32Bits(pLH);
- if (t >= 0x100000000L) {
- productHi += t >> 32;
- }
-# else
- t = low16Bits(pLH) + low16Bits(pHL) + hi16Bits(pLL);
- productLow = (t << 16) + low16Bits(pLL);
- productHi = pHH + hi16Bits(t) + hi16Bits(pHL) + hi16Bits(pLH);
- if (t >= 0x10000L) {
- productHi += t >> 16;
- }
-# endif
- }
-# endif
-# endif
-
- if (productHi == 0) {
- if (negative < 0) {
- if (productLow <= -(_MIN_INT)) {
- RETURN ( __MKSMALLINT(-((INT)productLow)) );
- }
- } else {
- if (productLow <= _MAX_INT) {
- RETURN ( __MKSMALLINT(productLow) );
- }
- }
- }
+ /*
+ * the common case ...
+ */
+ if ((pHL == 0)
+ && (pLH == 0)
+ && (pHH == 0)
+ && ((pLL & LLMASK) == 0)) {
+ if (negative < 0) {
+ RETURN ( __MKSMALLINT(- ((INT)pLL)) );
+ }
+ RETURN ( __MKSMALLINT((INT)pLL) );
+ }
+
+ /*
+ * pHH |--------|--------|
+ * pLH |--------|--------|
+ * pHL |--------|--------|
+ * pLL |--------|--------|
+ */
+
+# ifdef alpha64
+ t = low32Bits(pLH) + low32Bits(pHL) + hi32Bits(pLL);
+ productLow = (t << 32) + low32Bits(pLL);
+ productHi = pHH + hi32Bits(t) + hi32Bits(pHL) + hi32Bits(pLH);
+ if (t >= 0x100000000L) {
+ productHi += t >> 32;
+ }
+# else
+ t = low16Bits(pLH) + low16Bits(pHL) + hi16Bits(pLL);
+ productLow = (t << 16) + low16Bits(pLL);
+ productHi = pHH + hi16Bits(t) + hi16Bits(pHL) + hi16Bits(pLH);
+ if (t >= 0x10000L) {
+ productHi += t >> 16;
+ }
+# endif
+ }
+# endif /* ! WIN32 */
+# endif /* ! (__GNUC__ && i386) */
+# endif /* ! (__GNUC__ && mc68k) */
+
+ if (productHi == 0) {
+ if (negative < 0) {
+ if (productLow <= -(_MIN_INT)) {
+ RETURN ( __MKSMALLINT(-((INT)productLow)) );
+ }
+ } else {
+ if (productLow <= _MAX_INT) {
+ RETURN ( __MKSMALLINT(productLow) );
+ }
+ }
+ }
+#endif /* ! USE_LONGLONG */
+
+#ifdef alpha64
+ RETURN (__MKLARGEINT128(negative, productLow, productHi));
+#else
+ RETURN (__MKLARGEINT64(negative, productLow, productHi));
#endif
-
- {
-# ifdef alpha64
- RETURN (__MKLARGEINT128(negative, productLow, productHi));
-# else
- RETURN (__MKLARGEINT64(negative, productLow, productHi));
-# endif
- }
} else if (__isFloatLike(aNumber)) {
- OBJ newFloat;
- double val = (double)__intVal(self) * __floatVal(aNumber);
-
- __qMKFLOAT(newFloat, val);
- RETURN ( newFloat );
+ OBJ newFloat;
+ double val = (double)__intVal(self) * __floatVal(aNumber);
+
+ __qMKFLOAT(newFloat, val);
+ RETURN ( newFloat );
} else if (__isShortFloat(aNumber)) {
- OBJ newFloat;
- float val = (float)__intVal(self) * __shortFloatVal(aNumber);
-
- __qMKSFLOAT(newFloat, val);
- RETURN ( newFloat );
+ OBJ newFloat;
+ float val = (float)__intVal(self) * __shortFloatVal(aNumber);
+
+ __qMKSFLOAT(newFloat, val);
+ RETURN ( newFloat );
}
%}.
^ aNumber productFromInteger:self
@@ -372,28 +380,28 @@
if (__isSmallInteger(aNumber)) {
#ifdef _ADD_IO_IO
- RETURN ( _ADD_IO_IO(self, aNumber) );
+ RETURN ( _ADD_IO_IO(self, aNumber) );
#else
- REGISTER INT sum;
-
- sum = __intVal(self) + __intVal(aNumber);
- if (__ISVALIDINTEGER(sum)) {
- RETURN ( __MKSMALLINT(sum) );
- }
- RETURN ( __MKLARGEINT(sum) );
+ REGISTER INT sum;
+
+ sum = __intVal(self) + __intVal(aNumber);
+ if (__ISVALIDINTEGER(sum)) {
+ RETURN ( __MKSMALLINT(sum) );
+ }
+ RETURN ( __MKLARGEINT(sum) );
#endif
} else if (__isFloatLike(aNumber)) {
- OBJ newFloat;
- double val = (double)__intVal(self) + __floatVal(aNumber);
-
- __qMKFLOAT(newFloat, val);
- RETURN ( newFloat );
+ OBJ newFloat;
+ double val = (double)__intVal(self) + __floatVal(aNumber);
+
+ __qMKFLOAT(newFloat, val);
+ RETURN ( newFloat );
} else if (__isShortFloat(aNumber)) {
- OBJ newFloat;
- float val = (float)__intVal(self) + __shortFloatVal(aNumber);
-
- __qMKSFLOAT(newFloat, val);
- RETURN ( newFloat );
+ OBJ newFloat;
+ float val = (float)__intVal(self) + __shortFloatVal(aNumber);
+
+ __qMKSFLOAT(newFloat, val);
+ RETURN ( newFloat );
}
%}.
^ aNumber sumFromInteger:self
@@ -406,28 +414,28 @@
if (__isSmallInteger(aNumber)) {
#ifdef _SUB_IO_IO
- RETURN ( _SUB_IO_IO(self, aNumber) );
+ RETURN ( _SUB_IO_IO(self, aNumber) );
#else
- REGISTER INT diff;
-
- diff = __intVal(self) - __intVal(aNumber);
- if (__ISVALIDINTEGER(diff)) {
- RETURN ( __MKSMALLINT(diff) );
- }
- RETURN ( __MKLARGEINT(diff) );
+ REGISTER INT diff;
+
+ diff = __intVal(self) - __intVal(aNumber);
+ if (__ISVALIDINTEGER(diff)) {
+ RETURN ( __MKSMALLINT(diff) );
+ }
+ RETURN ( __MKLARGEINT(diff) );
#endif
} else if (__isFloatLike(aNumber)) {
- OBJ newFloat;
- double val = (double)__intVal(self) - __floatVal(aNumber);
-
- __qMKFLOAT(newFloat, val);
- RETURN ( newFloat );
+ OBJ newFloat;
+ double val = (double)__intVal(self) - __floatVal(aNumber);
+
+ __qMKFLOAT(newFloat, val);
+ RETURN ( newFloat );
} else if (__isShortFloat(aNumber)) {
- OBJ newFloat;
- float val = (float)__intVal(self) - __shortFloatVal(aNumber);
-
- __qMKSFLOAT(newFloat, val);
- RETURN ( newFloat );
+ OBJ newFloat;
+ float val = (float)__intVal(self) - __shortFloatVal(aNumber);
+
+ __qMKSFLOAT(newFloat, val);
+ RETURN ( newFloat );
}
%}.
^ aNumber differenceFromInteger:self
@@ -442,44 +450,44 @@
double dval;
if (__isSmallInteger(aNumber)) {
- val = __intVal(aNumber);
- if (val != 0) {
- me = __intVal(self);
- t = me / val;
+ val = __intVal(aNumber);
+ if (val != 0) {
+ me = __intVal(self);
+ t = me / val;
#ifdef GOOD_OPTIMIZER
- if (me % val == 0) {
+ if (me % val == 0) {
#else
- /* this is stupid - all I want is to look for a remainder ...
- but most compilers are too stupid and generate an extra modulus
- 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 modulo
- on most machines. Hint to GNU people :-)
- */
- if ((t * val) == me) {
+ /* this is stupid - all I want is to look for a remainder ...
+ but most compilers are too stupid and generate an extra modulus
+ 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 modulo
+ on most machines. Hint to GNU people :-)
+ */
+ if ((t * val) == me) {
#endif
- RETURN ( __MKSMALLINT(t) );
- }
- }
+ 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);
- RETURN ( newFloat );
- }
- }
+ if (__isFloatLike(aNumber)) {
+ dval = __floatVal(aNumber);
+ if (dval != 0.0) {
+ OBJ newFloat;
+ double val = (double)__intVal(self) / dval;
+
+ __qMKFLOAT(newFloat, val);
+ RETURN ( newFloat );
+ }
+ }
}
%}.
aNumber isInteger ifTrue:[
- aNumber == 0 ifTrue:[
- ^ DivisionByZeroSignal raise.
- ].
- ^ Fraction numerator:self denominator:aNumber
+ aNumber == 0 ifTrue:[
+ ^ DivisionByZeroSignal raise.
+ ].
+ ^ Fraction numerator:self denominator:aNumber
].
^ aNumber quotientFromInteger:self
@@ -508,59 +516,59 @@
INT dividend, divisor, rslt;
if (__isSmallInteger(aNumber)) {
- divisor = __intVal(aNumber);
- if (divisor != 0) {
- dividend = __intVal(self);
- rslt = dividend / divisor;
- /*
- * Optimized to speed up positive result
- */
- if (rslt <= 0) {
- if (rslt == 0) {
- if (dividend * divisor < 0) {
- /*
- * result (negative) has been truncated toward 0.
- * Return -1, because we truncate toward negative inf.
- */
- rslt = -1;
- }
- } else {
- /*
- * If result (negative) has been truncated toward 0,
- * subtract 1, beacuse we truncate toward negative inf.
- */
- if (divisor > 0) {
- if (rslt * divisor > dividend) {
- rslt--;
- }
- } else {
- if (rslt * divisor < dividend) {
- rslt--;
- }
- }
- }
- }
- RETURN ( __MKSMALLINT(rslt) );
- }
+ divisor = __intVal(aNumber);
+ if (divisor != 0) {
+ dividend = __intVal(self);
+ rslt = dividend / divisor;
+ /*
+ * Optimized to speed up positive result
+ */
+ if (rslt <= 0) {
+ if (rslt == 0) {
+ if (dividend * divisor < 0) {
+ /*
+ * result (negative) has been truncated toward 0.
+ * Return -1, because we truncate toward negative inf.
+ */
+ rslt = -1;
+ }
+ } else {
+ /*
+ * If result (negative) has been truncated toward 0,
+ * subtract 1, beacuse we truncate toward negative inf.
+ */
+ if (divisor > 0) {
+ if (rslt * divisor > dividend) {
+ rslt--;
+ }
+ } else {
+ if (rslt * divisor < dividend) {
+ rslt--;
+ }
+ }
+ }
+ }
+ RETURN ( __MKSMALLINT(rslt) );
+ }
} 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 ));
- }
- }
- }
+ 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.
+ ^ DivisionByZeroSignal raise.
].
^ self retry:#// coercing:aNumber
@@ -594,32 +602,32 @@
INT dividend, divisor, rem;
if (__isSmallInteger(aNumber)
- && (divisor = __intVal(aNumber)) != 0) {
- /*
- * Note that the sign of something modulo a negative number is undefined
- * in C!
- */
- dividend = __intVal(self);
- rem = dividend % divisor;
- if (rem) {
- if ((rem < 0) != (divisor < 0)) {
- /* sign of remainder is different from sign of divisor */
- rem = -rem;
- }
- if ((dividend < 0) != (divisor < 0)) {
- /* different signs, so division would have returned a
- * negative number.
- * C rounds toward zero, this code will simulate
- * rounding towards negative infinity.
- */
- rem = divisor - rem;
- }
- }
- RETURN ( __MKSMALLINT(rem) );
+ && (divisor = __intVal(aNumber)) != 0) {
+ /*
+ * Note that the sign of something modulo a negative number is undefined
+ * in C!
+ */
+ dividend = __intVal(self);
+ rem = dividend % divisor;
+ if (rem) {
+ if ((rem < 0) != (divisor < 0)) {
+ /* sign of remainder is different from sign of divisor */
+ rem = -rem;
+ }
+ if ((dividend < 0) != (divisor < 0)) {
+ /* different signs, so division would have returned a
+ * negative number.
+ * C rounds toward zero, this code will simulate
+ * rounding towards negative infinity.
+ */
+ rem = divisor - rem;
+ }
+ }
+ RETURN ( __MKSMALLINT(rem) );
}
%}.
(aNumber = 0) ifTrue:[
- ^ DivisionByZeroSignal raise.
+ ^ DivisionByZeroSignal raise.
].
^ self retry:#\\ coercing:aNumber
@@ -780,7 +788,7 @@
/* anding the tags doesn't change it */
if (__isSmallInteger(anInteger)) {
- RETURN ( ((OBJ) (((INT)self & ~(INT)anInteger) | TAG_INT)) );
+ RETURN ( ((OBJ) (((INT)self & ~(INT)anInteger) | TAG_INT)) );
}
%}.
^ self retry:#bitClear: coercing:anInteger
@@ -826,21 +834,21 @@
INT bits, count;
if (__isSmallInteger(shiftCount)) {
- count = __intVal(shiftCount);
- if (count >= 32) {
- RETURN (__MKSMALLINT(0));
- }
-
- bits = __intVal(self);
- if (count > 0) {
- bits = bits << count;
- } else {
- bits = bits >> (-count);
- }
+ count = __intVal(shiftCount);
+ if (count >= 32) {
+ RETURN (__MKSMALLINT(0));
+ }
+
+ bits = __intVal(self);
+ if (count > 0) {
+ bits = bits << count;
+ } else {
+ bits = bits >> (-count);
+ }
#ifdef alpha64
- bits &= 0xFFFFFFFFL;
+ bits &= 0xFFFFFFFFL;
#endif
- RETURN (__MKINT(bits));
+ RETURN (__MKINT(bits));
}
%}.
^ self primitiveFailed
@@ -858,75 +866,75 @@
"return the value of the receiver shifted by shiftCount bits;
leftShift if shiftCount > 0; rightShift otherwise.
Notice: the result of bitShift: on negative receivers is not
- defined in the language standard (since the implementation
- is free to choose any internal representation for integers)"
+ defined in the language standard (since the implementation
+ is free to choose any internal representation for integers)"
%{ /* NOCONTEXT */
INT bits, count;
if (__isSmallInteger(shiftCount)) {
- bits = __intVal(self);
- if (bits == 0) {
- RETURN (self);
- }
-
- count = __intVal(shiftCount);
-
- if (count > 0) {
- /*
- * a left shift
- */
+ bits = __intVal(self);
+ if (bits == 0) {
+ RETURN (self);
+ }
+
+ count = __intVal(shiftCount);
+
+ if (count > 0) {
+ /*
+ * a left shift
+ */
#if defined(USE_LONGLONG)
- unsigned LONGLONG result;
-
- result = bits;
- if (count <= N_INT_BITS) {
- result <<= count;
- if (result <= _MAX_INT) {
- RETURN ( __MKSMALLINT(result) );
- }
- {
- RETURN (__MKLARGEINT64(1, (INT)(result >> 32), (INT)(result & 0xFFFFFFFF)));
- }
- }
+ unsigned LONGLONG result;
+
+ result = bits;
+ if (count <= N_INT_BITS) {
+ result <<= count;
+ if (result <= _MAX_INT) {
+ RETURN ( __MKSMALLINT(result) );
+ }
+ {
+ RETURN (__MKLARGEINT64(1, (INT)(result >> 32), (INT)(result & 0xFFFFFFFF)));
+ }
+ }
#else
- /*
- * check for overflow
- */
- if (count < (N_INT_BITS-1)) {
- if (! (bits >> (N_INT_BITS - 1 - count))) {
- RETURN ( __MKSMALLINT(bits << count) );
- }
- /*
- * so, there is an overflow ...
- * handle it as largeInteger
- */
- /* FALL THROUGH */
- }
+ /*
+ * check for overflow
+ */
+ if (count < (N_INT_BITS-1)) {
+ if (! (bits >> (N_INT_BITS - 1 - count))) {
+ RETURN ( __MKSMALLINT(bits << count) );
+ }
+ /*
+ * so, there is an overflow ...
+ * handle it as largeInteger
+ */
+ /* FALL THROUGH */
+ }
#endif
- } else {
- if (count == 0) {
- RETURN (self);
- }
-
- /*
- * right shifts cannot overflow
- *
- * some machines ignore shifts bigger than
- * the number of bits in an int ...
- */
- count = -count;
- if (count > (N_INT_BITS-1)) {
- RETURN (__MKSMALLINT(0));
- }
-
- RETURN ( __MKSMALLINT(bits >> count) );
- }
+ } else {
+ if (count == 0) {
+ RETURN (self);
+ }
+
+ /*
+ * right shifts cannot overflow
+ *
+ * some machines ignore shifts bigger than
+ * the number of bits in an int ...
+ */
+ count = -count;
+ if (count > (N_INT_BITS-1)) {
+ RETURN (__MKSMALLINT(0));
+ }
+
+ RETURN ( __MKSMALLINT(bits >> count) );
+ }
}
%}.
(shiftCount isMemberOf:SmallInteger) ifTrue:[
- ^ (LargeInteger value:self) bitShift:shiftCount
+ ^ (LargeInteger value:self) bitShift:shiftCount
].
^ self bitShift:(shiftCount coerce:1)
!
@@ -964,19 +972,19 @@
%{ /* NOCONTEXT */
if (__isSmallInteger(anInteger)) {
- int index = __intVal(anInteger);
+ int index = __intVal(anInteger);
#ifdef alpha64
- if (index <= 63)
+ if (index <= 63)
#else
- if (index <= 30)
+ if (index <= 30)
#endif
- {
- INT mask = __MASKSMALLINT(1 << (index-1));
-
- RETURN ( ((OBJ) ((INT)self & ~(INT)mask)) );
- }
- RETURN (self);
+ {
+ INT mask = __MASKSMALLINT(1 << (index-1));
+
+ RETURN ( ((OBJ) ((INT)self & ~(INT)mask)) );
+ }
+ RETURN (self);
}
%}.
^ self retry:#clearBit: coercing:anInteger
@@ -1044,25 +1052,25 @@
bits = __intVal(self);
if (bits == 0) {
- RETURN ( __MKSMALLINT(-1) );
+ RETURN ( __MKSMALLINT(-1) );
}
if ((bits & 0xFFFFFF) == 0) {
- mask = 0x1000000;
- index = 25;
+ mask = 0x1000000;
+ index = 25;
} else {
- if ((bits & 0xFFFF) == 0) {
- mask = 0x10000;
- index = 17;
- } else {
- if ((bits & 0xFF) == 0) {
- mask = 0x100;
- index = 9;
- } else {
- mask = 1;
- index = 1;
- }
- }
+ if ((bits & 0xFFFF) == 0) {
+ mask = 0x10000;
+ index = 17;
+ } else {
+ if ((bits & 0xFF) == 0) {
+ mask = 0x100;
+ index = 9;
+ } else {
+ mask = 1;
+ index = 1;
+ }
+ }
}
#ifdef alpha64
@@ -1070,11 +1078,11 @@
#else
while (index != 31) {
#endif
- if (bits & mask) {
- RETURN ( __MKSMALLINT(index) );
- }
- mask = mask << 1;
- index++;
+ if (bits & mask) {
+ RETURN ( __MKSMALLINT(index) );
+ }
+ mask = mask << 1;
+ index++;
}
RETURN ( __MKSMALLINT(-1) );
%}
@@ -1108,49 +1116,49 @@
INT idx;
if (__isSmallInteger(index)) {
- val = __intVal(self);
- if (val < 0)
- val = -val;
- switch (idx = __intVal(index)) {
- case 1:
- break;
- case 2:
- val = (val >> 8);
- break;
- case 3:
- val = (val >> 16);
- break;
- case 4:
- val = (val >> 24);
- break;
+ val = __intVal(self);
+ if (val < 0)
+ val = -val;
+ switch (idx = __intVal(index)) {
+ case 1:
+ break;
+ case 2:
+ val = (val >> 8);
+ break;
+ case 3:
+ val = (val >> 16);
+ break;
+ case 4:
+ val = (val >> 24);
+ break;
#ifdef alpha64
- case 5:
- val = (val >> 32);
- break;
- case 6:
- val = (val >> 40);
- break;
- case 7:
- val = (val >> 48);
- break;
- case 8:
- val = (val >> 56);
- break;
+ case 5:
+ val = (val >> 32);
+ break;
+ case 6:
+ val = (val >> 40);
+ break;
+ case 7:
+ val = (val >> 48);
+ break;
+ case 8:
+ val = (val >> 56);
+ break;
#endif
- default:
- if (idx < 1)
- goto bad; /* sorry */
- RETURN (__MKSMALLINT(0));
- }
- RETURN ( __MKSMALLINT( val & 0xFF) );
+ default:
+ if (idx < 1)
+ goto bad; /* sorry */
+ RETURN (__MKSMALLINT(0));
+ }
+ RETURN ( __MKSMALLINT( val & 0xFF) );
}
bad: ;
%}.
index > 0 ifFalse:[
- "
- index less than 1 - not allowed
- "
- ^ self primitiveFailed
+ "
+ index less than 1 - not allowed
+ "
+ ^ self primitiveFailed
].
^ 0
@@ -1174,50 +1182,50 @@
INT idx;
if (__isSmallInteger(index)) {
- val = __intVal(self);
- switch (idx = __intVal(index)) {
- case 1:
- break;
- case 2:
- val = (val >> 8);
- break;
- case 3:
- val = (val >> 16);
- break;
- case 4:
- val = (val >> 24);
- break;
+ val = __intVal(self);
+ switch (idx = __intVal(index)) {
+ case 1:
+ break;
+ case 2:
+ val = (val >> 8);
+ break;
+ case 3:
+ val = (val >> 16);
+ break;
+ case 4:
+ val = (val >> 24);
+ break;
#ifdef alpha64
- case 5:
- val = (val >> 32);
- break;
- case 6:
- val = (val >> 40);
- break;
- case 7:
- val = (val >> 48);
- break;
- case 8:
- val = (val >> 56);
- break;
+ case 5:
+ val = (val >> 32);
+ break;
+ case 6:
+ val = (val >> 40);
+ break;
+ case 7:
+ val = (val >> 48);
+ break;
+ case 8:
+ val = (val >> 56);
+ break;
#endif
- default:
- if (idx < 1)
- goto bad; /* sorry */
- if (val < 0) {
- RETURN (__MKSMALLINT(0xFF));
- }
- RETURN (__MKSMALLINT(0));
- }
- RETURN ( __MKSMALLINT( val & 0xFF) );
+ default:
+ if (idx < 1)
+ goto bad; /* sorry */
+ if (val < 0) {
+ RETURN (__MKSMALLINT(0xFF));
+ }
+ RETURN (__MKSMALLINT(0));
+ }
+ RETURN ( __MKSMALLINT( val & 0xFF) );
}
bad: ;
%}.
index > 0 ifFalse:[
- "
- index less than 1 - not allowed
- "
- ^ self primitiveFailed
+ "
+ index less than 1 - not allowed
+ "
+ ^ self primitiveFailed
].
^ 0
@@ -1239,38 +1247,38 @@
INT val = __intVal(self);
if (val < 0) {
- val = -val;
+ val = -val;
}
#ifdef alpha64
if (val & 0xFFFFFFFF00000000L) {
- if (val & 0xFFFF000000000000L) {
- if (val & 0xFF00000000000000L) {
- RETURN ( __MKSMALLINT(8));
- } else {
- RETURN ( __MKSMALLINT(7));
- }
- } else {
- if (val & 0x0000FF0000000000L) {
- RETURN ( __MKSMALLINT(6));
- } else {
- RETURN ( __MKSMALLINT(5));
- }
- }
+ if (val & 0xFFFF000000000000L) {
+ if (val & 0xFF00000000000000L) {
+ RETURN ( __MKSMALLINT(8));
+ } else {
+ RETURN ( __MKSMALLINT(7));
+ }
+ } else {
+ if (val & 0x0000FF0000000000L) {
+ RETURN ( __MKSMALLINT(6));
+ } else {
+ RETURN ( __MKSMALLINT(5));
+ }
+ }
}
#endif
if (val & 0xFFFF0000) {
- if (val & 0xFF000000) {
- RETURN ( __MKSMALLINT(4));
- } else {
- RETURN ( __MKSMALLINT(3));
- }
+ if (val & 0xFF000000) {
+ RETURN ( __MKSMALLINT(4));
+ } else {
+ RETURN ( __MKSMALLINT(3));
+ }
} else {
- if (val & 0x0000FF00) {
- RETURN ( __MKSMALLINT(2));
- } else {
- RETURN ( __MKSMALLINT(1));
- }
+ if (val & 0x0000FF00) {
+ RETURN ( __MKSMALLINT(2));
+ } else {
+ RETURN ( __MKSMALLINT(1));
+ }
}
%}.
@@ -1381,9 +1389,9 @@
INT i = __intVal(self);
if (i & 0x80) {
- i = i | ~0xFFL;
+ i = i | ~0xFFL;
} else {
- i = i & 0x7F;
+ i = i & 0x7F;
}
RETURN (__MKSMALLINT(i));
@@ -1403,9 +1411,9 @@
INT i = __intVal(self);
if (i & 0x8000) {
- i = i | ~0xFFFFL;
+ i = i | ~0xFFFFL;
} else {
- i = i & 0x7FFF;
+ i = i & 0x7FFF;
}
RETURN (__MKSMALLINT(i));
@@ -1674,9 +1682,9 @@
* specially tuned version for compiled blocks,
* (the most common case)
*/
- if (((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil)
+ if (((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil)
#ifdef PARANOIA
- && (! ((INT)(__BlockInstPtr(aBlock)->b_flags) & __MASKSMALLINT(F_DYNAMIC)))
+ && (! ((INT)(__BlockInstPtr(aBlock)->b_flags) & __MASKSMALLINT(F_DYNAMIC)))
#endif
) {
@@ -1791,10 +1799,10 @@
*/
/* stay here, while no interrupts are pending ... */
do {
- (*codeVal)(BLOCK_ARG);
+ (*codeVal)(BLOCK_ARG);
if (InterruptPending != nil) goto outerLoop;
} while (--tmp);
- RETURN (self);
+ RETURN (self);
} else {
if (InterruptPending != nil) __interruptL(@line);
@@ -1862,9 +1870,9 @@
* specially tuned version for static compiled blocks, called with
* home on the stack (the most common case)
*/
- if (((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil)
+ if (((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil)
#ifdef PARANOIA
- && (! ((INT)(__BlockInstPtr(aBlock)->b_flags) & __MASKSMALLINT(F_DYNAMIC)))
+ && (! ((INT)(__BlockInstPtr(aBlock)->b_flags) & __MASKSMALLINT(F_DYNAMIC)))
#endif
) {
@@ -1903,7 +1911,7 @@
tmp++;
}
} else {
- while (tmp <= final) {
+ while (tmp <= final) {
if (InterruptPending != nil) __interruptL(@line);
(*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp));
tmp += step;
@@ -2074,7 +2082,7 @@
*/
REGISTER OBJFUNC codeVal;
- if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
+ if ((codeVal = __BlockInstPtr(aBlock)->b_code) != (OBJFUNC)nil) {
#ifdef NEW_BLOCK_CALL
@@ -2184,7 +2192,7 @@
tmp += 8;
# endif
}
- while (tmp <= final) {
+ while (tmp <= final) {
if (InterruptPending != nil) goto interruptedX;
continueX:
# if TAG_INT==1
@@ -2194,8 +2202,8 @@
(*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp));
tmp++;
# endif
- }
- RETURN (self);
+ }
+ RETURN (self);
if (0) {
/*
@@ -2274,12 +2282,12 @@
* directly call it without going through Block>>value
*/
- /* stay here, while no interrupts are pending ... */
- do {
- (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp));
- if (InterruptPending != nil) goto outerLoop;
+ /* stay here, while no interrupts are pending ... */
+ do {
+ (*codeVal)(BLOCK_ARG, __MKSMALLINT(tmp));
+ if (InterruptPending != nil) goto outerLoop;
tmp++;
- } while (tmp <= final);
+ } while (tmp <= final);
RETURN (self);
} else {
if (InterruptPending != nil) __interruptL(@line);
@@ -2355,13 +2363,13 @@
INT val, div, mod, mySelf;
if (__isSmallInteger(aNumber) &&
- (val = __intVal(aNumber)) > 0) {
- mySelf = __intVal(self);
- div = mySelf / val;
- mod = mySelf % val;
-
- RETURN (__ARRAY_WITH2( __MKSMALLINT(div),
- __MKSMALLINT(mod)));
+ (val = __intVal(aNumber)) > 0) {
+ mySelf = __intVal(self);
+ div = mySelf / val;
+ mod = mySelf % val;
+
+ RETURN (__ARRAY_WITH2( __MKSMALLINT(div),
+ __MKSMALLINT(mod)));
}
%}.
^ super divMod:aNumber
@@ -2382,30 +2390,30 @@
%{ /* NOCONTEXT */
if (__isSmallInteger(anInteger)) {
- INT orgArg, ttt, selfInt, orgSelfInt, temp;
-
- ttt = orgArg = __intVal(anInteger);
- if (ttt) {
- selfInt = orgSelfInt = __intVal(self);
- while (ttt != 0) {
- temp = selfInt % ttt;
- selfInt = ttt;
- ttt = temp;
- }
- /*
- * since its not defined in C, what the sign of
- * 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;
- } else {
- /* result should be positive */
- if (orgSelfInt < 0) selfInt = -selfInt;
- }
- RETURN ( __MKSMALLINT(selfInt) );
- }
+ INT orgArg, ttt, selfInt, orgSelfInt, temp;
+
+ ttt = orgArg = __intVal(anInteger);
+ if (ttt) {
+ selfInt = orgSelfInt = __intVal(self);
+ while (ttt != 0) {
+ temp = selfInt % ttt;
+ selfInt = ttt;
+ ttt = temp;
+ }
+ /*
+ * since its not defined in C, what the sign of
+ * 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;
+ } else {
+ /* result should be positive */
+ if (orgSelfInt < 0) selfInt = -selfInt;
+ }
+ RETURN ( __MKSMALLINT(selfInt) );
+ }
}
%}
.
@@ -2455,15 +2463,15 @@
%{ /* NOCONTEXT */
if (__isSmallInteger(aNumber)) {
- INT sum;
-
- sum = __intVal(self) + __intVal(aNumber);
+ INT sum;
+
+ 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
@@ -2480,15 +2488,15 @@
%{ /* NOCONTEXT */
if (__isSmallInteger(aNumber)) {
- INT diff;
-
- diff = __intVal(self) - __intVal(aNumber);
+ INT diff;
+
+ 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
@@ -2505,15 +2513,15 @@
%{ /* NOCONTEXT */
if (__isSmallInteger(aNumber)) {
- INT prod;
-
- prod = __intVal(self) * __intVal(aNumber);
+ INT prod;
+
+ 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
@@ -2564,26 +2572,26 @@
#else
myValue = __intVal(self);
if (myValue == 0) {
- RETURN (__MKSTRING_L("0", 1));
+ RETURN (__MKSTRING_L("0", 1));
}
if (myValue < 0) {
- negative = 1;
- myValue = -myValue;
+ negative = 1;
+ myValue = -myValue;
}
cp = buffer + sizeof(buffer) - 1;
*cp-- = '\0';
while (myValue != 0) {
- *cp = '0' + (myValue % 10);
- myValue = myValue / 10;
- cp--;
+ *cp = '0' + (myValue % 10);
+ myValue = myValue / 10;
+ cp--;
}
if (negative) {
- *cp-- = '-';
+ *cp-- = '-';
}
newString = __MKSTRING_L(cp+1, (buffer + sizeof(buffer) - 2 - cp));
#endif
if (newString != nil) {
- RETURN (newString);
+ RETURN (newString);
}
%}.
"/ only arrive here,
@@ -2615,79 +2623,79 @@
__base = __intVal(base);
#ifdef SLOW_CODE
- switch (__base) {
- case 10:
+ switch (__base) {
+ case 10:
#ifdef alpha64
- format = "%ld";
+ format = "%ld";
#else
- format = "%d";
+ format = "%d";
#endif
- break;
- case 16:
+ break;
+ case 16:
#ifdef alpha64
- format = "%lx";
+ format = "%lx";
#else
- format = "%x";
+ format = "%x";
#endif
- break;
- case 8:
+ break;
+ case 8:
#ifdef alpha64
- format = "%lo";
+ format = "%lo";
#else
- format = "%o";
+ format = "%o";
#endif
- break;
- }
-
- if (format) {
- /*
- * actually only needed on sparc: since thisContext is
- * in a global register, which gets destroyed by printf,
- * manually save it here - very stupid ...
- */
- __BEGIN_PROTECT_REGISTERS__
-
- sprintf(buffer, format, __intVal(self));
-
- __END_PROTECT_REGISTERS__
-
- newString = __MKSTRING(buffer COMMA_SND);
- if (newString != nil) {
- RETURN (newString);
- }
- }
+ break;
+ }
+
+ if (format) {
+ /*
+ * actually only needed on sparc: since thisContext is
+ * in a global register, which gets destroyed by printf,
+ * manually save it here - very stupid ...
+ */
+ __BEGIN_PROTECT_REGISTERS__
+
+ sprintf(buffer, format, __intVal(self));
+
+ __END_PROTECT_REGISTERS__
+
+ newString = __MKSTRING(buffer COMMA_SND);
+ if (newString != nil) {
+ RETURN (newString);
+ }
+ }
#else
- if ((__base <= 36) && (__base > 1)) {
- myValue = __intVal(self);
- if (myValue == 0) {
- RETURN (__MKSTRING_L("0", 1));
- }
- if (myValue < 0) {
- negative = 1;
- myValue = -myValue;
- }
- cp = buffer + sizeof(buffer) - 1;
- *cp-- = '\0';
- while (myValue != 0) {
- int digit;
-
- digit = myValue % __base;
- if (digit <= 9) {
- *cp = '0' + digit;
- } else {
- *cp = 'A' + digit - 10;
- }
- myValue = myValue / __base;
- cp--;
- }
- if (negative) {
- *cp-- = '-';
- }
- newString = __MKSTRING_L(cp+1, (buffer + sizeof(buffer) - 2 - cp));
- if (newString != nil) {
- RETURN (newString);
- }
- }
+ if ((__base <= 36) && (__base > 1)) {
+ myValue = __intVal(self);
+ if (myValue == 0) {
+ RETURN (__MKSTRING_L("0", 1));
+ }
+ if (myValue < 0) {
+ negative = 1;
+ myValue = -myValue;
+ }
+ cp = buffer + sizeof(buffer) - 1;
+ *cp-- = '\0';
+ while (myValue != 0) {
+ int digit;
+
+ digit = myValue % __base;
+ if (digit <= 9) {
+ *cp = '0' + digit;
+ } else {
+ *cp = 'A' + digit - 10;
+ }
+ myValue = myValue / __base;
+ cp--;
+ }
+ if (negative) {
+ *cp-- = '-';
+ }
+ newString = __MKSTRING_L(cp+1, (buffer + sizeof(buffer) - 2 - cp));
+ if (newString != nil) {
+ RETURN (newString);
+ }
+ }
#endif
}
%}.
@@ -2904,5 +2912,5 @@
!SmallInteger class methodsFor:'documentation'!
version
- ^ '$Header: /cvs/stx/stx/libbasic/SmallInteger.st,v 1.109 1999-03-19 21:39:37 cg Exp $'
+ ^ '$Header: /cvs/stx/stx/libbasic/SmallInteger.st,v 1.110 1999-05-10 13:45:48 cg Exp $'
! !