home *** CD-ROM | disk | FTP | other *** search
/ Amiga ISO Collection / AmigaUtilCD2.iso / Programming / C / OTL-MC6.DMS / in.adf / libsrc.lha / LIBSRC / math_floattostr.asm < prev    next >
Encoding:
Assembly Source File  |  1994-04-15  |  5.3 KB  |  350 lines
  1.  
  2. * Maxon C++ Library:
  3. * Modul "math_floattostr"
  4. * Jens Gelhar 08.09.91, 15.04.94
  5.  
  6.     xdef    _floattostr,_fpwr10
  7.  
  8.     xref    GetMathbase
  9.     xref    uintdiv
  10.  
  11. SPAdd    = -66
  12. SPMul    = -78
  13. SPDiv    = -84
  14.  
  15. Halb    = $3F000000
  16. Eins    = $3F800000
  17. Zehn    = $41200000
  18.  
  19. _floattostr: ; Stack-Parameter: float, char[], short
  20.     movem.l    d2-d7/a2-a6,-(a7)
  21.     move.l    11*4+4(a7),d0
  22.     move.l    11*4+8(a7),a5
  23.     move.w    11*4+12(a7),d1
  24.     bsr.b    RealStr
  25.     move.l    a5,d0
  26.     movem.l (a7)+,d2-d7/a2-a6
  27.     rts
  28.  
  29. RealStr: ; Zahl d0, ±d1 Stellen, nach a5
  30.     move.w    d1,-(a7)
  31.     move.l    a5,a2
  32.     move.b    #' ',(a2)+
  33.     tst.l    d0
  34.     bpl.b    .posi
  35.     move.b    #'-',-1(a2)
  36.     bclr    #31,d0
  37. .posi    tst.w    (a7)        ; Stellenzahl
  38.     bne.b    .fixed
  39.     tst.l    d0
  40.     bne.b    .1
  41.     move.b    #'0',(a2)+    ; d0 = 0F
  42.     clr.b    (a2)
  43.     bra    wrreEnd
  44. .1    moveq    #6,d1
  45.     bsr    DigitString
  46.     cmp.w    #4,d1
  47.     bge.b    .4
  48.     cmp.w    #-1,d1
  49.     blt.b    .4
  50.     move.w    d1,d0
  51.     bsr    InsertKomma
  52. .2    cmp.b    #'0',-1(a2)    ; Nullen am Ende entfernen
  53.     bne.b    .3
  54.     clr.b    -(a2)
  55.     bra.b    .2
  56. .3    cmp.b    #'.',-1(a2)
  57.     bne    wrreEnd
  58.     clr.b    -(a2)
  59.     bra    wrreEnd
  60. .4    bsr    Exponentiere
  61.     bra    wrreEnd
  62.  
  63. .fixed:    ; Festpunkt - Darstellung
  64.     move.w    (a7),d1
  65.     bmi.b    .expo
  66.     tst.l    d0
  67.     bpl.b    .8
  68.     bsr    Exponent    ; d0 <> 0F
  69.     cmp.w    #9,d1
  70.     bge.b    .1
  71.     cmp.w    #-9,d1
  72.     ble.b    .1
  73.     add.w    (a7),d1
  74.     addq.w    #1,d1
  75.     move.w    d1,-(a7)
  76.     cmp.w    #7,d1
  77.     bls.b    .5
  78.     moveq    #7,d1
  79. .5    bsr.b    DigitString
  80.     move.w    (a7)+,d2
  81.     cmp.w    #20,d2
  82.     bhi.b    .7
  83.     subq.w    #7,d2
  84.     bls.b    .7
  85. .6    move.b    #'0',(a2)+
  86.     subq.w    #1,d2
  87.     bne.b    .6
  88. .7
  89.     move.w    d1,d0
  90.     bsr    InsertKomma
  91.     bra.b    wrreEnd
  92.  
  93. .8    ; d0 = 0F
  94.     move.b    #'0',(a2)+
  95.     move.b    #'.',(a2)+
  96. .loop8    move.b    #'0',(a2)+
  97.     subq.w    #1,d1
  98.     bne.b    .loop8
  99.     bra.b    wrreEnd
  100.  
  101. .expo    ; Exponential-Darsetllung
  102.     neg.w    d1
  103.     tst.l    d0
  104.     bne.b    .10
  105.     move.w    d1,d0
  106.     moveq    #0,d1
  107. .9    move.b    #'0',(a2)+    ; d0=0F
  108.     subq.w    #1,d0
  109.     beq.b    .13
  110.     cmp.w    #20,d0
  111.     bhs.b    .13
  112.     bra.b    .9
  113. .10    ; d0 <> 0F
  114.     cmp.w    #7,d1
  115.     blo.b    .11
  116.     moveq    #7,d1
  117. .11    bsr.b    DigitString
  118.     move.w    (a7),d0
  119.     neg.w    d0        ; Ziffern-anzahl
  120.     cmp.w    #20,d0
  121.     bhi.b    .13
  122. .12    cmp.w    #7,d0
  123.     bls.b    .13
  124.     move.b    #'0',(a2)+  ; Nullen anhängen
  125.     subq.w    #1,d0
  126.     bra.b    .12
  127. .13    bsr    Exponentiere
  128.  
  129. wrreEnd    addq.w #2,a7
  130.     rts
  131.  
  132. DigitString:
  133.     ; Ziffern von d0, d1 Stück, nach (a2)+ schreiben
  134.     ; Logarithmus nach d1
  135.     pea    0(a2,d1.w)
  136.     move.l    a2,-(a7)
  137.     move.w    d1,-(a7)
  138.     bsr    Exponent    ; 10er-Logarithmus
  139.     move.w    d1,-(a7)
  140.     neg.w    d1
  141.     add.w    2(a7),d1    ; Ziffernzahl addieren
  142.     move.l    d0,-(a7)
  143.     move.w    d1,d0
  144.     subq.w    #1,d0
  145.     jsr    GetMathbase
  146.     bsr    power
  147.     move.l    (a7)+,d1
  148.     jsr    SPMul(a6)
  149.     move.l    #Halb,d1
  150.     jsr    SPAdd(a6)
  151.     bsr    FixIt
  152.     move.w    (a7)+,d2    ; Lg
  153.     move.w    (a7)+,d1    ; Ziffernanzahl
  154.     move.l    (a7)+,a2
  155.     move.w    d2,-(a7)
  156.     bsr.b    PutInt
  157.     move.w    (a7)+,d1
  158.     move.l    a2,a0
  159.     move.l    (a7)+,a2    ; gewünschtes Ende
  160.     clr.b    (a2)
  161.     sub.l    a2,a0
  162.     add.w    a0,d1
  163.     rts
  164.  
  165. PutInt:    ; d0 nach (a2)+
  166.     ; d2 = Ziffernanzahl
  167.     moveq    #0,d2
  168. .1    move.w    d2,-(a7)
  169.     moveq    #10,d1
  170.     jsr    uintdiv
  171.     move.w    (a7)+,d2
  172.     move.w    d1,-(a7)
  173.     addq.w    #1,d2
  174.     tst.l    d0
  175.     bne.b    .1
  176.     move.w    d2,d1
  177. .2    move.w    (a7)+,d0
  178.     add.b    #'0',d0
  179.     move.b    d0,(a2)+
  180.     subq.w    #1,d1
  181.     bne.b    .2
  182.     rts
  183.  
  184. Exponentiere:
  185.     ; String 1(a5) ... (a2) in Expo-Darstellung bringen
  186.     ; Exponent d1
  187.     move.b    #'E',(a2)+
  188.     move.b    #'+',(a2)+
  189.     tst.w    d1
  190.     bpl.b    .1
  191.     move.b    #'-',-1(a2)
  192.     neg.w    d1
  193. .1    ext.l    d1
  194.     divu    #10,d1
  195.     add.b    #'0',d1
  196.     move.b    d1,(a2)+
  197.     swap    d1
  198.     add.b    #'0',d1
  199.     move.b    d1,(a2)+
  200.     clr.b    (a2)
  201.     moveq    #0,d0
  202.     cmp.b    #'E',2(a5)
  203.     bne.b    InsertKomma
  204.     rts            ; bei nur einer Stelle keinen Punkt
  205.  
  206. InsertKomma:
  207.     ; in Ziffernfolge in String a5 ab Pos. d0 Komma einfügen
  208.     move.l    a5,a0
  209.     lea    2(a0,d0.w),a0
  210.     tst.w    d0
  211.     bpl.b    .2
  212.     lea    1(a5),a0
  213. .0    addq.w    #1,d0
  214.     bpl.b    .1
  215.     bsr.b    Insa0a2
  216.     move.b    #'0',(a0)
  217.     bra.b    .0
  218. .1    bsr.b    Insa0a2
  219.     move.b    #'.',(a0)
  220.     bsr.b    Insa0a2
  221.     move.b    #'0',(a0)
  222.     rts
  223. .2    ; d0 > 0
  224.     cmp.l    a2,a0
  225.     bhi.b    .3
  226.     beq.b    .4
  227.     ; Punkt liegt in Ziffernfolge
  228.     bsr.b    Insa0a2
  229.     move.b    #'.',(a0)
  230. .4    rts
  231. .3    ; Punkt hinter Ziffernfolge
  232.     move.b    #'0',(a2)+  ; Nullen anhängen
  233.     cmp.l    a0,a2
  234.     blo.b    .3
  235.     rts
  236.  
  237. Insa0a2:    ; ab a0 bis a2 ein Byte einfügen
  238.     addq.l    #1,a2
  239.     move.l    a2,a1
  240. .a    cmp.l    a0,a1
  241.     bls.b    .b
  242.     move.b    -(a1),1(a1)
  243.     bra.b    .a
  244. .b    rts
  245.  
  246. FixIt:    ; SPFix-Ersatz
  247.     tst.l    d0
  248.     beq.b    .0    ; Null ist Null
  249.     bpl.b    .1
  250.     bclr    #31,d0    ; negativ
  251.     bsr.b    .1
  252.     neg.l    d0
  253.     rts
  254. .1    cmp.l    #Eins,d0
  255.     blo.b    .0
  256.     move.l    d0,d1
  257.     and.l    #$007FFFFF,d0    ; Mantisse
  258.     bset    #23,d0        ; Hidden Bit setzen
  259.     swap    d1
  260.     lsr.w    #23-16,d1    ; nackter Exponent
  261.     sub.w    #$7E+24,d1    ; Shift-Stellen
  262.     bhs.b    .links
  263.     neg.w    d1
  264.     lsr.l    d1,d0
  265.     rts
  266. .links    lsl.l    d1,d0
  267.     rts
  268. .0    moveq #0,d0
  269.     rts
  270.  
  271. Exponent:
  272.     ; von Float d0>=0 nach d1, d0 nicht verändern
  273.     tst.l    d0
  274.     bne.b    .null
  275.     moveq    #0,d1        ; Null hat Exponent 0 (na ja...)
  276.     rts
  277. .null    jsr    GetMathbase
  278.     cmp.l    #Eins,d0
  279.     bhs.b    .greater
  280.     ; d0 < 1
  281.     moveq    #0,d1
  282.     move.l    d0,-(a7)
  283. .1    subq.l    #1,d1
  284.     move.l    d1,-(a7)
  285.     move.l    d1,d0
  286.     bsr    power
  287.     move.l    (a7)+,d1
  288.     move.l    (a7),d2
  289.     cmp.l    d0,d2        ; Floats vergleichen
  290.     blo.b    .1
  291.     bra.b    .5
  292. .greater    ; d0 >= 1
  293.     moveq    #-1,d1
  294.     move.l    d0,-(a7)
  295. .3    addq.l    #1,d1
  296.     cmp.w    #20,d1
  297.     bhs.b    .4
  298.     move.l    d1,-(a7)
  299.     move.l    d1,d0
  300.     bsr    power
  301.     move.l    (a7)+,d1
  302.     move.l    (a7),d2
  303.     cmp.l    d0,d2
  304.     bhi.b    .3
  305. .4    ; gefunden
  306.     subq.w    #1,d1
  307. .5    move.l    (a7)+,d0
  308.     rts
  309.  
  310.  
  311. _fpwr10:
  312.     move.l    4(a7),d0
  313.     movem.l    d2-d3/a6,-(a7)
  314.     jsr    GetMathbase
  315.     bsr.b    power
  316.     movem.l    (a7)+,d2-d3/a6
  317.     rts
  318.  
  319. power:    ; 10^d0 berechnen (Math-Base schon in a6!)
  320.     cmp.w    #19,d0
  321.     bgt.b    .large
  322.     tst.w    d0
  323.     bpl.b    .a
  324.     neg.w    d0
  325.     cmp.w    #19,d0
  326.     bhi.b    .e
  327.     bsr.b    .a
  328.     move.l    d0,d1
  329.     move.l    #Eins,d0
  330.     jmp    SPDiv(a6)
  331. .a    cmp.w    #9,d0
  332.     bls.b    .b
  333.     sub.w    #9,d0
  334.     bsr.b    .b
  335.     move.l    .data+9*4(pc),d1
  336.     jmp    SPMul(a6)
  337. .b    asl.w    #2,d0
  338.     move.l    .data(pc,d0.w),d0
  339.     rts
  340. .data    dc.l    Eins,Zehn,$42C80000,$447A0000,$461C4000
  341.     dc.l    $47C35000,$49742400,$4B189680,$4CBEBC20,$4E6E6B28
  342. .e    moveq #0,d0
  343.     rts
  344.  
  345. .large    ; Überlauf:
  346.     move.l #$7FFFFFFF,d0
  347.     rts
  348.  
  349.     end
  350.