подключение FPTOA и FPTOA2 из m32lib

                     
        .486                                                                
        .model flat, stdcall                                                
        option casemap:none   ; case sensitive                              
                                                                            
; ####################################################                      
        include \A\masm32\include\windows.inc      
        include \A\masm32\include\user32.inc       
        include \A\masm32\include\kernel32.inc     
        include \A\masm32\include\masm32.inc       
                                                                            
                                                                            
        includelib \A\masm32\lib\masm32.lib        
        includelib \A\masm32\lib\user32.lib        
        includelib \A\masm32\lib\kernel32.lib      
 
include FPTOA.asm                                                           
include FPTOA2.asm                                                                                                                      
 
.data
бла-бла
.code
бла-бла

_PowerOf10 PROTO

    include \MASM32\INCLUDE\masm32.inc
    include \MASM32\INCLUDE\gdi32.inc
    include \MASM32\INCLUDE\comctl32.inc
    include \MASM32\INCLUDE\comdlg32.inc
    include \MASM32\include\imagehlp.inc
    include \MASM32\include\shell32.inc
    include \MASM32\include\ole32.inc
    include \MASM32\include\oleaut32.inc
    include \MASM32\include\winmm.inc
    include \MASM32\include\advapi32.inc
 
    includelib \MASM32\LIB\gdi32.lib
    includelib \MASM32\LIB\comctl32.lib
    includelib \MASM32\LIB\comdlg32.lib
    includelib \MASM32\LIB\imagehlp.lib
    includelib \MASM32\lib\shell32.lib
    includelib \MASM32\lib\ole32.lib
    includelib \MASM32\lib\oleaut32.lib
    includelib \MASM32\lib\winmm.lib
    includelib \MASM32\lib\advapi32.lib

include FPTOA.asm                                                           
include FPTOA2.asm

; masm windows gui #
.486
.model flat
FP_LESSTHAN equ 01h
FP_EQUALTO  equ 40h
.data
ten dq  10.0
ten_1   dt  1.0e1
    dt  1.0e2
    dt  1.0e3
    dt  1.0e4
    dt  1.0e5
    dt  1.0e6
    dt  1.0e7
    dt  1.0e8
    dt  1.0e9
    dt  1.0e10
    dt  1.0e11
    dt  1.0e12
    dt  1.0e13
    dt  1.0e14
    dt  1.0e15
ten_16  dt  1.0e16
    dt  1.0e32
    dt  1.0e48
    dt  1.0e64
    dt  1.0e80
    dt  1.0e96
    dt  1.0e112
    dt  1.0e128
    dt  1.0e144
    dt  1.0e160
    dt  1.0e176
    dt  1.0e192
    dt  1.0e208
    dt  1.0e224
    dt  1.0e240
ten_256 dt  1.0e256
; The remaining exponents are only necessary if we decide to support
; 10-byte doubles.  FloatToStr and StrToFloat only support 8-byte,
; but PowerOf10 doesn't care, so we'll include them.
    dt  1.0e512
    dt  1.0e768
    dt  1.0e1024
    dt  1.0e1280
    dt  1.0e1536
    dt  1.0e1792
    dt  1.0e2048
    dt  1.0e2304
    dt  1.0e2560
    dt  1.0e2816
    dt  1.0e3072
    dt  1.0e3328
    dt  1.0e3584
    dt  1.0e4096
    dt  1.0e4352
    dt  1.0e4608
    dt  1.0e4864
; Multiply a floating point value by an integral power of 10.
; Entry: EAX = power of 10, -4932..4932.
;   ST(0) = value to be multiplied
; Exit: ST(0) = value x 10^eax
; I'd rather this was local to the procedure, but masm doesn't do 
; local arrays correctly.
szTemp  db  18 dup (0)
ten7    dq  1.0e6
ten17   dq  1.0e17
rounder dq  5.0e10
ten16   dq  1.0e16
.code
start:
    retn
PowerOf10   PROC    public
    mov ecx, eax
    .IF (SDWORD PTR eax < 0)
    neg eax
    .ENDIF
    fld1
    mov dl, al
    and edx, 0fh
    .IF (!ZERO?)
    lea edx, [edx+edx*4]
    fld ten_1[edx*2][-10]
    fmulp st(1), st
    .ENDIF
    mov dl, al
    shr dl, 4
    and edx, 0fh
    .IF (!ZERO?)
    lea edx, [edx+edx*4]
    fld ten_16[edx*2][-10]
    fmulp st(1), st
    .ENDIF
    mov dl, ah
    and edx, 1fh
    .IF (!ZERO?)
    lea edx, [edx+edx*4]
    fld ten_256[edx*2][-10]
    fmulp st(1), st
    .ENDIF
    .IF (SDWORD PTR ecx < 0)
    fdivp st(1), st
    .ELSE
    fmulp st(1), st
    .ENDIF
    ret
PowerOf10   ENDP
; Convert a string to a double-precision floating point number;
; char * StrToFloat( char * str, double * fpout )
StrToFloat  PROC    stdcall public, szIn: PTR BYTE, fpout: PTR QWORD
    LOCAL   sign: BYTE
    LOCAL   expsign: BYTE
    LOCAL   decimal: DWORD
    LOCAL   stat: WORD
    LOCAL   temp: WORD
 
    xor eax, eax
    mov [sign], al
    mov [expsign], al
    mov [decimal], -1
    fstcw [stat]
    mov [temp], 027fh
    fldcw [temp]
; First, see if we have a sign at the front end.
    mov esi, [szIn]
    mov al, [esi]
    .IF (al == '+')
    inc esi
    mov al, [esi]
    .ELSEIF (al == '-')
    inc esi
    mov [sign], 1
    mov al, [esi]
    .ENDIF
    cmp al, 0       ; null string?
    je sdExit
; Initialize the floating point unit.
    fclex
    xor ebx, ebx
    fldz
    xor ecx, ecx
; OK, now start our main loop.
;   esi => character in string now in al
;   al = next character to be converted
;   ebx = number of digits encountered thus far
;   ecx = exponent
;   ST(0) = accumulator
cvtloop:
    cmp al, 'E'
    je doExponent
    cmp al, 'e'
    je doExponent
    .IF (al == '.')
    mov [decimal], ebx  ; remember decimal point location
    .ELSE
    sub al, '0'     ; convert ASCII to BCD
    jb sdFinish ; if not a digit
    cmp al, 9
    ja sdFinish ; if not a digit
    mov [temp], ax
    fmul [ten]      ; d *= 10
    fiadd [temp]        ; d += new digit
    inc ebx     ; increment digit counter
    .ENDIF
    inc esi
    mov al, [esi]
    jnz cvtloop
    jmp sdFinish
; We have the mantissa at the top of the stack.  Now convert the exponent.
; Fortunately, this is an integer.
;   esi = pointer to character in al
;   al = next character to convert
;   ebx = digit counter
;   ecx = accumulated exponent
;   ST(0) = mantissa
doExponent:
    inc esi
    mov al, [esi]
    cmp al, 0
    jz sdFinish
    ; Does the exponent have a sign?
    .IF (al == '+')
    inc esi
    mov al, [esi]
    .ELSEIF (al == '-')
    inc esi
    mov [expsign], 1
    mov al, [esi]
    .ENDIF
    cmp al, 0
    jz sdFinish
expLoop:
    sub al, '0'
    jb sdFinish
    cmp al, 9
    ja sdFinish
    imul ecx, 10
    add ecx, eax
    inc esi
    mov al, [esi]
    jnz expLoop
; Adjust the exponent to account for decimal places.  At this juncture, 
; we work with the absolute value of the exponent.  That means we need
; to subtract the adjustment if the exponent will be negative, add if
; the exponent will be positive.
;  ST(0) = mantissa
;  ecx = unadjusted exponent
;  ebx = total number of digits
sdFinish:
    .IF ([expsign] != 0)
    neg ecx
    .ENDIF
    mov eax, [decimal]
    .IF (eax != -1)
    sub ebx, eax    ; ebx = digits to right of decimal place
    sub ecx, ebx    ; adjust exponent
    .ENDIF
; Multiply by 10^exponent.
;  ST(0) = mantissa
;  ecx = exponent
    mov eax, ecx
    call PowerOf10
; Negate the whole thing, if necessary.
    .IF ([sign] != 0)
    fchs
    .ENDIF
; That's it!  Store it and go home.
    mov edi, [fpout]
    fstp qword ptr [edi]    ; store the reslt
    fwait
sdExit:    fldcw [stat]
    mov eax, esi    ; return pt to next unread char
    ret
StrToFloat  ENDP
; Convert a floating point register to ASCII.  For internal use.
; The result always has exactly 18 digits, with zero padding on the
; left if required.
; Entry:    ST(0) = a number to convert, 0 <= ST(0) < 1E19.
;       szTemp = an 18-character buffer.
; Exit:     szTemp = the converted result.
FloatToBCD  PROC    public uses esi edi
    sub esp, 10
    ; The fbstp instruction converts the top of the stack to a
    ; packed BCD form in ten bytes, with two digits per byte.  The top 
    ; byte has the sign, which we ignore.
    fbstp [esp]
    ; Now we need to unpack the BCD to ASCII.
    lea esi, [esp+8]
    lea edi, [szTemp]
    mov ecx, 9
    .REPEAT
    mov al, [esi]          ; xxxx xxxx AAAA BBBB
    dec esi
    rol ax, 12             ; BBBB xxxx xxxx AAAA
    rol ah, 4              ; xxxx BBBB xxxx AAAA
    and ax, 0f0fh          ; 0000 BBBB 0000 AAAA
    add ax, 3030h          ; 3B3A
    mov [edi], ax
    add edi, 2
    dec ecx
    .UNTIL ZERO?
    add esp, 10
    ret
FloatToBCD  ENDP
; Convert a double precision number to a string.
; Entry:    fpin = 8-byte double to convert
;       szDbl = character buffer
; Exit:     szDbl = converted value
; szDbl should be at least 19 bytes long.
FloatToStr  PROC    stdcall public USES esi edi, fpin: QWORD, szDbl: PTR CHAR
    LOCAL   iExp: DWORD
    LOCAL   stat: WORD
    LOCAL   mystat: WORD
; Special case zero.  fxtract fails for zero.   
    mov edi, [szDbl]
    .if (dword ptr [fpin] == 0) && (dword ptr [fpin][4] == 0)
      mov byte ptr [edi], '0'
      mov byte ptr [edi][1], 0
      ret
    .endif
; Check for a negative number.
    .if (sdword ptr [fpin][4] < 0)
      and byte ptr [fpin][7], 07fh  ; change to positive
      mov byte ptr [edi], '-'       ; store a minus sign
      inc edi
    .endif
; Initialize the floating point unit and load our value onto the stack.
    fclex
    fstcw [stat]
    mov [mystat], 027fh
    fldcw [mystat]
    fld [fpin]
    fld st(0)
; Compute the closest power of 10 below the number.  We can't get an
; exact value because of rounding.  We could get close by adding in
; log10(mantissa), but it still wouldn't be exact.  Since we'll have to
; check the result anyway, it's silly to waste cycles worrying about
; the mantissa.
; The exponent is basically log2(fpin).  Those of you who remember
; algebra realize that log2(fpin) x log10(2) = log10(fpin), which is
; what we want.
    fxtract         ; ST=> mantissa, exponent, fpin
    fstp st(0)          ; drop the mantissa
    fldlg2          ; push log10(2)
    fmulp st(1), st     ; ST = log10(fpin), fpin
    fistp [iExp]        ; ST = fpin
; An 8-byte double can carry almost 16 digits of precision.  Actually, it's
; 15.9 digits, so some numbers close to 1E17 will be wrong in the bottom
; digit.  If this is a concern, change the '16' to a '15'.
; A 10-byte double can carry almost 19 digits, but fbstp only stores the
; guaranteed 18.  If you're doing 10-byte doubles, change the '16' to '18'.
    .IF ([iExp] < 16)
      fld st(0)         ; ST = fpin, fpin
      frndint           ; ST = int(fpin), fpin
      fcomp st(1)       ; ST = fpin, status set
      fstsw ax
      .IF (ah & FP_EQUALTO) ; if EQUAL
; We have an integer!  Lucky day.  Go convert it into a temp buffer.
    call FloatToBCD
    mov eax, 17
    mov ecx, [iExp]
    sub eax, ecx
    inc ecx
    lea esi, [szTemp][eax]
; The off-by-one order of magnitude problem below can hit us here.  
; We just trim off the possible leading zero.
    .IF (byte ptr [esi] == '0')
      inc esi
      dec ecx
    .ENDIF
; Copy the rest of the converted BCD value to our buffer.
    rep movsb
    jmp ftsExit
      .ENDIF
    .ENDIF
; We use the format [-]d.ddddddE+ddd.  That means we only need a maximum
; of 7 decimal places.  Let's have fbstp do our rounding for us.
    mov eax, 6
    sub eax, [iExp] ; adjust exponent to 7
    call PowerOf10
; Either we have exactly 7 digits, or we have exactly 6 digits.  We can
; detect that condition and adjust now.
    fcom [ten7]
    ; x0xxxx00 means top of stack > ten7
    ; x0xxxx01 means top of stack < ten7
    ; x1xxxx00 means top of stack = ten7
    fstsw ax
    .IF (ah & 1)
      fmul [ten]
      dec iExp
    .ENDIF
; Go convert to BCD.
    call FloatToBCD
    lea esi, [szTemp+11]    ; point to converted buffer
; If the exponent is between -1 and 6, we can express this as a number
; without scientific notation.
    mov ecx, iExp
    .IF (SDWORD PTR ecx >= -1) && (SDWORD PTR ecx <= 6)
; We need to copy ecx+1 digits, then a decimal point (maybe), then 
; the remaining 6-ecx digits.  If exponent is 0, add a leading 0.
      .IF (SDWORD PTR ecx == -1)
    mov byte ptr [edi], '0'
    inc edi
      .ENDIF
      inc ecx
      rep movsb
      mov byte ptr [edi], '.'
      inc edi
      mov ecx, 6
      sub ecx, [iExp]
      rep movsb
; Trim off trailing zeros.
      .WHILE (byte ptr [edi-1] == '0')
    dec edi
      .ENDW
; If we cleared out all the decimal digits, kill the decimal point, too.
      .IF (byte ptr [edi-1] == '.')
    dec edi
      .ENDIF
; That's it.
      jmp ftsExit
    .ENDIF
; Now convert this to a standard, usable format.  If needed, a minus
; sign is already present in the outgoing buffer, and edi already points
; past it.
    movsb               ; copy the first digit
    mov byte ptr [edi], '.'     ; plop in a decimal point
    inc edi
    movsd               ; copy four more digits
    movsw               ; copy two more digits
if 0
; The printf %g specified trims off trailing zeros here.  I dislike
; this, so I've disabled it.  Comment out the if 0 and endif if you
; want this.
    .WHILE (byte ptr [edi][-1] == '0')
      dec edi
    .ENDW
endif
; Shove in the exponent.  If you support 10-byte reals, remember to
; allow 4 digits for the exponent.
    mov byte ptr [edi], 'e' ; start the exponent
    mov eax, [iExp]
    .IF (sdword ptr eax < 0)    ; plop in the exponent sign
      mov byte ptr [edi][1], '-'
      neg eax
    .ELSE
      mov byte ptr [edi][1], '+'
    .ENDIF
    mov ecx, 10
    xor edx, edx
    div ecx
    add dl, '0'
    mov [edi][4], dl    ; shove in the ones exponent digit
    xor edx, edx
    div ecx
    add dl, '0'
    mov [edi][3], dl    ; shove in the tens exponent digit
    xor edx, edx
    div ecx
    add dl, '0'
    mov [edi][2], dl    ; shove in the hundreds exponent digit
    add edi, 5      ; point to terminator
; Clean up and go home.
ftsExit:    mov byte ptr [edi], 0
    fldcw [stat]        ; restore control word
    fwait
    ret
FloatToStr  ENDP
FloatToBCD2 PROC    public uses esi edi
    sub esp, 10
    ; The fbstp instruction converts the top of the stack to a
    ; packed BCD form in ten bytes, with two digits per byte.  The top 
    ; byte has the sign, which we ignore.
    fbstp [esp]
    ; Now we need to unpack the BCD to ASCII.
    lea esi, [esp+8]
    lea edi, [szTemp]
    mov ecx, 9
    .REPEAT
    mov al, [esi]       ; xxxx xxxx AAAA BBBB
    dec esi
    rol ax, 12      ; BBBB xxxx xxxx AAAA
    rol ah, 4       ; xxxx BBBB xxxx AAAA
    and ax, 0f0fh       ; 0000 BBBB 0000 AAAA
    add ax, 3030h       ; 3B3A
    mov [edi], ax
    add edi, 2
    dec ecx
    .UNTIL ZERO?
    add esp, 10
    ret
FloatToBCD2 ENDP
; Convert a double precision number to a string.
; Entry:    fpin = 8-byte double to convert
;       szDbl = character buffer
; Exit:     szDbl = converted value
; szDbl should be at least 19 bytes long.
FloatToStr2 PROC    stdcall public USES esi edi, fpin: QWORD, szDbl: PTR CHAR
    LOCAL   iExp: DWORD
    LOCAL   stat: WORD
    LOCAL   mystat: WORD
; Special case zero.  fxtract fails for zero.   
    mov edi, [szDbl]
    .if (dword ptr [fpin] == 0) && (dword ptr [fpin][4] == 0)
      mov byte ptr [edi], '0'
      mov byte ptr [edi][1], 0
      ret
    .endif
; Check for a negative number.
    .if (sdword ptr [fpin][4] < 0)
      and byte ptr [fpin][7], 07fh  ; change to positive
      mov byte ptr [edi], '-'       ; store a minus sign
      inc edi
    .endif
; Initialize the floating point unit and load our value onto the stack.
    fclex
    fstcw [stat]
    mov [mystat], 027fh
    fldcw [mystat]
    fld [fpin]
    fld st(0)
; Compute the closest power of 10 below the number.  We can't get an
; exact value because of rounding.  We could get close by adding in
; log10(mantissa), but it still wouldn't be exact.  Since we'll have to
; check the result anyway, it's silly to waste cycles worrying about
; the mantissa.
; The exponent is basically log2(fpin).  Those of you who remember
; algebra realize that log2(fpin) x log10(2) = log10(fpin), which is
; what we want.
    fxtract         ; ST=> mantissa, exponent, fpin
    fstp st(0)          ; drop the mantissa
    fldlg2          ; push log10(2)
    fmulp st(1), st     ; ST = log10(fpin), fpin
    fistp [iExp]        ; ST = fpin
; An 8-byte double can carry almost 16 digits of precision.  Actually, it's
; 15.9 digits, so some numbers close to 1E17 will be wrong in the bottom
; digit.  If this is a concern, change the '16' to a '15'.
; A 10-byte double can carry almost 19 digits, but fbstp only stores the
; guaranteed 18.  If you're doing 10-byte doubles, change the '16' to '18'.
    .IF ([iExp] < 16)
      fld st(0)         ; ST = fpin, fpin
      frndint           ; ST = int(fpin), fpin
      fcomp st(1)       ; ST = fpin, status set
      fstsw ax
      .IF (ah & FP_EQUALTO) ; if EQUAL
; We have an integer!  Lucky day.  Go convert it into a temp buffer.
    call FloatToBCD2
    mov eax, 17
    mov ecx, [iExp]
    sub eax, ecx
    inc ecx
    lea esi, [szTemp][eax]
; The off-by-one order of magnitude problem below can hit us here.  
; We just trim off the possible leading zero.
    .IF (byte ptr [esi] == '0')
      inc esi
      dec ecx
    .ENDIF
; Copy the rest of the converted BCD value to our buffer.
    rep movsb
    jmp ftsExit
      .ENDIF
    .ENDIF
; Have fbstp round to 17 places.
    mov eax, 16; experiment
    sub eax, [iExp] ; adjust exponent to 17
    call PowerOf10
; Either we have exactly 17 digits, or we have exactly 16 digits.  We can
; detect that condition and adjust now.
    fcom [ten16]
    ; x0xxxx00 means top of stack > ten16
    ; x0xxxx01 means top of stack < ten16
    ; x1xxxx00 means top of stack = ten16
    fstsw ax
    .IF (ah & 1)
      fmul [ten]
      dec iExp
    .ENDIF
; Go convert to BCD.
    call FloatToBCD2
    lea esi, [szTemp+1]     ; point to converted buffer
; If the exponent is between -15 and 16, we should express this as a number
; without scientific notation.
    mov ecx, iExp
    .IF (SDWORD PTR ecx >= -15) && (SDWORD PTR ecx <= 16)
; If the exponent is less than zero, we insert '0.', then -ecx
; leading zeros, then 16 digits of mantissa.  If the exponent is
; positive, we copy ecx+1 digits, then a decimal point (maybe), then 
; the remaining 16-ecx digits.
      inc ecx
      .IF (SDWORD PTR ecx <= 0)
        mov word ptr [edi], '.0'
    add edi, 2
    neg ecx
    mov al, '0'
    rep stosb
    mov ecx, 16
      .ELSE
        rep movsb
        mov byte ptr [edi], '.'
        inc edi
        mov ecx, 16
        sub ecx, [iExp]
      .ENDIF
      rep movsb
; Trim off trailing zeros.
      .WHILE (byte ptr [edi-1] == '0')
    dec edi
      .ENDW
; If we cleared out all the decimal digits, kill the decimal point, too.
      .IF (byte ptr [edi-1] == '.')
    dec edi
      .ENDIF
; That's it.
      jmp ftsExit
    .ENDIF
; Now convert this to a standard, usable format.  If needed, a minus
; sign is already present in the outgoing buffer, and edi already points
; past it.
    movsb               ; copy the first digit
    mov byte ptr [edi], '.'     ; plop in a decimal point
    inc edi
    movsd               ; copy four more digits
    movsw               ; copy two more digits
if 0
; The printf %g specified trims off trailing zeros here.  I dislike
; this, so I've disabled it.  Comment out the if 0 and endif if you
; want this.
    .WHILE (byte ptr [edi][-1] == '0')
      dec edi
    .ENDW
endif
; Shove in the exponent.  If you support 10-byte reals, remember to
; allow 4 digits for the exponent.
    mov byte ptr [edi], 'e' ; start the exponent
    mov eax, [iExp]
    .IF (sdword ptr eax < 0)    ; plop in the exponent sign
      mov byte ptr [edi][1], '-'
      neg eax
    .ELSE
      mov byte ptr [edi][1], '+'
    .ENDIF
    mov ecx, 10
    xor edx, edx
    div ecx
    add dl, '0'
    mov [edi][4], dl    ; shove in the ones exponent digit
    xor edx, edx
    div ecx
    add dl, '0'
    mov [edi][3], dl    ; shove in the tens exponent digit
    xor edx, edx
    div ecx
    add dl, '0'
    mov [edi][2], dl    ; shove in the hundreds exponent digit
    add edi, 5      ; point to terminator
; Clean up and go home.
ftsExit:    mov byte ptr [edi], 0
    fldcw [stat]        ; restore control word
    fwait
    ret
FloatToStr2 ENDP
end start

    string db '1234'
    float dq 0
    ...
    invoke StrToFloat, addr string, addr float  
       ;преобразованное число будет записано во float, а также в st(7)

StrToFloat      PROC    stdcall public, szIn: PTR BYTE, fpout: PTR QWORD

FloatToStr  proto stdcall fpin:QWORD, szDbl:PTR CHAR

.data
fnum  dq 123456789.123456789
buf db 20 dup(0)
.code
start:
invoke FloatToStr, qword ptr[fnum], addr buf