hg/stx-libbasic: comparison SmallInteger.st

equal deleted inserted replaced

-:0604a0bec563
+:eae082846c10
 #else
 double val = __intVal(self);
 extern double sqrt();
 if (val >= 0.0) {
-RETURN (__MKFLOAT(sqrt(val)));
+	RETURN (__MKFLOAT(sqrt(val)));
 }
 #endif
 %}.
 ^ self class
-raise:#imaginaryResultSignal
+	raise:#imaginaryResultSignal
-receiver:self
+	receiver:self
-selector:#sqrt
+	selector:#sqrt
-arguments:#()
+	arguments:#()
-errorString:'bad (negative) receiver in sqrt'
+	errorString:'bad (negative) receiver in sqrt'
 "
-2 sqrt
+	2 sqrt
--2 sqrt
+	-2 sqrt
 "
 "Created: / 08-05-2017 / 14:57:07 / stefan"
 ! !
 bitDeinterleave:n
 "extract count integers from an n-way Morton number as a vector;
 This is the inverse operation from bitInterleave: - see comment there.
 i.e. if count is 3,
 and the receiver's bits are
-cN bN aN ... c2 b2 a2 c1 b1 a1 c0 b0 a0
+	cN bN aN ... c2 b2 a2 c1 b1 a1 c0 b0 a0
 then the result will be a vector containing the numbers a,b,c with bits:
-aN ... a2 a1 a0
+	aN ... a2 a1 a0
-bN ... b2 b1 b0
+	bN ... b2 b1 b0
-cN ... c2 c1 c0."
+	cN ... c2 c1 c0."
 %{
 #if __POINTER_SIZE__ == 8
 # define M5555555555555555 0x5555555555555555
 # define M00ff0000ff0000ff 0xff0000ff
 # define Mffff00000000ffff 0x0000ffff
 #endif
 unsigned INT bits = __intVal(self);
 unsigned INT a, b;
 if (n == __MKSMALLINT(2)) {
 #       define morton2(x,dst) \
-{ \
+	    { \
-unsigned INT t; \
+		unsigned INT t; \
-t = (x) & M5555555555555555; \
+		t = (x) & M5555555555555555; \
-t = (t | (t >> 1))  & M3333333333333333; \
+		t = (t | (t >> 1))  & M3333333333333333; \
-t = (t | (t >> 2))  & M0f0f0f0f0f0f0f0f; \
+		t = (t | (t >> 2))  & M0f0f0f0f0f0f0f0f; \
-t = (t | (t >> 4))  & M00ff00ff00ff00ff; \
+		t = (t | (t >> 4))  & M00ff00ff00ff00ff; \
-t = (t | (t >> 8))  & M0000ffff0000ffff; \
+		t = (t | (t >> 8))  & M0000ffff0000ffff; \
-t = (t | (t >> 16)) & M00000000ffffffff; \
+		t = (t | (t >> 16)) & M00000000ffffffff; \
-dst = t; \
+		dst = t; \
-}
+	    }
-morton2(bits, a);
+	morton2(bits, a);
-morton2(bits>>1, b);
+	morton2(bits>>1, b);
-RETURN (__ARRAY_WITH2(__MKSMALLINT(a), __MKSMALLINT(b)));
+	RETURN (__ARRAY_WITH2(__MKSMALLINT(a), __MKSMALLINT(b)));
 }
 if (n == __MKSMALLINT(3)) {
-unsigned INT c;
+	unsigned INT c;
 #       define morton3(x,dst) \
-{ \
+	    { \
-unsigned INT t; \
+		unsigned INT t; \
-t = (x) & M9249249249249249; \
+		t = (x) & M9249249249249249; \
-t = (t | (t >> 2))  & M30c30c30c30c30c3; \
+		t = (t | (t >> 2))  & M30c30c30c30c30c3; \
-t = (t | (t >> 4))  & Mf00f00f00f00f00f; \
+		t = (t | (t >> 4))  & Mf00f00f00f00f00f; \
-t = (t | (t >> 8))  & M00ff0000ff0000ff; \
+		t = (t | (t >> 8))  & M00ff0000ff0000ff; \
-t = (t | (t >> 16)) & Mffff00000000ffff; \
+		t = (t | (t >> 16)) & Mffff00000000ffff; \
-t = (t | (t >> 32)) & M00000000ffffffff; \
+		t = (t | (t >> 32)) & M00000000ffffffff; \
-dst = t; \
+		dst = t; \
-}
+	    }
-morton3(bits, a);
+	morton3(bits, a);
-morton3(bits>>1, b);
+	morton3(bits>>1, b);
-morton3(bits>>2, c);
+	morton3(bits>>2, c);
-RETURN (__ARRAY_WITH3(__MKSMALLINT(a), __MKSMALLINT(b), __MKSMALLINT(c)));
+	RETURN (__ARRAY_WITH3(__MKSMALLINT(a), __MKSMALLINT(b), __MKSMALLINT(c)));
 }
 done: ;
 %}.
 ^ super bitDeinterleave:n
 (197 bitInterleaveWith:144 and:62) bitDeinterleave:3 -> #(197 144 62)
 |a b|
 (0 to:31) do:[:bitA |
-a := 1 << bitA.
+	 a := 1 << bitA.
-(0 to:31) do:[:bitB |
+	 (0 to:31) do:[:bitB |
-b := 1 << bitB.
+	    b := 1 << bitB.
-self assert:( (a bitInterleaveWith:b) bitDeinterleave:2 ) = {a . b }
+	    self assert:( (a bitInterleaveWith:b) bitDeinterleave:2 ) = {a . b }
-].
+	 ].
 ].
 |a b c|
 (0 to:31) do:[:bitA |
-a := 1 << bitA.
+	 a := 1 << bitA.
-(0 to:31) do:[:bitB |
+	 (0 to:31) do:[:bitB |
-b := 1 << bitB.
+	     b := 1 << bitB.
-(0 to:31) do:[:bitC |
+	     (0 to:31) do:[:bitC |
-c := 1 << bitC.
+		 c := 1 << bitC.
-self assert:( (a bitInterleaveWith:b and:c) bitDeinterleave:3 ) = {a . b . c}
+		 self assert:( (a bitInterleaveWith:b and:c) bitDeinterleave:3 ) = {a . b . c}
-].
+	     ].
-].
+	 ].
 ].
 "
 "Created: / 28-08-2017 / 18:32:48 / cg"
 !
 bitInterleaveWith:anInteger
 "generate a Morton number (-> https://en.wikipedia.org/wiki/Morton_number_(number_theory))
 by interleaving bits of the receiver
 (at even positions if counting from 1) with bits of the argument (at odd bit positions).
 Thus, if the bits of the receiver are
-aN ... a2 a1 a0
+	aN ... a2 a1 a0
 and those of the argument are:
-bN ... b2 b1 b0
+	bN ... b2 b1 b0
 the result is
-bN aN ... b2 a2 b1 a1 b0 a0.
+	bN aN ... b2 a2 b1 a1 b0 a0.
 Morton numbers are great to linearize 2D coordinates
 eg. to sort 2D points by distances"
 %{
 #if __POINTER_SIZE__ == 8
 # define __SLOW_MULTIPLY__
 # ifndef __SLOW_MULTIPLY__
 // the following is only faster, if multiplication is faster than a memory fetch
 if (__isSmallInteger(anInteger)) {
-INT _a = __intVal(self);
+	INT _a = __intVal(self);
-INT _b = __intVal(anInteger);
+	INT _b = __intVal(anInteger);
-if ( (((unsigned)_a)<=0xFFFFFFFF) && (((unsigned)_b)<=0xFFFFFFFF) )  {
+	if ( (((unsigned)_a)<=0xFFFFFFFF) && (((unsigned)_b)<=0xFFFFFFFF) )  {
-int shift = 0;
+	    int shift = 0;
-unsigned INT val = 0;
+	    unsigned INT val = 0;
-// Interleave bits of (8-bit) a and b, so that all of the
+	    // Interleave bits of (8-bit) a and b, so that all of the
-// bits of a are in the even positions and b in the odd;
+	    // bits of a are in the even positions and b in the odd;
-// resulting in a 16-bit Morton Number.
+	    // resulting in a 16-bit Morton Number.
 #           define interleaveBytes(a,b) \
-((((a * 0x0101010101010101ULL & 0x8040201008040201ULL) * 0x0102040810204081ULL >> 49) & 0x5555) \
+		((((a * 0x0101010101010101ULL & 0x8040201008040201ULL) * 0x0102040810204081ULL >> 49) & 0x5555) \
-| (((b * 0x0101010101010101ULL & 0x8040201008040201ULL) * 0x0102040810204081ULL >> 48) & 0xAAAA))
+		| (((b * 0x0101010101010101ULL & 0x8040201008040201ULL) * 0x0102040810204081ULL >> 48) & 0xAAAA))
-while (_a | _b) {
+	    while (_a | _b) {
-val |= (interleaveBytes((_a & 0xFF), (_b & 0xFF)) << shift);
+		val |= (interleaveBytes((_a & 0xFF), (_b & 0xFF)) << shift);
-_a = _a >> 8;
+		_a = _a >> 8;
-_b = _b >> 8;
+		_b = _b >> 8;
-shift += 16;
+		shift += 16;
-}
+	    }
-RETURN (__MKUINT(val) );
+	    RETURN (__MKUINT(val) );
-}
+	}
 }
 # else
 #  if __POINTER_SIZE__ == 8
 #   define HALF_INT_MAX     0xFFFFFFFFFFFFFFFF
 #   define M55555555        0x5555555555555555
 #   define M00FF00FF        0x00FF00FF
 #   define M0000FFFF        0
 #  endif
 if (__isSmallInteger(anInteger)) {
-INT _a = __intVal(self);
+	INT _a = __intVal(self);
-INT _b = __intVal(anInteger);
+	INT _b = __intVal(anInteger);
-if ( (((unsigned)_a)<=HALF_INT_MAX) && (((unsigned)_b)<=HALF_INT_MAX) )  {
+	if ( (((unsigned)_a)<=HALF_INT_MAX) && (((unsigned)_b)<=HALF_INT_MAX) )  {
-unsigned INT val;
+	    unsigned INT val;
-_a = (_a | (_a << 16)) & M0000FFFF;
+	    _a = (_a | (_a << 16)) & M0000FFFF;
-_a = (_a | (_a << 8))  & M00FF00FF;
+	    _a = (_a | (_a << 8))  & M00FF00FF;
-_a = (_a | (_a << 4))  & M0F0F0F0F;
+	    _a = (_a | (_a << 4))  & M0F0F0F0F;
-_a = (_a | (_a << 2))  & M33333333;
+	    _a = (_a | (_a << 2))  & M33333333;
-_a = (_a | (_a << 1))  & M55555555;
+	    _a = (_a | (_a << 1))  & M55555555;
-_b = (_b | (_b << 16)) & M0000FFFF;
+	    _b = (_b | (_b << 16)) & M0000FFFF;
-_b = (_b | (_b << 8))  & M00FF00FF;
+	    _b = (_b | (_b << 8))  & M00FF00FF;
-_b = (_b | (_b << 4))  & M0F0F0F0F;
+	    _b = (_b | (_b << 4))  & M0F0F0F0F;
-_b = (_b | (_b << 2))  & M33333333;
+	    _b = (_b | (_b << 2))  & M33333333;
-_b = (_b | (_b << 1))  & M55555555;
+	    _b = (_b | (_b << 1))  & M55555555;
-val = _a | (_b << 1);
+	    val = _a | (_b << 1);
-RETURN (__MKUINT(val) );
+	    RETURN (__MKUINT(val) );
-}
+	}
 }
 # endif
 #endif
 %}.
 ^ super bitInterleaveWith:anInteger
 (2r1100 bitInterleaveWith:2r1001) printStringRadix:2 -> '11 01 00 10'
 (2r11000101 bitInterleaveWith:2r10010000) printStringRadix:2'1101001000010001 -> '11 01 00 10 00 01 00 01'
 |a b|
 (0 to:31) do:[:bitA |
-a := 1 << bitA.
+	 a := 1 << bitA.
-(0 to:31) do:[:bitB |
+	 (0 to:31) do:[:bitB |
-b := 1 << bitB.
+	    b := 1 << bitB.
-self assert:( (a bitInterleaveWith:b) bitDeinterleave:2 ) = {a . b }
+	    self assert:( (a bitInterleaveWith:b) bitDeinterleave:2 ) = {a . b }
-].
+	 ].
 ].
 "
 "Created: / 28-08-2017 / 14:33:52 / cg"
 Returns 0 if no bit is set."
 %{  /* NOCONTEXT */
 #ifdef __SCHTEAM__
 {
-long bits = self.longValue();
+	long bits = self.longValue();
-int bitNr = 0;
+	int bitNr = 0;
-if (bits != 0) {
+	if (bits != 0) {
-if ((bits & 0xFFFFFFFF00000000L) != 0) {
+	    if ((bits & 0xFFFFFFFF00000000L) != 0) {
-bitNr += 32; bits >>= 32;
+		bitNr += 32; bits >>= 32;
-}
+	    }
-if ((bits & 0xFFFF0000L) != 0) {
+	    if ((bits & 0xFFFF0000L) != 0) {
-bitNr += 16; bits >>= 16;
+		bitNr += 16; bits >>= 16;
-}
+	    }
-if ((bits & 0xFF00) != 0) {
+	    if ((bits & 0xFF00) != 0) {
-bitNr += 8; bits >>= 8;
+		bitNr += 8; bits >>= 8;
-}
+	    }
-if ((bits & 0xF0) != 0) {
+	    if ((bits & 0xF0) != 0) {
-bitNr += 4; bits >>= 4;
+		bitNr += 4; bits >>= 4;
-}
+	    }
-if ((bits & 0xC) != 0) {
+	    if ((bits & 0xC) != 0) {
-bitNr += 2; bits >>= 2;
+		bitNr += 2; bits >>= 2;
-}
+	    }
-if ((bits & 0x2) != 0) {
+	    if ((bits & 0x2) != 0) {
-bitNr += 1; bits >>= 1;
+		bitNr += 1; bits >>= 1;
-}
+	    }
-bitNr += 1;
+	    bitNr += 1;
-}
+	}
-return context._RETURN( STInteger._new(bitNr) );
+	return context._RETURN( STInteger._new(bitNr) );
 }
 /* NOTREACHED */
 #else
 unsigned INT bits;
 int index;
 * this code only works for <=53 bit integers (i.e. only on 32bit machines)
 * we never use it - its only here as a hint.
 */
 #  if (POINTER_SIZE == 4) && defined( USE_IEE_FLOAT_BITS )
 union {
-double ff;
+	double ff;
-int ll[2];
+	int ll[2];
 } uu;
 int bNr;
 uu.ff=(double)((INT)(self));
 bNr = (uu.ll[1]>>20)-1023;
 #  else
 /*
 * general fallback; not super-fast,
 * but fast enough on all machines (better than a bit-masking loop, definitely).
 */
 index = 0;
 bits = __intVal(self);
 if (bits == 0) {
-RETURN ( __mkSmallInteger(0) );
+	RETURN ( __mkSmallInteger(0) );
 }
 #  if __POINTER_SIZE__ == 8
 if (bits & 0xFFFFFFFF00000000L) {
-index += 32; bits >>= 32;
+	index += 32; bits >>= 32;
 }
 #  endif
 if (bits & 0xFFFF0000L) {
-index += 16; bits >>= 16;
+	index += 16; bits >>= 16;
 }
 if (bits & 0xFF00) {
-index += 8; bits >>= 8;
+	index += 8; bits >>= 8;
 }
 if (bits & 0xF0) {
-index += 4; bits >>= 4;
+	index += 4; bits >>= 4;
 }
 if (bits & 0xC) {
-index += 2; bits >>= 2;
+	index += 2; bits >>= 2;
 }
 if (bits & 0x2) {
-index += 1; bits >>= 1;
+	index += 1; bits >>= 1;
 }
 #  endif /* not IEE float */
 # endif /* no BSR instruction */
 RETURN ( __mkSmallInteger(index+1) );
 2r100 highBit
 2r1000 highBit
 2r100000000000 highBit
 ((0 to:64) collect:[:s | 1 bitShift:s])
-collect:[:n | n highBit]
+	collect:[:n | n highBit]
 (((0 to:64) collect:[:s | 1 bitShift:s])
-collect:[:n | n highBit]) = (1 to:65)
+	collect:[:n | n highBit]) = (1 to:65)
 "
 "
 Time millisecondsToRun:[
-1000000 timesRepeat:[
+	1000000 timesRepeat:[
-2r1 highBit
+	    2r1 highBit
-]
+	]
 ]
 "
 "
 Time millisecondsToRun:[
-1000000 timesRepeat:[
+	1000000 timesRepeat:[
-2r1111 highBit
+	    2r1111 highBit
-]
+	]
 ]
 "
 "
 Time millisecondsToRun:[
-1000000 timesRepeat:[
+	1000000 timesRepeat:[
-2r11111111111111 highBit
+	    2r11111111111111 highBit
-]
+	]
 ]
 "
 "
 Time millisecondsToRun:[
-1000000 timesRepeat:[
+	1000000 timesRepeat:[
-2r11111111111111111111111111 highBit
+	    2r11111111111111111111111111 highBit
-]
+	]
 ]
 "
 "
 2r000100 highBit
 rightShift:shiftCount
 "return the value of the receiver shifted by shiftCount bits;
 right shift if shiftCount > 0; left shift  otherwise.
 Notice: the result of bitShift: 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).
-However, ST/X preserves the sign."
+	     However, ST/X preserves the sign."
 %{  /* NOCONTEXT */
 #ifdef __SCHTEAM__
 #else
 INT bits, count;
 if (__isSmallInteger(shiftCount)) {
-bits = __intVal(self);
+	bits = __intVal(self);
-if (bits == 0) {
+	if (bits == 0) {
-RETURN (self);
+	    RETURN (self);
-}
+	}
-count = __intVal(shiftCount);
+	count = __intVal(shiftCount);
-if (count < 0) {
+	if (count < 0) {
-/*
+	    /*
-* a left shift
+	     * a left shift
-*/
+	     */
-count = -count;
+	    count = -count;
 # if defined(USE_LONGLONG_FOR_SHIFT)
-if (count <= N_INT_BITS) {
+	    if (count <= N_INT_BITS) {
-unsigned LONGLONG result;
+		unsigned LONGLONG result;
-result = (unsigned LONGLONG)bits;
+		result = (unsigned LONGLONG)bits;
-result <<= count;
+		result <<= count;
-if (result <= _MAX_INT) {
+		if (result <= _MAX_INT) {
-RETURN ( __mkSmallInteger(result) );
+		    RETURN ( __mkSmallInteger(result) );
-}
+		}
-{
+		{
-RETURN (__MKLARGEINT64(1, (INT)(result >> 32), (INT)(result & 0xFFFFFFFF)));
+		    RETURN (__MKLARGEINT64(1, (INT)(result >> 32), (INT)(result & 0xFFFFFFFF)));
-}
+		}
-}
+	    }
 # else
-/*
+	    /*
-* check for overflow
+	     * check for overflow
-*/
+	     */
-if (count < (N_INT_BITS-1)) {
+	    if (count < (N_INT_BITS-1)) {
-if (! (bits >> (N_INT_BITS - 1 - count))) {
+		if (! (bits >> (N_INT_BITS - 1 - count))) {
-RETURN ( __mkSmallInteger(bits << count) );
+		    RETURN ( __mkSmallInteger(bits << count) );
-}
+		}
-/*
+		/*
-* so, there is an overflow ...
+		 * so, there is an overflow ...
-* handle it as largeInteger
+		 * handle it as largeInteger
-*/
+		 */
-/* FALL THROUGH */
+		/* FALL THROUGH */
-}
+	    }
 # endif
-} else {
+	} else {
-if (count == 0) {
+	    if (count == 0) {
-RETURN (self);
+		RETURN (self);
-}
+	    }
-/*
+	    /*
-* right shifts cannot overflow
+	     * right shifts cannot overflow
-*
+	     *
-* some machines ignore shifts bigger than
+	     * some machines ignore shifts bigger than
-* the number of bits in an int ...
+	     * the number of bits in an int ...
-*/
+	     */
-if (count > (N_INT_BITS-1)) {
+	    if (count > (N_INT_BITS-1)) {
-RETURN (__mkSmallInteger(0));
+		RETURN (__mkSmallInteger(0));
-}
+	    }
-RETURN ( __mkSmallInteger(bits >> count) );
+	    RETURN ( __mkSmallInteger(bits >> count) );
-}
+	}
 }
 #endif /* not __SCHTEAM__ */
 %}.
 (shiftCount isMemberOf:SmallInteger) ifTrue:[
-^ (LargeInteger value:self) rightShift:shiftCount
+	^ (LargeInteger value:self) rightShift:shiftCount
 ].
 ^ self rightShift:shiftCount asInteger   "/ is this a good idea ?
 "
-16 rightShift:2
+	16 rightShift:2
 -16 rightShift:2
-4 rightShift:-2
+	 4 rightShift:-2
--4 rightShift:-2
+	-4 rightShift:-2
 "
 "Modified: / 25-08-2017 / 12:30:42 / cg"
 ! !
 !SmallInteger methodsFor:'misc math'!
 bernoulli
 "returns the nth Bernoulli number.
 The series runs this:
-1, 1/2, 1/6, 0, -1/30, 0, 1/42, 0, -1/30, 0, 5/66, 0, -691/2730, etc
+	 1, 1/2, 1/6, 0, -1/30, 0, 1/42, 0, -1/30, 0, 5/66, 0, -691/2730, etc
 Uses a table of the first 20 even bernoulli numbers.
 So bernoulli(42) will fail for now.
 Used with taylor series for tan"
 |table p|
 table := #(
-(1 6)
+		(1 6)
-(-1 30)
+		(-1 30)
-(1 42)
+		(1 42)
-(-1 30)
+		(-1 30)
-(5 66)
+		(5 66)
-(-691 2730)
+		(-691 2730)
-(7 6)
+		(7 6)
-(-3617 510)
+		(-3617 510)
-(43867 798)
+		(43867 798)
-(-174611 330)
+		(-174611 330)
-(854513 138)
+		(854513 138)
-(-236364091 2730)
+		(-236364091 2730)
-(8553103 6)
+		(8553103 6)
-(-23749461029 870)
+		(-23749461029 870)
-(8615841276005 14322)
+		(8615841276005 14322)
-(-7709321041217 510)
+		(-7709321041217 510)
-(2577687858367 6)
+		(2577687858367 6)
-(-26315271553053477373 1919190)
+		(-26315271553053477373 1919190)
-(2929993913841559 6)
+		(2929993913841559 6)
-(-261082718496449122051 13530)
+		(-261082718496449122051 13530)
-).
+	      ).
 self even ifTrue:[
-self == 0 ifTrue:[^1].
+	self == 0 ifTrue:[^1].
-p := table at:(self / 2).
+	p := table at:(self / 2).
-^ Fraction numerator:(p first) denominator:(p second).
+	^ Fraction numerator:(p first) denominator:(p second).
 ].
 self == 1 ifTrue:[ ^ (1 / 2) ].
 ^ 0.
 "
 to print a number/and for conversion to a LargeInteger.
 Implemented that way, to allow for tiny systems (PDAs) without a Float class
 (i.e. without log)."
 self > 0 ifTrue:[
-self < 10000 ifTrue:[
+	self < 10000 ifTrue:[
-self < 10 ifTrue:[^ 0].
+	    self < 10 ifTrue:[^ 0].
-self < 100 ifTrue:[^ 1].
+	    self < 100 ifTrue:[^ 1].
-self < 1000 ifTrue:[^ 2].
+	    self < 1000 ifTrue:[^ 2].
-^ 3
+	    ^ 3
-].
+	].
-self < 100000000 ifTrue:[
+	self < 100000000 ifTrue:[
-self < 100000 ifTrue:[^ 4].
+	    self < 100000 ifTrue:[^ 4].
-self < 1000000 ifTrue:[^ 5].
+	    self < 1000000 ifTrue:[^ 5].
-self < 10000000 ifTrue:[^ 6].
+	    self < 10000000 ifTrue:[^ 6].
-^ 7
+	    ^ 7
-].
+	].
-self < 1000000000 ifTrue:[^ 8].
+	self < 1000000000 ifTrue:[^ 8].
-SmallInteger maxBytes == 4 ifTrue:[
+	SmallInteger maxBytes == 4 ifTrue:[
-"/ on a 32 bit machine, SmallInt cannot be larger
+	    "/ on a 32 bit machine, SmallInt cannot be larger
-^ 9
+	    ^ 9
-] ifFalse:[
+	] ifFalse:[
-"/ 64 bit machine
+	    "/ 64 bit machine
-self < 100000000000000 ifTrue:[
+	    self < 100000000000000 ifTrue:[
-self < 10000000000 ifTrue:[^ 9].
+		self < 10000000000 ifTrue:[^ 9].
-self < 100000000000 ifTrue:[^ 10].
+		self < 100000000000 ifTrue:[^ 10].
-self < 1000000000000 ifTrue:[^ 11].
+		self < 1000000000000 ifTrue:[^ 11].
-self < 10000000000000 ifTrue:[^ 12].
+		self < 10000000000000 ifTrue:[^ 12].
-^ 13
+		^ 13
-].
+	    ].
-self < 1000000000000000 ifTrue:[^ 14].
+	    self < 1000000000000000 ifTrue:[^ 14].
-self < 10000000000000000 ifTrue:[^ 15].
+	    self < 10000000000000000 ifTrue:[^ 15].
-self < 100000000000000000 ifTrue:[^ 16].
+	    self < 100000000000000000 ifTrue:[^ 16].
-self < 1000000000000000000 ifTrue:[^ 17].
+	    self < 1000000000000000000 ifTrue:[^ 17].
-^ 18.
+	    ^ 18.
-].
+	].
 ].
 ^ self class
-raise:(self = 0 ifTrue:[#infiniteResultSignal] ifFalse:[#domainErrorSignal])
+	raise:(self = 0 ifTrue:[#infiniteResultSignal] ifFalse:[#domainErrorSignal])
-receiver:self
+	receiver:self
-selector:#integerLog10
+	selector:#integerLog10
-arguments:#()
+	arguments:#()
-errorString:'bad receiver in log10 (not strictly positive)'
+	errorString:'bad receiver in log10 (not strictly positive)'
 "
 99 integerLog10
 100 integerLog10
 101 integerLog10
 char buffer[256];
 OBJ s;
 int len;
 if (__isStringLike(formatString)) {
-/*
+	/*
-* actually only needed on sparc: since thisContext is
+	 * actually only needed on sparc: since thisContext is
-* in a global register, which gets destroyed by printf,
+	 * in a global register, which gets destroyed by printf,
-* manually save it here - very stupid ...
+	 * manually save it here - very stupid ...
-*/
+	 */
-__BEGIN_PROTECT_REGISTERS__
+	__BEGIN_PROTECT_REGISTERS__
-len = snprintf(buffer, sizeof(buffer), __stringVal(formatString), __intVal(self));
+	len = snprintf(buffer, sizeof(buffer), __stringVal(formatString), __intVal(self));
-__END_PROTECT_REGISTERS__
+	__END_PROTECT_REGISTERS__
-if (len < 0) goto fail;
+	if (len < 0) goto fail;
-if (len >= sizeof(buffer)) goto fail;
+	if (len >= sizeof(buffer)) goto fail;
-s = __MKSTRING_L(buffer, len);
+	s = __MKSTRING_L(buffer, len);
-if (s != nil) {
+	if (s != nil) {
-RETURN (s);
+	    RETURN (s);
-}
+	}
 }
 fail: ;
 #endif /* not __SCHTEAM__ */
 %}.
 ^ super printfPrintString:formatString
 "
-123 printfPrintString:'%%d -> %d'
+	123 printfPrintString:'%%d -> %d'
-123 printfPrintString:'%%6d -> %6d'
+	123 printfPrintString:'%%6d -> %6d'
-123 printfPrintString:'%%x -> %x'
+	123 printfPrintString:'%%x -> %x'
-123 printfPrintString:'%%4x -> %4x'
+	123 printfPrintString:'%%4x -> %4x'
-123 printfPrintString:'%%04x -> %04x'
+	123 printfPrintString:'%%04x -> %04x'
 "
 "Modified: / 03-07-2017 / 15:07:37 / cg"
 ! !

changeset 22227	eae082846c10
parent 22221	ffeed1814b34
child 22268	fe294972157a