amodf386.asm

来自「开放源码的编译器open watcom 1.6.0版的源代码」· 汇编 代码 · 共 238 行

;*****************************************************************************
;*
;*                            Open Watcom Project
;*
;*    Portions Copyright (c) 1983-2002 Sybase, Inc. All Rights Reserved.
;*
;*  ========================================================================
;*
;*    This file contains Original Code and/or Modifications of Original
;*    Code as defined in and that are subject to the Sybase Open Watcom
;*    Public License version 1.0 (the 'License'). You may not use this file
;*    except in compliance with the License. BY USING THIS FILE YOU AGREE TO
;*    ALL TERMS AND CONDITIONS OF THE LICENSE. A copy of the License is
;*    provided with the Original Code and Modifications, and is also
;*    available at www.sybase.com/developer/opensource.
;*
;*    The Original Code and all software distributed under the License are
;*    distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
;*    EXPRESS OR IMPLIED, AND SYBASE AND ALL CONTRIBUTORS HEREBY DISCLAIM
;*    ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF
;*    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR
;*    NON-INFRINGEMENT. Please see the License for the specific language
;*    governing rights and limitations under the License.
;*
;*  ========================================================================
;*
;* Description:  WHEN YOU FIGURE OUT WHAT THIS FILE DOES, PLEASE
;*               DESCRIBE IT HERE!
;*
;*****************************************************************************


;       double modf( double value, double *iptr );
;
; Description:
;   The modf function breaks the argument value into integral and
;   fractional parts, each of which has the same sign as the argument.
;   It stores the integral part as a double in the object pointed to
;   by iptr.
;
; Returns:
;   The modf function returns the signed fractional part of value.
;
;  18-oct-86    ...             Fraction in Modf not computed right
;                               significant digits
;
include mdef.inc
include struct.inc

        modstart        amodf386

        xdefp   __ModF
        xdefp   __ZBuf2F

;[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]
;[]
;[] __ModF
;[]
;[]     void __ModF( double near *AX, double near *DX );
;[]     Input:  EAX         - pointer to double precision float
;[]             EDX         - place to store integral part
;[]     Output: [EAX]       - fractional part of value.
;[]             [EDX]       - integral part of value
;[]
;[][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][][]

        defpe   __ModF
        push    EBP             ; save BP
        push    ESI             ; save SI
        push    EDI             ; save DI
        push    ECX             ; save CX
        push    EBX             ; save BX
        mov     ESI,EDX         ; get address for ipart
        mov     EBP,EAX         ; get address of float
        mov     EAX,0[EBP]      ; get float
        mov     EDX,4[EBP]      ; . . .
        xchg    ESI,EBP         ; flip pointers
        mov     0[EBP],EAX      ; store integral part of value
        mov     4[EBP],EDX      ; . . .
        _guess                  ; guess: fraction is zero
          mov   ECX,EDX         ; - get exponent
          and   ECX,7FF00000h   ; - get exponent part of R into DI
          je    short done      ; - set integer part to 0 if exponent = 0
          cmp ECX,(3FFh+52) shl 20; - check for exponent > 52
          _quif b               ; - quit if fraction not zero
          xchg  EBP,ESI         ; - get address of fractional part
done:     sub   EAX,EAX         ; - set fraction(or integer) to 0
          mov   4[EBP],EAX      ; - . . .
          mov   0[EBP],EAX      ; - . . .
          pop   EBX             ; - restore BX
          pop   ECX             ; - restore CX
          pop   EDI             ; - restore DI
          pop   ESI             ; - restore SI
          pop   EBP             ; - restore BP
          ret                   ; - return
        _endguess               ; endguess
        mov     EDI,ECX         ; save exponent
        shr     ECX,20          ; move exponent to bottom
        sub     CX,03FFh        ; remove bias
        jb      done            ; quit if number < 1.0
        push    EDX             ; save sign
        sub     EAX,EAX         ; initialize mask to 0
        mov     EDX,0FFF00000h  ; ...
        cmp     CL,20           ; if exponent > 20
        _if     a               ; then
          sar   EDX,21          ; - set ESI to all ones
          rcr   EAX,1           ; - set high bit of EBX
          sub   CL,21           ; - get shift count for second part
          sar   EAX,CL          ; - create rest of mask
        _else                   ; else
          sar   EDX,CL          ; - create mask in high part only
        _endif                  ; endif
        and     4[EBP],EDX      ; mask off the remaining fraction bits
        and     0[EBP],EAX      ; . . .
        not     EDX             ; complement the mask to get fractional part
        not     EAX             ; . . .
        mov     EBP,ESI         ; get address of fractional part
        and     EDX,4[EBP]      ; get fraction bits
        and     EAX,0[EBP]      ; . . .
        call    Norm            ; normalize the fraction
        pop     ESI             ; restore sign
        or      EDX,EDX         ; if fraction is not 0
        _if     ne              ; then
          and   ESI,80000000h   ; - isolate sign
          or    EDX,ESI         ; - set sign in fractional part
        _endif                  ; endif
        mov     4[EBP],EDX      ; store fractional part
        mov     0[EBP],EAX      ; . . .
        pop     EBX             ; restore BX
        pop     ECX             ; restore CX
        pop     EDI             ; restore DI
        pop     ESI             ; restore SI
        pop     EBP             ; restore BP
        ret                     ; return
        endproc __ModF


;<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>
;<>                                                                   <>
;<>   __ZBuf2F - convert buffer of significant digits into floating   <>
;<>             void __ZBuf2F( char near *buf, double near *value )   <>
;<>                                                                   <>
;<>   input:  EAX - address of buffer of significant digits           <>
;<>           EDX - place to store value                              <>
;<>   output: [EDX]        - floating point number                    <>
;<><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><><>

        defpe   __ZBuf2F
        push    EBP             ; save BP
        push    ESI             ; save SI
        push    EDI             ; save DI
        push    ECX             ; save CX
        push    EBX             ; save BX
        push    EDX             ; save pointer to result
        mov     ESI,EAX         ; get address of buffer
        sub     EDX,EDX         ; set 54-bit integer to 0
        sub     ECX,ECX         ; . . .
        sub     EAX,EAX         ; zero out EAX
        _loop                   ; loop (convert digits into 54-bit int)
          mov   AL,[ESI]        ; - get next digit
          cmp   AL,0            ; - quit if at end of buffer
          _quif e               ; - . . .

;[]  multiply current value in EDX:ECX by 10

          mov   EDI,EDX         ; - save current value
          mov   EBX,ECX         ; - ...
          _shl  ECX,1           ; - multiply number by 4
          _rcl  EDX,1           ; -   by shifting left 2 places
          _shl  ECX,1           ; - . . .
          _rcl  EDX,1           ; - . . .
          add   ECX,EBX         ; - add original value
          adc   EDX,EDI         ; -  (this will make it times 5)
          _shl  ECX,1           ; - shift left to make it times 10
          _rcl  EDX,1           ; - . . .
          and   AL,0Fh          ; - isolate binary digit
          add   ECX,EAX         ; - add in current digit
          adc   EDX,0           ; - . . .
          inc   ESI             ; - point to next digit in buffer
        _endloop                ; endloop
        mov     EAX,ECX         ; get low order word into EAX

;[] Turn the integer in EDX:EAX into a real number

        mov     EDI,(3FFh+52) shl 20; set exponent
        call    Norm            ; convert the 52 bit integer to a float
        pop     EBP             ; restore pointer to result
        mov     4[EBP],EDX      ; store result
        mov     0[EBP],EAX      ; . . .
        pop     EBX             ; restore BX
        pop     ECX             ; restore CX
        pop     EDI             ; restore DI
        pop     ESI             ; restore SI
        pop     EBP             ; restore BP
        ret                     ; return to caller
        endproc __ZBuf2F


;[] Norm normalizes an unsigned real in EDX:EAX
;[] expects the exponent to be in EDI.  The real returned is in 'packed'
;[] format
;[]     ESI is destroyed

Norm    proc    near            ; normalize floating point number
        sub     ESI,ESI         ; clear out SI
        or      ESI,EAX         ; see if the integer is zero
        or      ESI,EDX         ; . . .
        je      short Z_52ret   ; if integer is zero, return to caller
        test    EDX,0FFF00000h  ; see if we have to shift forward or backward
        _if     e               ; if (we haven't shifted msb into bit 53)
          _loop                 ; - loop
            sub   EDI,00100000h ; - - exp <-- exp - 1
            _shl  EAX,1         ; - - shift integer left by 1 bit
            _rcl  EDX,1         ; - - . . .
            test  EDX,0FFF00000h;
          _until ne             ; - until( msb is shifted into bit 53 )
        _else                   ; else (we must shift to the right)
          test  EDX,0FFE00000h  ; -
          je    short done1     ; - if msb is bit 53, we are done
          _loop                 ; - loop
            add   EDI,00100000h ; - - exp <-- exp + 1
            shr   EDX,1         ; - - shift integer right by 1 bit
            rcr   EAX,1         ; - - . . .
            rcr   ESI,1         ; - - save lsb
            test  EDX,0FFE00000h; -
          _until e              ; - until( msb is bit 53 )
          _rcl  ESI,1           ; - get lsb
          adc   EAX,0           ; - and use it to round off the number
          adc   EDX,0           ; - . . .
        _endif                  ; endif
done1:  and     EDX,000FFFFFh   ; clear out implied bit
        or      EDX,EDI         ; put in exponent
Z_52ret:ret                     ; return
        endproc Norm

        endmod
        end