; переводит число в двоично-десятичном коде в строку
bcd_to_string macro     str_num, number
local   m1, exit ;ten,num,num2,go,m2,m3,m4,num_one

;jmp     go
;
;go:
        SaveReg <cx, ax ,si, bx>
        mov     cx, 10
        mov     bx, str_num
        add     bx, 20 ; смещаемся на 20 символов от начала строки
        mov     byte ptr[bx], '$' ; ставим в конец доллар
        dec     bx
        lea     si, number ; берем адрес числа
m1:
        dec     bx
        mov     al, byte ptr[si] ; в al байт
        inc     si ; переходим на следующий байт
        mov     ah,al
        shr     ah,4 ; в ah старшая часть байта
        add     ah, 30h
        mov     byte ptr [bx], ah ; выводим старшую часть
        inc     bx

        mov     ah,al
        shl     ah,4 ; в ah младшие 4 бита байта, но в 4 старших битах
        shr     ah,4 ; поэтому ставим на место
        add     ah, 30h
        mov     byte ptr [bx], ah ; выводим младшую часть
        dec     bx
        dec     bx

        loop    m1 ; и так ровно 10 байтов (потому что 10 байт в FPU разрядность)
exit:
;       dec     bx
        mov     byte ptr [bx], '$'
        LoadReg <bx, si, ax, cx>
endm

float_to_string macro   number, str_number
local   flag,ten,go,exit,m1,m2,m3,m4,m5,c1,c2,c3,max,min, ten2
jmp     go

ten     dq      100000000.0 ; 10^8
ten2    dq      10.0
flag    db      0
max     dq      1.0
min     dq      0.1

go:
        SaveReg <bx,cx>

        ; хитрая проверка на знак: сравниваем байт, в котором знак с 10000000b. Делаем побитовое "и" этого байта и 10000000b. Если 0, значит в знаковом бите был 0.
        lea     si, number
        add     si, 9
        mov     al, byte ptr[si]
        test    al, 80h
        je      m1 ; так вот если был 0, то переходим
        mov     flag, 1 ; иначе ставим флаг
m1:

        finit

        fld     ten
        fld     number
        fmul
        fbstp   number

        lea     bx, str_number
        lea     si, str_number
        bcd_to_string   bx, number

        mov     cx, 20
        cmp     flag, 0
        je      m2
        mov     byte ptr[si], '-'
        inc     bx
        inc     si
        dec     cx
m2:
        cmp     byte ptr[bx],'0'
        jne     m4
        cmp     cx,9
        je      m4
        inc     bx
        loop    m2
m4:
        cmp     cx, 8
        jne     m5
        mov     byte ptr[si], '.'
        inc     si
        dec     cx
        jmp     m4
m5:
        mov     al, byte ptr[bx]
        mov     byte ptr[si], al
        inc     bx
        inc     si
        loop    m4

        mov     byte ptr [si], 10
        inc     si
        mov     byte ptr [si], 13
        inc     si
        mov     byte ptr [si], '$'

exit:

        LoadReg <cx,bx>
endm