Subversion Repositories ft816float

; ============================================================================

;        __

;   \\__/ o\    (C) 2022  Robert Finch, Waterloo

;    \  __ /    All rights reserved.

;     \/_//     robfinch@opencores.org

;       ||

;

;

; BSD 3-Clause License

; Redistribution and use in source and binary forms, with or without

; modification, are permitted provided that the following conditions are met:

;

; 1. Redistributions of source code must retain the above copyright notice, this

;    list of conditions and the following disclaimer.

;

; 2. Redistributions in binary form must reproduce the above copyright notice,

;    this list of conditions and the following disclaimer in the documentation

;    and/or other materials provided with the distribution.

;

; 3. Neither the name of the copyright holder nor the names of its

;    contributors may be used to endorse or promote products derived from

;    this software without specific prior written permission.

;

; THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

; AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

; IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

; DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

; FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

; SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

; CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

; OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

; OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

;

; ============================================================================

;

;==============================================================================

; Decimal-Floating point to string conversion routine.

;==============================================================================

; These variables may need to be relocated depending on the system.

fpBuf equ $402C0

_exp equ $40500

_digit equ $40504

_width equ $40508

_E equ $4050C

_digits_before_decpt equ $40510

_precision equ $40514

_fpBuf equ $40520       ; to $40560

_fpWork equ $40600

        code

;==============================================================================

; Decimal-Floating point to string conversion routine.

;

; Modifies

;               _fpWork work area

; Register Usage:

;       fp0 = input decimal-float to convert

;               fp1 = constant holder, 1.0, 10.0

;               fp2 = 1.0e value for conversion

;               fp3 = holds digit value during significand conversion

;       a0 = pointer to string buffer, updated to point to NULL at end of string

;               a1 = pointer to "Nan" or "Inf" message string

;               d0 = temporary

;               d1 = digit value during exponent, significand conversion

;       d6 = exponent

;==============================================================================

        align 4

_dfOne  dc.l $25ff0000,$00000000,$00000000

_dfTen  dc.l $2600C000,$00000000,$00000000

_dfMil  dc.l $2606DDFA,$1C000000,$00000000

_msgNan dc.b "NaN",0

_msgInf dc.b "Inf",0

        even

;------------------------------------------------------------------------------

; Check for the special Nan and infinity values. Output the appropriate string.

;

; Modifies

;               _fpWork area

;               d0,a1,a0

; Parameters:

;               fp0 = dbl

;------------------------------------------------------------------------------

_CheckNan:

        fmove.p fp0,_fpWork

        move.b _fpWork,d0                               ; get sign+combo

        andi.b #$7C,d0                                  ; mask for combo bits

        cmpi.b #$7C,d0                                  ; is it the Nan combo?

        bne .notNan

        lea _msgNan,a1                                  ; output "Nan"

        bra .outStr

.notNan

        cmpi.b #$78,d0                                  ; is it infinity combo?

        bne .notInf

        lea _msgInf,a1

.outStr

        move.b (a1)+,(a0)+                      ; output "Inf"

        move.b (a1)+,(a0)+

        move.b (a1)+,(a0)+

        clr.b (a0)

.twoup

        addq #4,sp                                                      ; pop return address for two up return

.notInf

        rts

;------------------------------------------------------------------------------

; Check for a zero value. Output a single "0" if zero,

;

; Modifies:

;               a0

; Parameters:

;               fp0 = dbl

;------------------------------------------------------------------------------

_CheckZero:

        ftst fp0                                                                ; check if number is zero

        fbne .0003

        move.b #'0',(a0)+                               ; if zero output "0"

        clr.b (a0)

        addq #4,sp                                                      ; pop return address for two up return

.0003

        rts

;------------------------------------------------------------------------------

; Check for a negative number. This includes Nans and Infinities. Output a "-"

; if negative.

;

;       Modifies

;               a0

; Parameters:

;               fp0 = dbl

;------------------------------------------------------------------------------

_CheckNegative:

        ftst fp0                                                                ; is number negative?

        fbge .0002

        move.b #'-',(a0)+                               ; yes, output '-'

        fneg fp0                                                                ; make fp0 positive

.0002

        rts

;------------------------------------------------------------------------------

; Make the input value larger so that digits may appear before the decimal

; point.

;

; Modifies:

;               fp0,fp1,d6

; Parameters:

;               fp0 = dbl

;------------------------------------------------------------------------------

;       if (dbl < 1.0) {

;               while (dbl < 1.0) {

;                       dbl *= 1000000.0;

;                       exp -= 6;

;               }

;       }

_MakeBig:

        fmove.w #1,fp1

.0002

        fcmp fp1,fp0                                            ; is fp0 > 1?

        fbge .0001                                                      ; yes, return

        fscale.l #6,fp0                                 ; multiply fp0 by a million

        subi.w #6,d6                                            ; decrement exponent by six

        bra .0002                                                               ; keep trying until number is > 1

.0001

        fmove.p fp0,_fpWork+24  ; debugging

        rts

;------------------------------------------------------------------------------

;       Create a number dbl2 on the same order of magnitude as dbl, but

;       less than dbl. The number will be 1.0e

;

; Modifies:

;               d6,fp2

; Parameters:

;               fp0 = dbl

;------------------------------------------------------------------------------

;       // The following is similar to using log10() and pow() functions.

;       // Now dbl is >= 1.0

;       // Create a number dbl2 on the same order of magnitude as dbl, but

;       // less than dbl.

;       dbl2 = 1.0;

;       dbla = dbl2;

;       if (dbl > dbl2) {       // dbl > 1.0 ?

;               while (dbl2 <= dbl) {

;                       dbla = dbl2;

;                       dbl2 *= 10.0;   // increase power of 10

;                       exp++;

;               }

;               // The above loop goes one too far, we want the last value less

;               // than dbl.

;               dbl2 = dbla;

;               exp--;

;       }

_LessThanDbl:

        fmove.w #1,fp2                  ; setup fp2 = 1

        fcmp fp2,fp0                            ; if (dbl > dbl2)

        fble .0004

.0006

        fcmp fp0,fp2                            ; while (dbl2 <= dbl)

        fbgt .0005

        fscale.w #1,fp2                 ; dbl2 *= 10 (increase exponent by one)

        addi.w #1,d6                            ; exp++

        bra .0006

.0005

        fscale.l #-1,fp2                ; dbl2 /= 10 (decrease exponent by one)

        subi.w #1,d6                            ; exp--;

.0004

        fmove.p fp0,_fpWork     ; debugging

        fmove.p fp2,_fpWork+12

        rts

;------------------------------------------------------------------------------

; Compute the number of digits before the decimal point.

;

; Modifies:

;               d0,d6,_digits_before_decpt

; Parameters:

;               d6 = exponent

;------------------------------------------------------------------------------

; if (exp >= 0 && exp < 6) {

;   digits_before_decpt = exp+1;

;               exp = 0;

;       }

;       else if (exp >= -6)

;               digits_before_decpt = 1;

;       else

;               digits_before_decpt = -1;

_ComputeDigitsBeforeDecpt:

        tst.w d6

        bmi .0007

        cmpi.w #6,d6

        bge .0007

        move.w d6,d0

        addi.w #1,d0

        move.w d0,_digits_before_decpt

        clr.w d6

        rts

.0007

        cmpi.w #-6,d6

        blt .0009

        move.w #1,_digits_before_decpt

        rts

.0009

        move.w #-1,_digits_before_decpt

        rts

;------------------------------------------------------------------------------

;       Spit out a leading zero before the decimal point for a small number.

;

; Parameters:

;               d6 = exponent

;------------------------------------------------------------------------------

;  if (exp < -6) {

;                buf[ndx] = '0';

;                ndx++;

;    buf[ndx] = '.';

;    ndx++;

;  }

_LeadingZero:

        cmpi.w #-6,d6

        bge .0010

        move.b #'0',(a0)+

        move.b #'.',(a0)+

.0010

        rts

;------------------------------------------------------------------------------

; Extract the digits of the significand.

;

; Modifies:

;               _precision variable

; Register Usage

;               d1 = digit

;               fp0 = dbl

;               fp2 = dbl2

;               fp3 = digit as decimal float

;               fp7 = dbla

; Parameters:

;               fp0

;------------------------------------------------------------------------------

;       // Now loop processing one digit at a time.

;  for (nn = 0; nn < 25 && precision > 0; nn++) {

;    digit = 0;

;               dbla = dbl;

;               // dbl is on the same order of magnitude as dbl2 so

;               // a repeated subtract can be used to find the digit.

;    while (dbl >= dbl2) {

;      dbl -= dbl2;

;      digit++;

;    }

;    buf[ndx] = digit + '0';

;               // Now go back and perform just a single subtract and

;               // a multiply to find out how much to reduce dbl by.

;               // This should improve the accuracy

;               if (digit > 2)

;                       dbl = dbla - dbl2 * digit;

;    ndx++;

;    digits_before_decpt--;

;    if (digits_before_decpt==0) {

;                       buf[ndx] = '.';

;                       ndx++;

;    }

;    else if (digits_before_decpt < 0)

;      precision--;

;               // Shift the next digit to be tested into position.

;    dbl *= 10.0;

;  }

_SpitOutDigits:

        move.w #24,d0                   ; d0 = nn

        fmove.l #10,fp1         ; fp1 = 10.0

.0017

        tst.l _precision

        ble .0011

        moveq #0,d1                             ; digit = 0

        fmove fp0,fp7                   ; dbla = dbl

.0013

        fcmp fp2,fp0

        fblt .0012

        fsub fp2,fp0                    ; dbl -= dbl2

        addi.b #1,d1                    ; digit++

        bra .0013

.0012

        addi.b #'0',d1          ; convert digit to ascii

        move.b d1,(a0)+         ; and store

        subi.b #'0',d1          ; d1 = binary digit again

.0014

        subi.w #1,_digits_before_decpt

        bne .0015

        move.b #'.',(a0)+

.0015

        tst.w _digits_before_decpt

        bge .0016

        subi.l #1,_precision

.0016

        fscale.l #-1,fp2                ; dbl *= 10.0

        dbra d0,.0017

.0011

        rts

;------------------------------------------------------------------------------

; If the number ends in a decimal point, trim off the point.

;

; Registers Modified:

;               none

; Parameters:

;               a0 = pointer to end of number

; Returns:

;               a0 = updated to point just past last digit.

;------------------------------------------------------------------------------

_TrimTrailingPoint:

        cmpi.b #'.',-1(a0)

        bne .0001

        clr.b -(a0)

        rts

.0001

        cmpi.b #'.',(a0)

        bne .0002

        cmpi.b #0,1(a0)

        bne .0002

        clr.b (a0)

        subq #1,a0

.0002

        rts

;------------------------------------------------------------------------------

; If the number ends in .0 get rid of the .0

;

; Registers Modified:

;               none

; Parameters:

;               a0 = pointer to last digits of number

; Returns:

;               a0 = updated to point just past last digit.

;------------------------------------------------------------------------------

_TrimDotZero:

        tst.b (a0)

        bne .0004

        cmpi.b #'0',-1(a0)

        bne .0004

        cmpi.b #'.',-2(a0)

        bne .0004

        clr.b -2(a0)

        subq #2,a0

.0004

        rts

;------------------------------------------------------------------------------

; Trim trailing zeros from the number. Generally there is no need to display

; trailing zeros.

; Turns a number like 652.000000000000000000000 into 650.0

;

; Registers Modified:

;               none

; Parameters:

;               a0 = pointer to last digits of number

; Returns:

;               a0 = updated to point just past last digit.

;------------------------------------------------------------------------------

;       // Trim trailing zeros from the number

;  do {

;      ndx--;

;  } while(buf[ndx]=='0');

;  ndx++;

_TrimTrailingZeros:

.0018

        cmpi.b #'0',-(a0)               ; if the last digit was a zero, backup

        beq .0018

        addq #1,a0                                      ; now advance by one

        move.b #0,(a0)                  ; NULL terminate string

        rts

;------------------------------------------------------------------------------

; Output 'e+' or 'e-'

;

; Registers Modified:

;               d6.w (if negative)

; Parameters:

;               a0 = pointer to last digits of number

; Returns:

;               a0 = updated to point just past '+' or '-'.

;------------------------------------------------------------------------------

;       // Spit out +/-E

;  buf[ndx] = E;

;  ndx++;

;  if (exp < 0) {

;    buf[ndx]='-';

;    ndx++;

;    exp = -exp;

;  }

;  else {

;               buf[ndx]='+';

;               ndx++;

;  }

_SpitOutE:

        move.b _E,(a0)+

        tst.w d6

        bge .0021

        move.b #'-',(a0)+

        neg.w d6

        bra .0022

.0021

        move.b #'+',(a0)+

.0022

        rts

;------------------------------------------------------------------------------

; Extract a single digit of the exponent. Extract works from the leftmost digit

; to the rightmost.

;

; Register Usage

;               d2 = history of zeros

;               d3 = digit

; Modifies

;               d2,d3,d6,a0

; Parameter

;       d1.w = power of ten

;               d6.w = exponent

;------------------------------------------------------------------------------

_ExtExpDigit:

        ext.l d6                                ; make d6 a long

        divu d1,d6                      ; divide by power of ten

        move.b d6,d3            ; d3 = quotient (0 to 9)

        swap d6                                 ; d6 = remainder, setup for next digit

        or.b d3,d2

        tst.b d3

        bne .0003

        tst.b d2

        beq .0004

.0003

        addi.b #'0',d3  ; convert to ascii

        move.b d3,(a0)+

.0004

        rts

;------------------------------------------------------------------------------

; Extract all the digits of the exponent.

;

; Register Usage

;               d1 = power of 10

;               d2 = history of zeros

; Parameters

;               a0 = pointer to string buffer

;               d6 = exponent

;------------------------------------------------------------------------------

;       // If the number is times 10^0 don't output the exponent

;  if (exp==0) {

;    buf[ndx]='\0';

;    goto prt;

;  }

_ExtExpDigits:

        tst.w d6                                                        ; is exponent zero?

        beq .0002

        bsr _SpitOutE                                   ; exponent is non-zero e+

        clr.b d2                                                        ; d2 = history of zeros

        move.w #1000,d1

        bsr _ExtExpDigit

        move.w #100,d1

        bsr _ExtExpDigit

        move.w #10,d1

        bsr _ExtExpDigit

        move.w #1,d1

        bsr _ExtExpDigit

.0002:

        move.b #0,(a0)                          ; NULL terminate string

        rts                                                                             ; and return

;------------------------------------------------------------------------------

; Pad the left side of the output string.

;

; Modifies:

;               d0,d1,d2,d3

;------------------------------------------------------------------------------

;  // pad left

;  if (width > 0) {

;    if (ndx < width) {

;      for (nn = 39; nn >= width-ndx; nn--)

;        buf[nn] = buf[nn-(width-ndx)];

;      for (; nn >= 0; nn--)

;        buf[nn] = ' ';

;    }

;  }

_PadLeft:

        tst.b _width

        ble .0041

        move.l a0,d0

        sub.l #_fpBuf,d0        ; d0 = ndx

        cmp.b _width,d0

        bge .0041

        move.w #49,d1                   ; d1 = nn

.0040

        move.b _width,d2

        ext.w d2

        sub.w d0,d2                             ; d2 = width-ndx

        cmp.w d2,d1

        blt .0039

        move.w d1,d3                    ; d3 = nn

        sub.w d2,d3                             ; d3 = nn-(width-ndx)

        move.b (a0,d3.w),(a0,d1.w)

        subi.w #1,d1

        bra .0040

.0039

        tst.w d1

        bmi .0041

        move.b #' ',(a0,d1.w)

        subi.w #1,d1

        bra .0039

.0041

        rts

;------------------------------------------------------------------------------

; Pad the right side of the output string.

;

; Modifies:

;               d0

; Returns:

;               d0 = length of string

;------------------------------------------------------------------------------

;  // pad right

;  if (width < 0) {

;    width = -width;

;    while (ndx < width) {

;      buf[ndx]=' ';

;      ndx++;

;    }

;    buf[ndx]='\0';

;  }

;  return (ndx);

_PadRight:

        tst.b _width

        bpl .0042

        neg.b _width

        move.l a0,d0

        sub.l #_fpBuf,d0        ; d0 = ndx

.0044

        cmp.b _width,d0

        bge .0043

        move.b #' ',(a0,d0.w)

        addi.w #1,d0

        bra .0044

.0043

        move.b #0,(a0,d0.w)

.0042

        ext.w d0

        ext.l d0

        rts

;------------------------------------------------------------------------------

; Output a string representation of a decimal floating point number to a

; buffer.

;

; Register Usage

;               a0 = pointer to string buffer

;               d6 = exponent

; Parameters:

;               fp0 = number to convert

;------------------------------------------------------------------------------

_sprtflt:

        bsr _CheckNegative                      ; is number negative?

        bsr _CheckZero                                  ; check for zero

        bsr _CheckNan                                           ; check for Nan or infinity

        ; Now the fun begins

        clr.l d6

        bsr _MakeBig

        bsr _LessThanDbl

        bsr _ComputeDigitsBeforeDecpt

        bsr _LeadingZero

        bsr _SpitOutDigits

        bsr _TrimTrailingZeros

        bsr _TrimTrailingPoint

        bsr _TrimDotZero

        bsr _ExtExpDigits                               ; extract exponent digits

        bsr _PadLeft                                            ; pad the number to the left or right

        bra _PadRight

;------------------------------------------------------------------------------

; Trap #15, function 39 - convert floating-point to string and display

;

; Parameters

;               a0 = pointer to buffer

;               fp0 = number to print

;               d1 = width of print field

;               d2 = precision

;               d3 = 'E' or 'e'

;------------------------------------------------------------------------------

prtflt:

        movem.l d0/d1/d2/d3/d6/a1,-(a7)

;       fmove.p fp0,-(a7)

        move.l a1,a0                                            ; a0 = pointer to buffer to use

        move.b d1,_width

        move.l d2,_precision

        move.b d3,_E

        bsr _sprtflt

        bsr DisplayString

;       fmove.p (a7)+,fp0

        movem.l (a7)+,d0/d1/d2/d3/d6/a1

        rts