"

 COPYRIGHT (c) 1988 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libbasic' }"

Number subclass:#Integer

	instanceVariableNames:''

	classVariableNames:'DefaultDisplayRadix BCDConversionErrorSignal'

	poolDictionaries:''

	category:'Magnitude-Numbers'

!

Object subclass:#ModuloNumber

	instanceVariableNames:'modulus reciprocal shift'

	classVariableNames:''

	poolDictionaries:''

	privateIn:Integer

!

!Integer class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) 1988 by Claus Gittinger

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

documentation

"

    abstract superclass for all integer numbers.

    See details in concrete subclasses LargeInteger and SmallInteger.

    Mixed mode arithmetic:

	int op int         -> int

	int op fix         -> fix; scale is fix's scale

	int op fraction    -> fraction

	int op float       -> float

    [Class variables:]

	DefaultDisplayRadix     the radix in which integers present their 

				displayString (which is used in inspectors)

				If you are to look at many hex numbers, bitmasks

				etc. you may set this to 2 or 16.

				(avoids typing printStringRadix:.. all the time

				 - I know - I am lazy ;-). Default is 10.

    [author:]

	Claus Gittinger

    [see also:]

	Number

	LargeInteger SmallInteger

	Float ShortFloat Fraction FixedPoint

"

! !

!Integer class methodsFor:'initialization'!

initialize

    BCDConversionErrorSignal isNil ifTrue:[

        BCDConversionErrorSignal := ConversionErrorSignal newSignal.

        BCDConversionErrorSignal nameClass:self message:#bcdConversionErrorSignal.

        BCDConversionErrorSignal notifierString:'bcd conversion error'.

    ].

    "Modified: / 15.11.1999 / 20:36:04 / cg"

! !

!Integer class methodsFor:'instance creation'!

byte1:b1 byte2:b2 byte3:b3 byte4:b4

    "Squeak compatibility:

     Return an Integer given four value bytes.

     The returned integer is either a Small- or a LargeInteger"

    |t|

    t := b4.

    t := (t bitShift:8) + b3.

    t := (t bitShift:8) + b2.

    ^ (t bitShift:8) + b1.

    "

     (Integer byte1:16r10 byte2:16r32 byte3:16r54 byte4:16r76) hexPrintString

     (Integer byte1:16r00 byte2:16r11 byte3:16r22 byte4:16r33) hexPrintString

    "

    "Created: 19.10.1997 / 18:08:52 / cg"

    "Modified: 19.10.1997 / 18:09:04 / cg"

!

fastFromString:aString at:startIndex

    "return the next unsigned Integer from the string 

     as a decimal number, starting at startIndex.

     The number must be in the native machines int range

     (i.e. 63bit on alpha / 31 on all others);

     However, for portability, only use it for 31bit numbers.

     No spaces are skipped.

     This is a specially tuned entry (using a low-level C-call), which

     returns garbage if the argument string is not a small integer number.

     It has been added to allow higher speed string decomposition into

     numbers."

%{

     if (__isString(aString) && __isSmallInteger(startIndex)) {

        char *cp = (char *)(__stringVal(aString));

        int idx = __intVal(startIndex) - 1;

        unsigned INT val;

        if ((unsigned)idx < __stringSize(aString)) {

            val = atoi(cp + idx);

            if (val <= _MAX_INT) {

                RETURN(__MKSMALLINT(val));

            }

            RETURN (__MKUINT(val));

        }

     }

%}.

     self primitiveFailed.

    "

     Integer fastFromString:'12345' at:1  

     Integer fastFromString:'12345' at:2  

     Integer fastFromString:'12345' at:3  

     Integer fastFromString:'12345' at:4  

     Integer fastFromString:'12345' at:5  

     Integer fastFromString:'1234512345' at:1  

     Integer fastFromString:'2147483647' at:1  

     Integer fastFromString:'4294967295' at:1 

     Integer fastFromString:'12345' at:6  

     Integer fastFromString:'12345' at:0  

     Time millisecondsToRun:[

        100000 timesRepeat:[

            Integer readFrom:'12345'

        ]

     ]  

    "

    "

     Time millisecondsToRun:[

        100000 timesRepeat:[

            Integer fastFromString:'12345' at:1  

        ]

     ]   

    "

!

fromBCDBytes:aByteArray

    "given a byteArray in BCD format, return an appropriate integer.

     The byteArray must contain the BCD encoded decimal string,

     starting with the most significant digits.

     This conversion is useful for some communication protocols,

     or control systems, which represent big numbers this way...

    "

    |val|

    val := 0.

    aByteArray do:[:twoDigits |

        |hi lo|

        hi := (twoDigits bitShift:-4) bitAnd:16r0F.

        lo := twoDigits bitAnd:16r0F.

        val := (val * 100) + (hi * 10) + lo

    ].

    ^ val

    "

     Integer fromBCDBytes:#[16r12 16r34 16r56]    

     Integer fromBCDBytes:#[16r12 16r34 16r56 16r78]   

     Integer fromBCDBytes:#[16r12 16r34 16r56 16r78 16r90] 

     Integer fromBCDBytes:#[16r98 16r76 16r54] 

     Integer fromBCDBytes:#[16r98 16r76 16r54 16r32] 

     Integer fromBCDBytes:#[16r98 16r76 16r54 16r32 16r10] 

     Integer fromBCDBytes:#[16r12 16r34 16r56 16r78 16r90 16r12 16r34 16r56 16r78 16r90]

    "

!

fromSwappedBCDBytes:aByteArray

    "given a byteArray in BCD format, return an appropriate integer.

     The byteArray must contain the BCD encoded decimal string,

     starting with the LEAST significant digits.

     This conversion is useful for some communication protocols,

     or control systems (e.g. SMC), which represent big numbers this way...

    "

    |val|

    val := 0.

    aByteArray do:[:twoDigits |

        |hi lo|

        lo := (twoDigits bitShift:-4) bitAnd:16r0F.

        hi := twoDigits bitAnd:16r0F.

        lo <= 9 ifTrue:[

            val := (val * 100) + (hi * 10) + lo

        ] ifFalse:[

            "16rF is used to encode an odd number of digits"

            val := (val * 10) + hi.

        ].

    ].

    ^ val

    "

     Integer fromSwappedBCDBytes:#[16r12 16r34 16r56]    

     Integer fromSwappedBCDBytes:#[16r12 16r34 16rF6]    

     Integer fromSwappedBCDBytes:#[16r12 16r34 16r56 16r78]   

     Integer fromSwappedBCDBytes:#[16r12 16r34 16r56 16r78 16r90] 

     Integer fromSwappedBCDBytes:#[16r98 16r76 16r54] 

     Integer fromSwappedBCDBytes:#[16r98 16r76 16r54 16r32] 

     Integer fromSwappedBCDBytes:#[16r98 16r76 16r54 16r32 16r10] 

     Integer fromSwappedBCDBytes:#[16r12 16r34 16r56 16r78 16r90 16r12 16r34 16r56 16r78 16r90]

    "

!

new:numberOfBytes neg:negative

    "for ST-80 compatibility:

     Return an empty Integer (uninitialized value) with space for

     numberOfBytes bytes (= digitLength). The additional argument

     negative specifies if the result should be a negative number.

     The digits can be stored byte-wise into the result, using digitAt:put:"

    ^ (LargeInteger basicNew numberOfDigits:numberOfBytes) 

		sign:(negative ifTrue:[-1] ifFalse:[1])

!

readFrom:aStringOrStream 

    "return the next unsigned Integer from the (character-)stream aStream 

     as decimal number. 

     NOTICE:   

       This behaves different from the default readFrom:, in returning

       0 (instead of raising an error) in case no number can be read.

       It is unclear, if this is the correct behavior (ST-80 does this)

       - depending on the upcoming ANSI standard, this may change."

    ^ self readFrom:aStringOrStream onError:0

    "

     Integer readFrom:(ReadStream on:'foobar')     

     Integer readFrom:(ReadStream on:'foobar') onError:nil  

    "

!

readFrom:aStringOrStream onError:exceptionBlock

    "return the next Integer from the (character-)stream aStream,

     handling initial XXr for arbitrary radix numbers and initial sign.

     Also, all initial whitespace is skipped.

     If the string does not represent a valid integer number,

     return the value of exceptionBlock."

    |value|

    ErrorSignal handle:[:ex |

        ^ exceptionBlock value

    ] do:[

        |str nextChar negative|

        str := aStringOrStream readStream.

        nextChar := str skipSeparators.

        (nextChar == $-) ifTrue:[

            negative := true.

            str next.

            nextChar := str peekOrNil

        ] ifFalse:[

            negative := false

        ].

        (nextChar isNil or:[nextChar isDigit not]) ifTrue:[ 

            "

             the string does not represent an integer

            "

            ^ exceptionBlock value

        ].

        value := self readFrom:str radix:10.

        nextChar := str peekOrNil.

        ((nextChar == $r) or:[ nextChar == $R]) ifTrue:[

            "-xxr<number> is invalid; should be xxr-<val>"

            negative ifTrue:[

                'Integer [warning]: invalid (negative) radix ignored' errorPrintCR.

                negative := false

            ].

            str next.

            value := self readFrom:str radix:value

        ].

        negative ifTrue:[

            value := value negated

        ].

    ].

    ^ value

    "

     Integer readFrom:'12345'      onError:['wrong']    

     Integer readFrom:'-12345'     onError:['wrong']    

     Integer readFrom:'+12345'     onError:['wrong']    

     Integer readFrom:'16rFFFF'    onError:['wrong']    

     Integer readFrom:'12345.1234' onError:['wrong'] 

     Integer readFrom:'foo'        onError:['wrong']

     Integer readFrom:'foo'                          

    "

    "Created: / 16.11.1995 / 22:48:59 / cg"

    "Modified: / 14.4.1998 / 19:17:28 / cg"

!

readFrom:aStringOrStream radix:radix

    "return the next unsigned Integer from the (character-)stream aStream 

     in radix; (assumes that the initial XXr has already been read).

     No whitespace-skipping is done.

     Returns 0 if no number available.

     NOTICE:   

       This behaves different from the default readFrom:, in returning

       0 (instead of raising an error) in case no number can be read.

       It is unclear, if this is the correct behavior (ST-80 does this)

       - depending on the upcoming ANSI standard, this may change."

    ^ self readFrom:aStringOrStream radix:radix onError:0

!

readFrom:aStringOrStream radix:radix onError:exceptionBlock

    "return the next unsigned Integer from the (character-)stream aStream 

     in radix; (assumes that the initial XXr has already been read).

     No whitespace-skipping is done.

     Returns the value of exceptionBlock, if no number is available."

    |str nextChar nextChar2 value 

     r     "{ Class: SmallInteger }"

     r2    "{ Class: SmallInteger }"|

    str := aStringOrStream readStream.

    nextChar := str peekOrNil.

    (nextChar notNil and:[nextChar isDigitRadix:radix]) ifFalse:[

        ^ exceptionBlock value

    ].

    value := nextChar digitValue.

    str next.

    nextChar := str peekOrNil.

"/ OLD code

"/    [nextChar notNil and:[nextChar isDigitRadix:radix]] whileTrue:[

"/        str next.

"/        value := value * radix + nextChar digitValue.

"/        nextChar := str peekOrNil.

"/    ].

"/    ^ value.

    "/ the code below does the same, but is much faster, if the

    "/ converted number is large

    "/ (requires only half as many LargeInt multiplications and additions)

    "/ It should not be slower for smallIntegers.

    r := radix.

    r2 := r * r.

    [nextChar notNil and:[nextChar isDigitRadix:r]] whileTrue:[

        str next.

        nextChar2 := str peekOrNil.

        (nextChar2 notNil and:[nextChar2 isDigitRadix:r]) ifTrue:[

            str next.

            value := (value * r2) + ((nextChar digitValue * r) + nextChar2 digitValue).

            nextChar := str peekOrNil.

        ] ifFalse:[

            ^ (value * r) + nextChar digitValue.

        ]

    ].

    ^ value

    "

     Integer readFrom:(ReadStream on:'12345') radix:10  

     Integer readFrom:(ReadStream on:'FFFF') radix:16  

     Integer readFrom:(ReadStream on:'1010') radix:2   

     Integer readFrom:(ReadStream on:'foobar') radix:10   

     Integer readFrom:(ReadStream on:'foobar') radix:10 onError:nil  

     Integer readFrom:'gg' radix:10 onError:0                      

    "

    "Modified: / 14.4.1998 / 19:16:46 / cg"

! !

!Integer class methodsFor:'Signal constants'!

bcdConversionErrorSignal

    "return the signal which is raised when bcd conversion fails

     (i.e. when trying to decode an invalid BCD number)"

    ^ BCDConversionErrorSignal

    "Modified: / 15.11.1999 / 20:35:20 / cg"

! !

!Integer class methodsFor:'constants'!

unity

    "return the neutral element for multiplication (1)"

    ^ 1

    "Modified: 18.7.1996 / 12:26:43 / cg"

!

zero

    "return the neutral element for addition (0)"

    ^ 0

    "Modified: 18.7.1996 / 12:26:38 / cg"

! !

!Integer class methodsFor:'misc'!

displayRadix:aNumber

    "being tired of always sending #printStringRadix: in the inspectors,

     this allows you to change the default print radix for the displayString

     method."

    DefaultDisplayRadix := aNumber

    "

     Integer displayRadix:16. 123456 inspect

     Integer displayRadix:10. 123456 inspect

    "

! !

!Integer class methodsFor:'queries'!

hasSharedInstances

    "return true if this class has shared instances, that is, instances

     with the same value are identical.

     Although not always shared (LargeIntegers), these should be treated

     so, to be independent of the number of bits in a SmallInt"

    ^ true

! !

!Integer methodsFor:'Compatibility - Dolphin'!

highWord

    "return the high 16 bits of a 32 bit value"

    ^ self bitShift:-16

    "

     (16r12345678 highWord) hexPrintString 

     (16r12345678 lowWord) hexPrintString 

    "

!

lowWord

    "return the low 16 bits of a 32 bit value"

    ^ self bitAnd:16rFFFF

    "

     (16r12345678 lowWord) hexPrintString    

     (16r12345678 highWord) hexPrintString   

    "

!

mask:integerMask set:aBoolean

    "Answer the result of setting/resetting the specified mask in the receiver."

    ^ aBoolean