
 20. ਬ ᫨⥫쭮 ணࠬ஢
----------------------------------------------------------------


 ᫥饬 ࠧ ਢ ਬ ணࠬ ᫨⥫쭮
ࠪ   i486, ᠭ  ᥬ
ASM386/486.  ਬ    ਥ
 ࠧࠡ⪨ ᫨⥫ ணࠬ த⮢  ⥬ 
᭮  i486.

20.1 ਬ ᫮ ⢫
----------------------------------------------------------------

 㦥 㦤   15, ࠧ ᫮ 
    ᫮ ᫮ ﭨ
 ࠡ⪨ 権  饩 窮,  
⢮ ᯮᮡ  ⮣, ⮡ ॠ ᫮
⢫, ᫥饥  ࠢ.  ਢ ᭮
室:

- 믮 ࠢ.

- ࠭ ᫮ ﭨ. ( ﭨ  ࠡ⪨
  権  饩 窮  ࠭ אַ  ॣ
  AX.)

- ஢   ᫮.

- ३  १.

 㭪 20-1 ।⠢ ࠣ ணࠬ, 
,   ࠢ  室騥  
⢥ ᫠  ଠ ( ணࠬ 
 ᯮ짮   FTST). ᫠, 
ࠢ  ⮬ ࠣ,  A  B.

 ࠢ ॡ 㧪 ᫠ A  設
ॣ஢ ⥪  ࠡ⪨ 権  饩 窮,
 ⥬ ࠢ   ᫮ B, 믮  ⮬ 
⠭  ⥪. ᫥ 祣 ᫮ ﭨ 뢠
 ॣ AX.

A  B    浪,   C3, C2  C0 
᫮ 㪠뢠,    浪 ⠭.  
ᯮ  孥  ᫮ ﭨ  ࠡ⪨
権  饩 窮 ⠪, ⮡ ᮮ⢥⢮ 䫠
, ⭮  ७ (ZF, PF  CF),   뢠
 䫠.  ࠣ ணࠬ 䫠 ZF, PF  CF ॣ
EFLAGS ⠭  祭 ⮢ C3, C2  C0 ᫮
ﭨ,  ⥬ ᯮ  ᫮ 室 
⮣, ⮡ ஢ 䫠.  ணࠬ 祭
⭠  뢠 ᥣ   ᥬ .

 FXAM      ᫮.  㭪
20-2 ,  ⠡ 室   ᯮ짮 
⮣, ⮡ । ࠪ ᬮ७ 稭. 
室 (FXAM_TBL) ᮤন 16 ⮪,    
  ᫮.  ,   祭
ᮤঠ   ⮦ - "EMPTY" ().   祭 
᫮ ᮮ⢥ 樨 "EMPTY".  㣨 祭 
⠡,  ᮤঠ "EMPTY",    ᯮ짮
஬ i486  ⥬᪨ ᮯ஬ 387(TM), 
  ᯮ짮  믮 ணࠬ  ᮯ
80287.

Ŀ
                                                               
        .                                                      
        .                                                      
        .                                                      
  A     DQ     ?                                               
  B     DQ     ?                                               
        .                                                      
        .                                                      
        .                                                      
        FLD    A   ;  㦠 A  設 ⥪ FPU          
        FCOMP  B   ;  ࠢ A:B, ⠫ A            
        FSTSW  AX  ;  ࠭ १  ॣ AX        
  ;                                                            
  ;  ᫮ ᮤঠ  ॣ  AX                  
  ;     ( ࠢ)                                 
  ; 㧪  ᫮  䫠                            
  ;                                                            
        SAHF                                                   
  ;                                                            
  ; ᯮ ᫮ 室  ⮣, ⮡               
  ; ।  㯮冷祭 A  B                           
  ;                                                            
        JP  A_B_UNORDERED  ; ஢  C2 (PF)         
        JB  A_LESS         ; ஢  C0 (CF)         
        JE  A_EQUAL        ; ஢  C3 (ZF)         
  A_GREATHER:              ; C0 (CF) = 0, C3 (ZF) = 0          
        .                                                      
        .                                                      
  A_EQUAL:                 ; C0 (CF) = 0, C3 (ZF) = 1          
        .                                                      
        .                                                      
  A_LESS:                  ; C0 (CF) = 1, C3 (ZF) = 0          
        .                                                      
        .                                                      
  A_UNORDERED:             ; C2 (PF) = 1                       
        .                                                      
        .                                                      
                                                               
                                                               


         㭮 20-1. ᫮ ⢫  ࠢ

ࠣ ணࠬ 믮  FXAM  ࠭ ᫮
ﭨ. ⥬   ⠬  ᫮ 
⥫쭮 뢮 ᫠  ॣ AX, ஥ ࠢ 
᫮, 㬭  2.  ⮬ 砥 㫥
ᯮ㥬 ⮢  ,  ᮤন , ந室
ᤢ  C3 ࠢ ⠪, ⮡   ᥤ  ⮬ C2, 
⥬ ந室 ᤢ   ⮣, ⮡ 㬭   2.
祭 祭 ᯮ  ,  ஬
롨ࠥ   ⮪  ⠡ 室 FXAM TBL
(㬭  ᫮ ॡ - 2- ⭮ 
 祭  ⠡).  ᫮ 室 JMP
ࠢ  १ ⠡ 室  楤,
 ᮤন ணࠬ (   ਬ) 
ࠡ⪨   १  FXAM.

20.2 ਬ ࠡ⪨ ᪫祭
----------------------------------------------------------------

 ⢮ 室  ᠭ ࠡ稪
᪫⥫ 権.   ਥ -  ᤥ
楤 ࠡ⪨ ᪫祭   ⥩: "஫",
"⥫"  "".  楤 뢠 १ 뢠
 16.

Ŀ
                                                               
    ;  室  楤 ஢ન                 
    ;                                                          
    FXAM_TBL    DD POS_UNNORM, POS_NAN, NEG_UNNORM, NEG_NAN,   
    &           POS_NORM, POS_INFINITY, NEG_NORM,              
    &           NEG_INFINITY, POS_ZERO, EMPTY, NEG_ZERO,       
    &           EMPTY, POS_DENORM, EMPTY, NEG_DENORM, EMPTY    
         .                                                     
         .                                                     
    ; ஢ ST  ࠭ १ ( ᫮)        
    ;                                                          
         FXAM                                                  
         XOR   EAX, EAX   ;  ॣ EAX               
         FSTSW AX                                              
    ;                                                          
    ; ᫥ ᬥ饭  ⠡ 室                  
    ;                                                          
         AND   AX, 0100011100000000B  ;         
    ;                                   ஬ C3, C2-C0        
         SHR   EAX, 6   ;  C2-C0  (000XXX00)        
         SAL   AH, 5    ; ⠭ C3   (00X00000)        
         OR    AL, AH   ;  C3  C2-C0   (00XXXX00)        
         XOR   AH, AH   ;    C3              
    ;                                                          
    ; ३  楤   ᫮                      
    ;                                                          
         JMP   FXAM_TBL[EAX]                                   
    ;                                                          
    ; ⪨ ⠡ 室,    ࠡ⪨           
    ;   १ FXAM                       
    ;                                                          
    POS_UNNORM:                                                
        .                                                      
    POS_NAN:                                                   
        .                                                      
    NEG_UNNORM:                                                
        .                                                      
    NEG_NAN:                                                   
        .                                                      
    POS_NORM:                                                  
        .                                                      
    POS_INFINITY:                                              
       .                                                       
    NEG_NORM:                                                  
        .                                                      
    NEG_INFINITY:                                              
        .                                                      
    POS_ZERO:                                                  
        .                                                      
    EMPTY:                                                     
        .                                                      
    NEG_ZERO:                                                  
        .                                                      
    POS_DENORM:                                                
        .                                                      
    NEG_DENORM:                                                
        .                                                      
                                                               


       㭮 20-2. ᫮ ⢫  樨 FXAM

 । ࠢ  楤 ࠡ⪨ ᪫祭,
 뢠   ᯮᮡ. ஫
믮  㭪樨,    饭 
 뢠  ᮪ ਮ⮬. 筮 
࠭ ॣ஢  । ᪮ ଠ樨 
 ࠡ⪨ 権   窮  . 
᪨  㤥 襭, ஫  ࠧ
뢠  ⮣, ⮡  ࠡ稪 뢠 
 ᮪ ਮ⮬ 믮 ࠭ ࠡ稪
᪫祭.

 ࠡ稪 ᪫祭 ᬠਢ 
ଠ  ॠ  ,  室  窨 ७
ணࠬ த.  ॠ    
뢠 믮  ⮣, ⮡ 뤠 ᮮ饭, 
⪨ 㫠   த ଠ쭮 믮.

, ᮡ⢥, 믮 ⢨  ஫,
   ﭨ,  ஬  뫮 
 ଠ쭮 믮.    㦠
᪨஢ 䫠 ᪫祭   ࠡ⪨ 権 
饩 窮  ॡ  㣮
᪫⥫쭮 樨.

 㭪  㭪 20-3  㭪 20-5  ᪥
奬 室   ᥬ ASM386/486  ࠡ稪
᪫⥫ 権.  ⮬    
ᠭ ஫    ࠧ ,   , 
  饭 饥  ਬ ⥫ ࠡ稪
᪫祭,  ਨ.

Ŀ
                                                               
    SAVE_ALL        PROC                                       
    ;                                                          
    ; ࠭ ॣ,                               
    ; ⮡ࠦ ﭨ FPU  ⥪                         
    ;                                                          
       PUSH  EBP                                               
       MOV   EBP, ESP                                          
       SUB   ESP, 108                                          
    ;                                                          
    ; ࠭  ﭨ FPU, ࠧ 뢠     
    ;                                                          
       FNSAVE [EBP-108]                                        
       STI                                                     
    ;                                                          
    ;  ᫥ ணࠬ ࠡ稪 ᪫祭           
    ;  ᨬ  楫 ࠡ⪨                          
    ;                                                          
    ;  䫠 ᪫祭  ᫮ ﭨ              
    ; (஥ 室  )                             
    ; ⠭ ஢ ⮡ࠦ ﭨ      
    ;                                                          
       MOV     BYTE PTR [EBP-104], 0H                          
       FRSTOR  [EBP-108]                                       
    ;                                                          
    ; ᢮ ⥪, ⠭ ॣ                   
    ;                                                          
       MOVE  ESP, EBP                                          
         .                                                     
         .                                                     
       POP   EBP                                               
    ;                                                          
    ;   ࢠ ᫥                       
    ;                                                          
       IRET                                                    
    SAVE_ALL        ENDP                                       
                                                               


   㭮 20-3. ࠡ稪 ᪫祭  ﭨ

Ŀ
                                                               
    SAVE_ENVIRONMENT  PROC                                     
    ;                                                          
    ; ࠭ ॣ,                               
    ; 㦥 FPU  ⥪                                     
    ;                                                          
       PUSH  EBP                                               
                                                               
       MOV   EBP, ESP                                          
       SUB   ESP, 28                                           
    ;                                                          
    ; ࠭ 㦥 FPU, ࠧ 뢠            
    ;                                                          
       FNSTENV [EBP-28]                                        
       STI                                                     
    ;                                                          
    ;  ᫥ ணࠬ ࠡ稪 ᪫祭           
    ;  ᨬ  楫 ࠡ⪨                          
    ;                                                          
    ;  䫠 ᪫祭  ᫮ ﭨ              
    ; (஥ 室  )                             
    ; ⠭ ஢ ⮡ࠦ 㦥      
    ;                                                          
       MOV     BYTE PTR [EBP-24], 0H                           
       FLDENV  [EBP-28]                                        
    ;                                                          
    ; ᢮ ⥪, ⠭ ॣ                   
    ;                                                          
       MOVE  ESP, EBP                                          
       POP   EBP                                               
    ;                                                          
    ;   ࢠ ᫥                       
    ;                                                          
       IRET                                                    
    SAVE_ENVIRONMENT  ENDP                                     
                                                               


    㭮 20-4. ࠡ稪 ᪫祭 饭 ६
                  

  㭪 20-3  20-4 祭 宦;  ⫨稥
砥 ⮫쪮  롮   ࠭ 
⠭ ﭨ  ࠡ⪨ 権  饩
窮. 롮  砥  襭 ᪮
ଠ樨, ।⠢塞  FNSAVE,   
믮  FNSTENV.   ਫ, 
⢨⥫  ६  뢠    
ᬠਢ ᮤন ॣ஢,  FNSTENV ᮪頥
த⥫쭮 "᪮ ",  祭 ன
   ॡ 㣨 뢠.

᫥ 믮 ⥫ ࠡ稪 ᪫祭, 
ਣ⠢   ⮣, ⮡ த 믮
 窨 뢠 ( , , ᫥饩  ⮩, 
ᮧ ᪨஢ ᪫祭).  , 
䫠 ᪫祭  ,  㦠  
ࠡ⪨ 権  饩 窮,    
१㧪 (䠪᪨,   ਬ  
⮡ࠦ ᫮ ﭨ).

ਬ  㭪 20-3  20-4 ।,  ᠬ ࠡ稪
᪫祭  㤥 稭 㣮 ᪨㥬 ᪫祭.
,   ,  ਬ 騩 室, 
 㭪 20-5. ᭮ ਥ - ࠭  ﭨ
 ࠡ⪨ 権  饩 窮  ⥬ 㧨
 ࠢ饥 ᫮  ஫. 頥    ,
   祭 ஦  ࠧࠡ⪥ ࠡ稪
᪫祭 ⮣ ⨯  ⮣, ⮡ 㡥 ࠡ稪 
᪮ 饭.

Ŀ
                                                               
            .                                                  
            .                                                  
            .                                                  
        LOCAL_CONTROL  DW  ?   ; 樠஢              
            .                                                  
            .                                                  
            .                                                  
    REENTRANT       PROC                                       
    ;                                                          
    ; ࠭ ॣ,                               
    ; ⮡ࠦ ﭨ FPU  ⥪                         
    ;                                                          
       PUSH  EBP                                               
         .                                                     
         .                                                     
         .                                                     
       MOV   EBP, ESP                                          
       SUB   ESP, 108                                          
    ;                                                          
    ; ࠭  ﭨ FPU, 㧨           
    ; ࠢ饥 ᫮, ࠧ 뢠                  
    ;                                                          
       FNSAVE [EBP-108]                                        
       FLDCW  LOCAL_CONTROL                                    
       STI                                                     
         .                                                     
         .                                                     
         .                                                     
    ;                                                          
    ;  ᫥ ணࠬ ࠡ稪 ᪫祭           
    ;  ᨬ  楫 ࠡ⪨                          
    ; 㥬  ᪨஢ ᪫祭            
    ; 㤥 稭 맮 ࠡ稪 ᪫祭.            
    ; ᫨ 室 쭠 ,                 
    ; ᯮ   ⥪.                              
         .                                                     
         .                                                     
         .                                                     
    ;  䫠 ᪫祭  ᫮ ﭨ              
    ; (஥ 室  )                             
    ; ⠭ ஢ ⮡ࠦ ﭨ      
    ;                                                          
       MOV     BYTE PTR [EBP-104], 0H                          
       FRSTOR  [EBP-108]                                       
    ;                                                          
    ; ᢮ ⥪, ⠭ ॣ                   
    ;                                                          
       MOVE  ESP, EBP                                          
         .                                                     
         .                                                     
       POP   EBP                                               
    ;                                                          
    ;   ,  ந諮 뢠              
    ;                                                          
       IRET                                                    
    REENTRANT       ENDP                                       
                                                               


      㭮 20-5. ࠡ ࠡ稪 ᪫祭


20.3 ਬ ॢ ᫠  饩 窮  ᨬ 
----------------------------------------------------------------

᫨⥫ ணࠬ  ନ஢ ᢮ १ 
⮣, ⮡  뫨 ਭ  ⠥ 짮⥫
ணࠬ.  設⢥ 砥, ᫮ १ 뢮
 ப ᨬ ASCII  ⮣, ⮡   뫮
⯥  ᬮ  ᯫ.  ਬ 뢠,
 稭  饩 窮   ॢ 
 ப ASCII ᨬ. 㭪,  
㭪 20-6,   맢  ணࠬ  몠
PL/M-386/486, Pascal386/486, FORTRAN-386/486  ASM386/486.

 ᠭ ணࠬ 頫  ᪮॥ 
⪮, ᪮  筮 믮, 祬  ᨬ
᫠  .  ⪠ ⠢ 楫  
ᮡ⢥   ⮣, ⮡ । 砩
訡  ॢ ᥫ.

ᯮ ᫠  ⢥ ଠ ७ 筮, 
ணࠬ ⨣  襬 砥 筮   
16-⮬ 筮 ࠧ拉  楫᫥ 稭 
楫 ᥫ,  祬 10**(18).   筮. ᫨
᫮   冷, 訩 祬 100, 筮
⠢    17-⮬ 筮 ࠧ拉.

 ᮪ 筮   ⨣  
  ணࠬ஢, 㢥祭 ࠧ ணࠬ 
 䥪⨢.

20.3.1 ⠢騥  㭪樨
----------------------------------------------------------------

ॢ ᥫ ॠ ६ ⤥묨 ﬨ. 
ࠡ 믮塞  FLOATING TO ASCII (᫮  饩
窮  ASCII-ப). 㣨 㫨 ।⠢ ⤥쭮,
⮬     饥 祭.   , GET
POWER 10 ( ⥯ 10-), ᯮ ⠪ 
ணࠬ ॢ ᥫ  ASCII   ଠ  饩
窮. 㣮 쪨 , TOP STATUS (ﭨ 設
⥪),  ,  室  設 ᫮
ॣ஢ ⥪.

20.3.2 襭  ᪫祭
----------------------------------------------------------------

室 । 㭪  ஢  
᪫⥫ 権. ਭ  ᫮ 祭,
 ⮬ ⮫쪮  ᪫祭  ⥪ ᫮
ॣ஢.

 祭, ᫠  ᫮ ⥪, ஢ 
⢮, ⨯ (NaN  ᪮筮)  ﭨ
(ଠ쭮, , ).  ப  
쭮  ᨬ쭮 祭. ᫨ 設 ॣ஢
⥪   ࠧ ப ᫨誮 , 㭪 頥
 訡.

९  ⥫쭮 ९  祭  
祭 쪨 ᫠ ।  㭪樨.

㭮 20-6. ணࠬ ॢ ᥫ  饩 窮 
              ASCII 
Ŀ
                                                                         
                                                                         
  SOURCE                                                                 
                                                                         
  +1 $title('ॢ ᫠  饩 窮  ASCII ')              
                                                                         
                                                                         
       name    floating_to_ascii                                         
                                                                         
       public  floating_to_ascii                                         
       extrn   get_power_10:near, tos_status:near                        
  ;                                                                      
  ;  ணࠬ ॢ ᫮  饩 窮                  
  ;  設 ⥪ FPU  ப ⨯ ASCII  ⤥                  
  ; ⥯ 10, ⠡ 祭 ( 筮 ).                  
  ; ᨬ쭠  ப ᨬ ॣ㫨                      
  ; ࠬ஬,     1.                            
  ; -ଠ 祭, ଠ 祭  ᥢ               
  ; -㫨 ॢ ४⭮. , -ଠ                   
  ; 稭  ᥢ-㫨   ন                       
  ; ஬ i486 ( ᮮ⢥⢨  ⠭⮬ IEEE)                
  ; ७  . 頥 祭                     
  ; 㪠뢠 ᪮쪮  ࠧ冷 筮 뫮                    
  ; ﭮ  -ଠ  ଠ 祭.                 
  ;  㪠뢠  稭  ᥢ-                    
  ; ( 浪).  ᫠ 訥 10**18                      
  ; ॢ 筮, ᫨ ਭ ப ASCII                     
  ; ᨬ ᮤন 筮 ⢮ 権                  
  ;   ᥫ.  ⨢ 砥 祭                         
  ; ॢ   .                                      
  ;                                                                      
  ;  ᨬ  १ ணࠬ 뤠                      
  ; ᫥騥 祭:                                                  
  ;                                                                      
  ;       0  ॢ 믮, ࠧ ப ।                   
  ;       1  ⨬ 㬥                                      
  ;       2   楫᫥ ॢ, ࠧ ப                 
  ;            ।                                                 
  ;       3  ।                                            
  ;       4  + NaN (-᫮)                                            
  ;       5  - NaN                                                       
  ;       6  + ᪮筮                                             
  ;       7  - ᪮筮                                             
  ;       8  祭 ᥢ-, ࠧ ப ।               
  ;                                                                      
  ;    䥩  맮  PLM-386/486                               
  ;                                                                      
  ; floating_to_ascii:                                                   
  ;   procedure (number, denormal_ptr, string_ptr, size_ptr,             
  ;   field_size, power_ptr) word external;                              
  ;   declare (denormal_ptr, string_ptr, power_ptr, size_ptr)            
  ;   pointer;                                                           
  ;   declare field_size word;                                           
  ;   string_size based size_ptr word;                                   
  ;   declare number real;                                               
  ;   declare denormal integer based denormal_ptr;                       
  ;                                                                      
                                                                         
  ; declare power integer based power_ptr;                               
  ; end floating_to_ascii;                                               
  ;                                                                      
  ; 稭  饩 窮    設                   
  ; ⥪ FPU.  ணࠬ ॡ  ᢮                    
  ; ॣ  ⥪  ᫥ ࠡ⪨ ⠫                       
  ; । 祭  ⥪. 祭 ப                    
  ; 㤥  砫 ᨬ  "+",  "-",                     
  ; 㪠뢠   稭. ⥬ ᫥                   
  ;   ASCII . ᫮ 祭 ப ⨯                    
  ; ASCII 㤥 ࠢ (ASCII )*10**. ᫨                   
  ;  ᫮ 뫮 㫥,  ப 㤥 ᮤঠ                   
  ; ⮫쪮    ᨬ 0. 稭 ࠧ ப                 
  ; (string_size) 㪠뢠    ப ᨬ,             
  ;  ᨬ . ப (0) ᥣ 㤥                        
  ; ᮤঠ . ,  ࠧ ப 㤥                    
  ;  ࠧ .  뢠    楫                    
  ; ᫠. ᥢ- 뤠 ᮡ  .                   
  ; ଠ ᫠ 㪠뢠 ⥯                          
  ; ।⠢ 祭. ⥯   ப               
  ; ⠪ ,  ᫨  稭 뫠   㫥.               
  ;                                                                      
  ;  ணࠬ 筮 뤠  楫  18                 
  ; .  稭   ⥫                     
  ; ⥯  ப  㫥.  楫 稭                     
  ; 筮 १ 祭   ᫥                       
  ;   ( 筮).                             
  ; ⠡஢ 稭  , ਥ                  
  ;  ⨯ BCD, ᯮ                      
  ; ⥯.  ॢ ᯮ ० 㣫,                 
  ; 騩  室  ணࠬ.                                
  ;                                                                      
  ;       騥 ॣ  :                                   
  ;                                                                      
  ;      eax ebx ecx edx esi edi eflags                                  
  ;                                                                      
  ; । ⥪.                                                   
  ;                                                                      
  ebp_save       equ     dword ptr [ebp]                                 
  es_save        equ     ebp_save + size ebp_save                        
  return_ptr     equ     es_save + size es_save                          
  power_ptr      equ     return_ptr + size return_ptr                    
  field_size     equ     power_ptr + size power_ptr                      
  size_ptr       equ     field_size + size size_ptr                      
  string_ptr     equ     size_ptr + size size_ptr                        
  denormal_ptr   equ     string_ptr + size string_ptr                    
                                                                         
  parms_size     equ     size power_ptr + size field_size +              
  &              size    size_ptr + size string_ptr +                    
  &              size    denormal_ptr                                    
  ;                                                                      
  ; । ᯮ㥬 ⠭.                                   
  ;                                                                      
  BCD_DIGITS   equ  18  ; ⢮   稭 ⨯ BCD            
  WORD_SIZE    equ  4                                                    
  BCD_SIZE     equ  10                                                   
  MINUS        equ  1   ; । 뤠 祭                
  NAN          equ  4   ; ࠭   稭 -               
  INFINITY     equ  6   ; .   ᮮ⢥⢮              
  INDEFINITE   equ  3   ;  뤠 祭                
  PSEUDO_ZERO  equ  8   ; ஢  ⮬  浪,             
  INVALID      equ  -2  ;   ⮩ ணࠬ.                     
  ZERO         equ  -4                                                   
  DENORMAL     equ  -6                                                   
  UNNORMAL     equ  -8                                                   
  NORMAL       equ  0                                                    
  EXACT        equ  2                                                    
  ;                                                                      
  ;       ।  ६  ࠭.              
  ;                                                                      
  power_two    equ  word ptr [ebp - WORD_SIZE]                           
  bcd_value    equ  tbyte ptr power_two - BCD_SIZE                       
  bcd-byte     equ  byte ptr bcd_value                                   
  fraction     equ  bcd_value                                            
                                                                         
  lokal_size   equ  size power_two + size bcd_value                      
  ;                                                                      
  ;      뤥  ꥬ ⥪                             
  ;      ६ १⮢.                                          
  ;                                                                      
  stack  stackseg (lokal_size+6) ; 뤥 ࠭⢮ ⥪           
                                 ;   .                 
  +1 $eject                                                              
                                                                         
  code         segment public er                                         
               extrn   power_table:qword                                 
  ;                                                                      
  ;      ⠭, ᯮ㥬 ⮩ 㭪樥.                          
  ;                                                                      
               even               ; ⨬஢  16 .           
  const10      dw      10         ; ॣ㫨஢ 祭          
  ;                               ; ᫨誮  BCD.                 
  ;                                                                      
  ;        ॢ  C3, C2, C1  C0                               
  ;        騥 䫠  稭, ᯮ                          
  ;        楤 tos_status.                                         
  ;                                                                      
  status_table db      UNNORMAL, NAN, UNNORMAL+MINUS,                    
  &                    NAN+MINUS, NORMAL, INFINITY,                      
  &                    NORMAL+MINUS, INFINITY+MINUS,                     
  &                    ZERO, INVALID, ZERO+MINUS, INVALID,               
  &                    DENORMAL, INVALID, DENORMAL+MINUS, INVALID        
  floting_to_ascii proc                                                  
                                                                         
         call   tos_status   ; ᬮ  ﭨ ST(0)             
  ;                                                                      
  ;          ਯ  ⠡                                  
  ;                                                                      
         movzx      eax, status_table[eax]                               
         cmp        al,INVALID             ; ST(0) ?                 
         jne        not_empty                                            
  ;                                                                      
  ;        ST(0) - ! 頥 祭 ﭨ.                  
  ;                                                                      
         ret    parms_size                                               
  ;                                                                      
  ;         ᪮筮  ⥪  .                       
  ;                                                                      
  found_infinity:                                                        
         fstp       st(0)       ; ⠢ fstp                          
         jmp        short exit_proc                                      
  ;                                                                      
  ;               ப ᫨誮 !                              
  ;              뤠  ⨬.                              
  ;                                                                      
  small_string:                                                          
         mov    al,INVALID                                               
  exit_proc:                                                             
         leave                          ; ⠭ ⥪              
                                                                         
         pop    es                                                       
         ret    parms_size                                               
  ;                                                                      
  ;           ST(0) 室 NaN                                    
  ;          ।. ࠭ 祭                        
  ;             ᬮ ஡                          
  ;           ⮣, ⮡ ⫨                                    
  ;          ।  筮 NaN.                           
  ;                                                                      
  NAN_or_indefinite:                                                     
         fstp   fraction       ;  ஢ન - 㤠 祭         
                               ;  ⥪.                               
         test   al,MINUS       ; ᬮ  .                   
         fwait                 ;   믮 ࠭.      
         jz     exit_proc      ; ᫨ ⥫ ,            
                               ;   ।.           
                                                                         
         mov    ebx,0C0000000H ;  孨 32 ࠧ鸞 ஡     
                               ; .                                  
                                                                         
  ;             ࠢ ࠧ 63-32                                   
         sub    ebx,dword ptr fraction + 4                               
                                                                         
  ;              31-0   ﬨ                          
         or     ebx,dword ptr fraction                                   
         jnz    exit_proc                                                
                                                                         
  ;             ⠭ 뤠 祭                         
  ;             ।                                         
         mov   al,INDEFINITE                                             
         jmp   exit_proc                                                 
  ;                                                                      
  ;             뤥   ⥪   ६          
  ;              ⠭ ࠬ 樨.                         
  ;                                                                      
  not_empty:                                                             
         push  es            ; ࠭ ࠡ稩 ॣ                 
         enter local_size,0  ; ⠭  ⥪                
                                                                         
  ;             ஢, 筮    ப                  
         mov   ecx,field_size                                            
         cmp   ecx,2                                                     
         jl    small_string                                              
                                                                         
         dec   ecx           ; ⠭ ᨬ                    
                                                                         
  ; ᬮ,   ப ᫨誮   ⨯ BCD           
         cmp   ecx,BCD_DIGITS                                            
         jbe   size_ok                                                   
                                                                         
  ;  ⠭ ᨬ ࠧ ப                          
         mov   ecx,BCD_DIGITS                                            
  size_ok:                                                               
         cmp   al,INFINITY   ;   ᪮筮?                 
                                                                         
  ;  祭 ﭨ  +  - ᪮筮              
         jge   found_infinity                                            
                                                                         
         cmp   al,NAN              ;   NaN                  
         jge   NAN_or_indefinite   ; ।                    
                                                                         
  ;                                                                      
  ;             ⠭ 뤠 祭  㬮砭              
  ;              ஢, ଠ  ᫮.                     
  ;                                                                      
         fabs        ; ᯮ짮 ⮫쪮 ⥫ 祭        
  ;                                                                      
  ;         ॣ AL ᮤন ⨭  稭.        
  ;                                                                      
         xor   edx,edx          ; ⮢ ⠭ 0                
         mov   edi,denormal_ptr ; 㫨 稪 ଠ ᥫ    
         mov   [edi],dx                                                  
         mov   ebx,power_ptr    ; 㫨 祭 ⥯        
         mov   [ebx],dx                                                  
         mov   dl,al                                                     
         and   dl,1                                                      
         add   dl,EXACT                                                  
         cmp   al,ZERO          ; ஢                        
         jae   convert_integer  ; ३ ணࠬ           
                                ; ⥯, ᫨ 祭 ࠢ .     
                                                                         
         fstp  fraction                                                  
         fwait                                                           
         mov   al,bcd_byte + 7                                           
         or    byte ptr bcd_byte +7,80h                                  
         fld   fraction                                                  
         fxtract                                                         
         test  al,80h                                                    
         jnz   normal_value                                              
                                                                         
         fld1                                                            
         fsub                                                            
         ftst                                                            
         fstsw ax                                                        
         sahf                                                            
         jnz   set_unnormal_count                                        
  ;                                                                      
  ;                  ᥢ-                                   
  ;                                                                      
         fldlg2                 ; 業 ⥯                  
         add   dl,PSEUDO_ZERO - EXACT                                    
         fmulp st(2),st                                                  
         fxch                   ;  ⥯                    
         fistp word ptr [ebx]   ; ⠭ ⥯               
         jmp   convert_integer                                           
                                                                         
  set_unnormal_count:                                                    
         fxtract                ;  室 ஡,                  
                                ;  ଠ.                       
         fxch              ;  稪 -ଠ ᥫ           
         fchs                                                            
         fistp word ptr [edi]   ; ⠭ 稪                     
                                ; -ଠ ᥫ                    
                                                                         
  ;                                                                      
  ; ᫨  稭   ⨬ ᫮                   
  ;   浪.                                               
  ;                                                                      
  ; ᥣ  㣫 㤥 ⢮ 訡                    
  ; -  筮.  १,                               
  ; ।७  ᫥ 浪  ⠫                        
  ; ᬠਢ LOG10  祭 ஡.                         
  ; ஡ ᥣ   ࠢ 1   ,                     
  ; LOG10  ⮩ ஡   ᭮ 筮                    
  ; 㭪樨.  ⮣, ⮡                           
  ; 冷 稭,   㬭 ⥯                       
  ;   LOG10(2)  㣫 १                              
  ; 祭  楫.                                                
  ;                                                                      
  normal_value:                                                          
         fstp  fraction    ;  쭥襣 ᯮ짮               
                           ; ࠭  ஡.                       
         fist  power_twq   ; ࠭ ⥯                       
         fldlg2            ;  LOG10(2)                              
                           ;   ᭮ ᯮ짮         
                           ; power_two                                   
         fmul              ; ⮢ LOG10  浪 ᫠          
         fistp word ptr [ebx]   ;    ਬ         
                                ; ० 㣫                       
  ;                                                                      
  ;            ஢, ⮡ 稭 ᫠                           
  ;            ஢  楫.                             
  ;                                                                      
  ; CX  ᨬ쭮  ⢮  .         
  ;                                                                      
         fwait              ;  ⨬ ⥯           
  ;                                                                      
  ;                ⥯ 稭 祭              
  ;                                                                      
         movsx si,word ptr [ebx]                                         
         sub   esi,ecx         ; ⮢  AX 室            
                               ; 樥 ⠡஢.            
         ja    adjust_result   ; ३, ᫨ ᫮  室         
  ;                                                                      
  ; ᫮  1  10**(field_size - ࠧ )                       
  ; ஢  楫᫥                                         
  ;                                                                      
         fild  power_two         ; ⠭ 砫쭮 祭       
         sub   dl,NORMAL-EXACT   ; ॢ  筮 뤠         
                                 ; 祭                              
         fld   farction                                                  
         fscale              ; ⮢  稭,  ⮩       
                             ;                       
         fst   st(1)         ; ஢ 祭  ࠢ        
         frndint             ; ஢  楫᫥              
         fcomp               ; ࠢ 祭                         
         fstsw ax            ; ࠭ ﭨ                       
         sahf                ; C3 = 1,   뫠 楫 ᫮       
                                                                         
         jnz   convert_integer                                           
                                                                         
         fstp  st(0)            ;  楫᫥ 祭       
         add   dl,NORMAL-EXACT  ; ⠭ 砫쭭 뤠     
                                ; 祭                               
  ;                                                                      
  ; ⠡஢ ᫮  ,                               
  ;  ଠ⮬ BCD.                                   
  ; ⠡஢ 뤠 ᫮                             
  ; 筮 浪 稭 襣                             
  ; 筮 ᫠, ।⠢                       
  ; ப.                                                              
  ;                                                                      
  ;     稭 ⥯   ⠡஢                      
  ;     室  ॣ SI.                                         
  ;                                                                      
  adjust_result:                                                         
         mov   eax,esi            ; ⮢            
                                  ; ⥯                              
         mov   word ptr [ebx],ax  ; ⠭ 砫 稭        
                                  ; ⥯                        
         neg   eax                ;     浪  
                                  ; 稭,   ⠡  
                                  ; 祭.                            
         call  get_power_10       ; 樥 ⠡஢          
                                  ; ।⠢  冷  ஡.  
         fld   fraction           ;  ஡                          
         fmul                     ; ஢ ஡                  
         mov   esi,ecx            ;    ᨬ       
                                  ; ⥯                              
         shl   esi,3              ;  ⮣, ⮡ 祭 BCD         
                                  ; 室  ப                     
         fild  power_two          ; ஢ ⥯            
         faddp st(2),st                                                  
         fscale                   ; ⮢  祭,         
                                  ; 冷 ⠫  ஭          
         fstp  st(1)              ;  冷                      
  ;                                                                      
  ; ஢ ⠭ 祭  ⠡                          
  ;  ⥯ . 㬬 訡 業                      
  ; 稭  ⥯ 㭪樨  ਢ                         
  ; ⮬,  祭  浪 稭 㤥                     
  ;  ᫨誮 쪮,  ᫨誮 讥                      
  ;  ⨯ BCD.  ࠭ ⮩ ஡                          
  ;  祭 祭 -                        
  ;  ᫨誮 訬  ᫨誮 쪨. ⥬                     
  ; ॣ㫨   祭 ⥯ .                         
  ;                                                                      
  test_power:                                                            
  ;                                                                      
  ; ࠢ  筮 ⥯. ᯮ ᫥                    
  ; ⥯  㬥襭 CX  .                                
  ;                                                                      
         fcom  power_table[esi]+type power_table                         
         fstsw ax               ;                             
         sahf                   ; ᫨ C3=C0=0,  ᫨誮 讥       
         jb    test_for-small                                            
         fidiv const10          ;  ⠭ 祭              
         and   dl,not EXACT     ;  䫠 ⮣,  ᫮ 筮    
         inc   word ptr [ebx]   ; ⠭ 祭 ⥯      
         jmp   short in_range   ; ॢ 祭  楫 ⨯ BCD    
                                                                         
  test_for_small:                                                        
         fcom  power_table[esi] ; ஢ ⭮⥫ ࠧ         
                                                                         
         fstsw ax               ;                                 
         sahf                   ; ᫨ C0 = 0,  ST(0)         
                                ; ࠢ 襩 ࠭                   
         jc    in_range         ; ॢ 祭  楫 ⨯ BCD    
         fimul const10          ;  祭          
         dec   word ptr [ebx]   ;  祭 ⥯       
  in_range:                                                              
         frndint                ; ⮢ 楫 祭             
  ;                                                                      
  ; ⢥ত: 0 <= TOS <= 999,999,999,999,999,999                     
  ; ᫮ TOS 㤥 筮 ।⠢                                   
  ; 18- ࠬ  ଠ BCD.                                          
  ;                                                                      
  convert_integer:                                                       
         fbstp bcd_value        ; ࠭ ᫮  ଠ BCD          
  ;                                                                      
  ;  ࠭ ଠ BCD ⠭ ॣ                       
  ;  ॢ  ASCII .                                            
  ;                                                                      
         mov   esi,BCD_SIZE-2   ; 樠஢ 祭              
                                ;  BCD                            
         mov   cx,0f04h         ; ⠭ 稪 ᤢ        
         mov   ebx,1            ; ⠭ 砫 ࠧ ASCII      
                                ;                            
         mov   edi,string_ptr   ;   砫 ASCII ப        
         mov   ax,ds            ; ஢ DS  ES                    
         mov   es,ax                                                     
         cld                    ; ⠭ ० ⮬᪮       
                                ;                       
         mov   al,'+'           ;                       
         test  dl,MINUS         ; ஢  ⥫쭮 祭    
         jz    positive_result                                           
                                                                         
         mov   al,'-'                                                    
  positive_result:                                                       
         stosb                  ; ⠭ 㪠⥫ ப          
                                ; ᫥                          
         and   dl,not MINUS     ; 몫                      
         fwait                  ;  砭  fbstp        
  ;                                                                      
  ; ᯮ㥬 ॣ:                                               
  ;                                                                      
  ;          AH:            祭 ⨯ BCD                     
  ;          AL:          祭 ப ASCII                          
  ;          DX:          頥 祭                          
  ;          CH:          ᪠ BCD = 0fh                                
  ;          CL:          稪 ᤢ BCD = 4                         
  ;          BX:          ਭ  ப ASCII                       
  ;          ESI:           BCD                                
  ;          DI:          㪠⥫  ப BCD                      
  ;          DS, ES:       ᥣ ப ASCII                    
  ;                                                                      
  ;           砫 㫨  ᫠.                            
  ;                                                                      
  ;                                                                      
  skip_leading_zeroes:                                                   
         mov   ah,bcd_byte[esi]    ;   BCD                      
         mov   al,ah               ; ஢ 祭                
         shr   al,cl               ;    浪       
         and   al,0fh              ; ⠭ 䫠                 
         jnz   enter_odd           ;   横, ᫨  砫       
                                   ; 㦥  㫨                  
                                                                         
         mov   al,ah               ;  ᭮  BCD                
         and   al,0fh              ;    浪        
         jnz   enter-even          ;   横, ᫨ 㦥     
                                   ; 㫥                      
                                                                         
         dec   esi                 ;   BCD                
         jns   skip_leading_zeroes                                       
  ;                                                                      
  ;                 ⮨  㫥                          
  ;                                                                      
         mov   al,'0'              ; ⠭ 砫            
         stosb                                                           
         inc   ebx                 ;   ப              
         jmp   short exit_with_value                                     
  ;                                                                      
  ;                塞 ப ࠬ                      
  ;               0  9                               
  ;                                                                      
  digit_loop:                                                            
         mov   ah,bcd_byte[esi]    ;   BCD                      
         mov   al,ah                                                     
         shr   al,cl               ;    浪       
  enter_odd:                                                             
         add   al,'0'              ; ॢ  ASCII                   
         stosb                     ;    ப ASCII        
         mov   al,ah               ;    浪        
         and   al,0fh                                                    
         inc   ebx                 ;  稪 ࠧ       
  enter-even:                                                            
         add   al,'0'              ; ॢ  ASCII                   
         stosb                     ;    ப ASCII        
         inc   ebx                 ;  稪 ࠧ       
         dec   esi                 ; ३  ᫥饬  BCD      
         jns   digit_loop                                                
  ;                                                                      
  ;           ॢ 祭. ⠭ ࠧ                        
  ;           ப  ⮪                                           
  ;                                                                      
  exit_with_value:                                                       
         mov   edi,size_ptr                                              
         mov   word ptr [edi],bx                                         
         mov   eax,edx             ; ⠭ 뤠 祭      
         jmp   exit_proc                                                 
                                                                         
  floating_to_ascii       endp                                           
                          code          ends                             
                                        end                              
                                                                         
                                                                         
  +1 $title(᫨ 祭 10**AX)                                   
                                                                         
  ;  ணࠬ  祭 ⥯                          
  ; 10**EAX.  १ 뤠  祭                     
  ;  0 <= EAX < 19.  ॣ ஧                      
  ;  祭 뤠  TOS   ᫠: 冷                     
  ;  ST(1)  ஡  ST(0). 稭 浪                       
  ; ॢ 訩 冷 ᫠  ७                     
  ; ⢥ ଠ.  ணࠬ ᯮ                       
  ;  ⥪ ॣ.                                               
  ;                                                                      
         name      get_power_10                                          
         public    get_power_10, power_table                             
                                                                         
  stack  stackseg  8                                                     
                                                                         
  code  segment public er                                                
  ;                                                                      
  ;          ᯮ짮  祭  1.0  1E18.                
  ;                                                                      
         even               ; ⨬஢ 16- ⮢         
  power_table   dq  1.0,1e1,1e2,1e3                                      
                                                                         
                dq  1e4,1e5,1e6,1e7                                      
                                                                         
                dq  1e8,1e9,1e10,1e11                                    
                                                                         
                dq  1e12,1e13,1e14,1e15                                  
                                                                         
                dq  1e16,1e17,1e18                                       
                                                                         
  get_power_10  proc                                                     
         cmp   eax,18      ; ஢  0 <= AX < 19             
         ja    out_of_range                                              
                                                                         
         fld   power_table[eax*8]  ;  筮 祭               
         fxtract           ; ⤥ ⥯                           
                           ; ஡                                
         ret               ; ⠢ fxtract                            
  ;                                                                      
  ; ᫨ 祭, ᯮ                       
  ;  ⥯. ᯮ ᫥騥 ᮮ⭮襭:                       
  ;                                                                      
  ; 10**X = 2**(log2(10)*X)                                              
  ; 2**(I+F) = 2**I * 2**F                                               
  ;                                                                      
  ; ᫨ ST(1) = I  ST(0) = 2**F,   fscale                     
  ; 뤠 2**(I+F).                                                     
  ;                                                                      
  out_of_range:                                                          
                                                                         
         fldl2t                   ; TOS = LOG2(10)                       
         enter 4,0                                                       
                                                                         
  ;            ࠭ 祭 ⥯ , P                      
  ;                                                                      
         mov   [ebp-4],eax                                               
                                                                         
  ;            TOS, X = LOG2(10)*P = LOG2(10**P)                         
  ;                                                                      
         fimul dword ptr [ebp-4]                                         
         fld1                     ; ⠭ TOS = -1.0                
         fchs                                                            
         fld   st(1)              ; ஢ 祭 ⥯       
                                  ; ᭮                         
         frndint                  ; TOS = I; -᪮筮 < I <= X,    
                                  ;  I - 楫                        
                                  ;  㣫   祭   
         fxch  st(2)              ; TOS = X, ST(1) = -1.0                
                                  ; ST(2) = I                            
         fsub  st,st(2)           ; TOS, F = X-I:                        
                                  ; -1.0 < TOS <= 1.0                    
                                                                         
  ;      ⠭ 砫 ० ࠢ 筮               
         pop   eax                                                       
         f2xm1            ; TOS = 2**(F) - 1.0                           
         leave            ; ⠭ ⥪                            
         fsubr            ; ⮢ 2**(F)                           
         ret              ; ⠢ fsubr                               
                                                                         
  get_power_10   endp                                                    
                                                                         
  code           ends                                                    
                 end                                                     
                                                                         
  +1 $title(। ᮤন ॣ TOS)                        
  ;                                                                      
  ;  ணࠬ 뤠 祭  0  15                         
  ; ॣ EAX  ᮮ⢥⢨  ᮤঠ 設                     
  ; ⥪ FPU.  ॣ ஧, ⮬ 訡                    
  ; ᪫祭. 뤠 祭 ᮮ⢥                         
  ; ⠬ C3, C2, C1  C0  FXAM.                                  
  ;                                                                      
         name           tos_status                                       
         public         tos_status                                       
                                                                         
  stack        stackseg   6                                              
                                                                         
  code         segment public er                                         
                                                                         
  tos_status  proc                                                       
         fxam             ;  ﭨ ॣ TOS                 
         fstsw ax         ;  ⥪饥 ﭨ                      
         mov   al,ah      ;   10-8   2-0                
         and   eax,4007h  ; ᪨஢  C3, C2, C1  C0             
         shr   ah,3       ;   C3   11                     
         or    al,ah      ;   C3   3                      
         mov   ah,0       ;  頥 祭               
         ret                                                             
                                                                         
  tos_status endp                                                        
                                                                         
  code       ends                                                        
             end                                                         
                                                                         
                                                                         



20.3.3 樠 
----------------------------------------------------------------

㭪樨  ࠧ묨 ᫮묨 , ⨯
  ࠢ 筮.   
  ⮬᪮ ॢ ᥫ  BCD  (筮-
 ).  ⮬  10- ⭮ 祭
楫᫥ 稭, 樨 믮 ६,
⠭ ᨭ஭   ᯮ
ਥ஢ 㣫  㫥 ࠡ⪨ 権 
饩 窮.

 ⨯  ७ 筮  ஥
ᯮ樠쭮 㭪樨,    ⨣ 
筮 ⮩ 㭪樨  ᪮  ࠧ ਢ
ਬ.

㭪   ᫮ ⨯  BCD  ॢ 
筮  饩 窮  筮. ᭮ ࠡ
砥  ⠡஢ 祭  饩 窮 
ਥ ࠭祭  祭 ⨯ BCD.  ,
⮡  १  9- , 室 筮
஢ ⠡஢  稭  楫  10**(8) 
10**(9). ਬ, ᫮ +0.123456789 ॡ 樥
⠡஢ 浪 10**(9)  ⮣, ⮡  ᫮
+123456789.0, ஥  ࠭  9-  ⨯ BCD.
樥 ⠡஢   筮 ⥯ 10-
 ⮣, ⮡ ।    .

 ணࠬ  ࠢ쭮 ॢ  祭, 筮
।⠢  筮 ,  ,  ࠧ.
᫥ 祭,  室   ࠧ
ப,  室 ⠡஢,   ࠧ
࠭  ଥ BCD. 楫᫥ 祭, 筮
।⠢  筮   । ࠧ ப, ⠪
ॢ 筮. ਬ, ᫮ 0.125 筮 ।⠢  
筮 , ⠪   筮.  ⮣, ⮡ ॢ 
祭  饩 窮   ,  
樥 ⠡஢ 1000.  १ 稬 ᫮
125.  ⠡஢ 稭, 㭪  ⠢ ᫥
⠬,  㤥 ᯮ 筠 窠  筮
筮 祭.

20.3.4 ᠭ 樨
----------------------------------------------------------------

ॢ ᫠  饩 窮   ASCII 
஢   ᭮ 蠣: । 稭 ᫠,
⠡஢   ।⠢   BCD  ॢ
 ⨯ BCD   ᨬ ASCII .

। 稭 १ ॡ 宦 ⠪
祭 ᫠ X,  ஬  ᫮ 뫮  ।⠢ 
 I x 10**(X),  1.0  I < 10.0. ⠡஢ ᫠
ॡ  㬭  樥 ⠡஢ 10**(S)
⠪, ⮡ १  楫,  ᮤঠ騬  
, 祬 ⢥  ⮣   ப ᨬ ASCII.

᫥ ⠡஢, 㣫  ॢ  ⨯ BCD ᫮
।⠢  ଥ, 㤮  ॢ   ASCII
  ணࠬ ᯥ祭.

    蠣 ॡ ।쭮  
⠫.  砫  ,    稭 
饩 窮  ᫮ 祭. ணࠬ ॢ
  祭  ⠪ 稭  ᪮筮,
।  NaN. ⮬  ணࠬ  㬥
  稭  筮 । .

  ᮡ 砨 ᫮ 祭. ଠ
稭  ᫮ 祭    ⫨稬
㭪樥, ⠪   㪠뢠  ,  뫠 ﭠ
筮   ஢ । ᫥.

।,  ᫮  ᫮ 祭  ଠ
( 室 ⠭ ᮮ⢥ 䫠
ᨣ 맢 ணࠬ,   ଠ쭮 ᫮),
 ⠡஢ 稭   ⨯ BCD.

20.3.5 ⠡஢ 稭
----------------------------------------------------------------

 ⮣, ⮡ ⠡஢ ᫮, 室 । 
稭. 筮 ᫨ 稭  筮  1 
  ⭮ 10 樥, 㬭  ॡ㥬
稭. ᫥ ⠡஢ ᫠ ஢ ஢ઠ 
⮣, ⮡ ᬮ   १   .
᫨ ,  १   ࠢ   
冷     ॡ㥬 稭. ஥ 
᫥ ⠡஢ 室  ࠭ 
筮  ⠡஢ 祭.

  業 祭  樥 ⠡஢ 
 筮 ,  ᯮ  ਥ
⠡஢. 稭 業 㬭 ⥯ 2,
 ।⠢  ᥡ ᬥ饭 冷 ᫠ 
饩 窮, ᮮ⢥⢥  ᫮ log(10)  2.
㣫 १  楫  業 筮
筮.  ஡, 祭  १  
ᨬ 訡 0.32.

ᯮ 祭 稭  ࠧ ᫮ ப,
 ᫨ 樥 ⠡஢.  楤
ॢ ᫠ ᫥ 樥 ⠡஢ 
ᠬ 筮 樥.  ⮣ ᯮ ᮮ⭮襭
10**(X) = 2**(X * log(10) 2)   F2XM1.

 ᮮ⢥⢨  ࠭祭ﬨ   祭, ࠧ襭
 F2XM1, 祭 ⥯ 2 ࠧ  楫 
஡ . ⭮襭 2**(I + F) = 2**(I) x 2**(F)
 ᯮ짮  FSCALE  ⮣, ⮡
४஢ 祭 2**(F), ᫥  F2XM1, 
 2**(I).

20.3.5.1 筮  ⠡஢
----------------------------------------------------------------

 ᫥ 樥 ⠡஢  筮
-  㫥, 饭  ஡ 稭 ⥯ 2
 ⤥ 稬 ⮢ 楫 .   楫
稬   祭 ⥯ 2, ⤥  ஡
⮢,  ஡     筮  
ﬨ   ⮢.

 14 ⮢   ﭮ  ஡ , ⠪ 
 ⨬ 稭 浪 ᫠  饩 窮
⠢ 2**(14) - 1.   ।⢥  㬥
筮 ᫥ 樥 ⠡஢, 祬  뢠
㬥襭 筮 ᠬ 祭 ᫠.  ᥫ  
10**(30) ᨬ쭮 ᫮ ⮢ 筮, ﭭ 
믮 ⠡஢, ⨣ 8-.

20.3.5.2 ।० ९  ⥫ ९
----------------------------------------------------------------

஡  ᫠  ⥫ ⤥   㣠 
⮣, ⮡  ९  ⥫ ९
 ᫥ 蠡஢ 稭. ਬ,  ⮣,
⮡ ந ⠡஢ ᫠ 10**(-4932)  10**(8),
ॡ 樥 ⠡஢ 10**(4950),  
  ।⠢ ஬ i486.

⤥ ⥫  ஡,  ⠡஢ 㤥
 ᪫뢠 ⥫ ⤥쭮  㬭 ஡. 
䬥᪠  砥  楫 ᫠, 
।⠢ ஬ i486.

20.3.5.3 ⥫쭠 ॣ㫨஢
----------------------------------------------------------------

,  ⥯ 㭪 Get Power 10  뤠
१ ⠡஢ 稭 ⠪,   ᫮,
饥  ࠧ冷, 祬   ।⠢  ப
ASCII ᨬ. ਬ, ⠡஢ ᫠
9.9999999999999999 x 10**(4900)  樥⮬
1.00000000000000010 x 10**(-4883)    १ ᫮
1.00000000000000009 x 10**(18).  樥 ⠡஢
ᮮ⢥ 筮  ࠡ⪨ 権  饩
窮  १ ᮮ⢥ 筮 ॢ,  ᫮ 
  ।⠢  ଠ BCD.  祬 室 ᫥
⠡஢ ஢ ஢ 稭 १.
  㬭  ࠧ  10,  ᨬ 
⮣,   १ ᮮ⢥⢥ ᫨誮  
᫨誮 訬.

20.3.6 室 ଠ
----------------------------------------------------------------

 ᨬ쭮  室 ଠ,  筮
窨 㪠뢠  楫 ᫮, 뢠 祭
⥫ ⥯. ᫨ ⥫ ⥯ ࠢ , 
筠 窠 । ࠢ  ᠬ ࠢ .
⥫ ⥯ 訩  뢠,   
㫥  뢠.      筠
窠  ப ᤢ .

᫥ 蠣 ॢ ᫠ -  ࠭ १  
BCD  㪠,  室 筠 窠. ப ⨯ BCD
⥬ ᯠ뢠   ப  ASCII ᨬ.
 ⠭  ᮮ⢥⢨   ਣ쭮
祭.

20.4 ਬ ਣ᪨ ᫥
----------------------------------------------------------------

 ⮬ ਬ  ⨪ 㪨 ஡  
栬 ८ࠧ ࠧ஬ 4 x 4, । ⮬ 
⥭࣮ (1,2). ।   ⭮襭 
ᬥ묨 ﬨ 㪨 ᠭ    , ᯮ
 ⮤ D-H.    ஥ 
 ८ࠧ ࠧ஬ 4 x 4,  ।⠢
न ⥬  (L(i))  ᮥ (J(i)) 
ᮮ⢥⢨  ।饩 न⭮ ⥬ (J(i-1),L(i-1)).


1. J.Denavit and R.S.Hartenberg, "A Kinematic Notation for
   Lower-Pair Mechanisms Based on Matrices."
   J. Applied Mechanics, June 1955, pp. 215-221

2. C.S.George Lee, "Robert Arm Kinematics, Dinamics, and
   Control." IEEE Computer, Dec. 1982.


騥  ᪨ 稭  뢠
   ᮥ/ (J(i),L(i)),  
 㭪 20-7.

(i)   =    x(i)   x(i-1)  
              z(i-1) ⨢ ᮢ ५.

d(i)      = ﭨ  (i-1)- न⭮ ⥬ 
             z(i-1)   x(i).

a(i)      = ﭨ  i- न⭮ ⥬  
            z(i-1)   -x(i).

(i)  =    z(i)   z(i-1)  
              x(i) ⨢ ᮢ ५.

Ŀ
                                                               
                                                               
                            zi-1          xi-1                 
                yi-1              90   /                      
                  \         \  /                        
                    \              /\                     
                      \          /    \                       
                        \      /       *                      
                          \  /                                
              i-1                    
                                                             
                                                             
                                                             
                 i                                      
          \                                                  
            \                                                 
              \       * <ĳ\                        di    
                \                \ 90                         
  zi              \                                         
   \             yi \                                       
     \           /    \                                     
       \       /        \                                   
         \   /            \                                 
            xi      
  i+1                                                
                                                               
            ai Ĵ                                  
                                                    240486/103 


        㭮 20-7. ⭮襭  묨 ﬨ

 ८ࠧ A(i)(i-1) ⨯ D-H  ᬥ
न ⪮  ᮥ (i-1)  ᮥ (i)
 :

A(i)(i-1) = T(z,d) x T(z,) x T(x,a) x T(x,)

:

T(z,d)        ।⠢ ।   z(i-1)

T(z,)     ।⠢  㣫    z(i-1)

T(x,a)        ।⠢ ।   x(i)

T(x,)    ।⠢  㣫    x(i)


A(i)(i-1) =

 COS(i) -COS(i)SIN(i)  SIN(i)SIN(i) COS(i) 
                                                             
 SIN(i)  COS(i)COS(i) -SIN(i)COS(i) SIN(i) 
                                                             
 0          SIN(i)           COS(i)          d(i)      
                                                             
 0          0                   0                  1         


⭠   T,  ।⠢ ᮡ
  ਥ  ᮥ/  ⭮襭 
᭮ ⥬, 砥 ᫥⥫ 㬭 
८ࠧ ⨯ D-H  ᬥ न ⪮.

T(i)(0) = A(1)(0) x A(2)(1) x ... x A(i)(i-1)

ਬ ணࠬ  㭪 20-8 ,  
믮 । , ᯮ  ࠡ⪨
権  饩 窮  i486. ணࠬ ⮨
   楤. ࢠ 楤 TRANS PROC
ᯮ  ᫥ ⮢    A(i)(i-1)
⨯ D-H.  楤 MATRIXMUL PROC 室 ந
 ᫥⥫  ⨯ D-H.

          㭮 20-8. ਬ ⨪ 㪨 

Ŀ
                                                                         
                                                                         
    Name ROT_MATRIX_CAL                                                  
    ;                                                                    
    ;  ਬ  ᯮ짮                      
    ; 饩 窮  i486  筮                        
    ; 㭪 FSINCOS,   祭 ᨭ                     
    ; ᨭ ६. ணࠬ                          
    ;  ,   ࠡ⠥ 堭                  
    ; ।.                                                          
    ;                                                                    
    ;  ⮬ ਬ ᬮ७ ⮫쪮 ⨪                       
    ; ஡.                                                            
    ;                                                                    
    ; ᫨ ⭠ , 㯮 ,                         
    ;  :                                                      
    ; T1n = A1 x A2 x ... x An,                                        
    ; T1n 室 맮 楤 trans_proc                         
    ; matrixmul_proc,                               
    ; ६.                                                       
    ;                                                                    
    ; 楤 trans_proc                        
    ;  A(A1,.....An),  楤                              
    ; matrixmul_proc 믮 㬭  Ai                     
    ; Ai+1.  㬭 楤 matrixmul_proc                       
    ; ᯮ 楤 matrix_row  matrix_elem.                     
    ;                                                                    
    ; । ⥪ ࠭⢮                                   
    ;                                                                    
    trans_stack stackseg 400                                             
                                                                         
    ; । 筮   ।                   
    ;  ࠧ஬ 4x4                                                
                                                                         
    a_matrix struc                                                       
           a11   dq   ?                                                  
           a12   dq   ?                                                  
           a13   dq   ?                                                  
           a14   dq   ?                                                  
           a21   dq   ?                                                  
           a22   dq   ?                                                  
           a23   dq   ?                                                  
           a24   dq   ?                                                  
           a31   dq   0h                                                 
           a32   dq   ?                                                  
           a33   dq   ?                                                  
           a34   dq   ?                                                  
           a41   dq   0h                                                 
           a42   dq   0h                                                 
           a43   dq   0h                                                 
           a44   dq   1h                                                 
    a_matrix ends                                                        
    ;                                                                    
    ; ।,   ᮥ ࠭                        
    ;  樨 , ᫥⥫쭮,                       
    ; ࠬ஢. ,   襥 ⢮                  
    ; ᮥ.                                                        
    ;                                                                    
    alp_deg struc                                                        
           alpha_deg1 dd ?                                               
           alpha_deg2 dd ?                                               
    alp_deg ends                                                         
    ;                                                                    
    tht_deg struc                                                        
           theta_deg1 dd ?                                               
           theta_deg2 dd ?                                               
    tht_deg ends                                                         
    ;                                                                    
    A_array struc                                                        
           A1         dq ?                                               
           A2         dq ?                                               
    A_array ends                                                         
    ;                                                                    
    D_array struc                                                        
           D1         dq ?                                               
           D2         dq ?                                               
    D_array ends                                                         
    ;                                                                    
    ;   - trans_data                                        
    ;                                                                    
    trans_data             segment rw   public                           
           Amx             a_matrix<>                                    
           Bmx             a_matrix<>                                    
           Tmx             a_matrix<>                                    
           ALPHA_DEG       alp_deg<>                                     
           THETA_DEG       tht_deg<>                                     
           A_VECTOR        A_array<>                                     
           D_VECYOR        D_array<>                                     
           ZERO            dd           0                                
           d180            dd           180                              
           NUM_JOINT       equ          1                                
           NUM_ROW         equ          4                                
           NUM_COL         equ          4                                
           REVERSE         DB           1H                               
    trans_data             ends                                          
                                                                         
    assume  ds:trans_data, es:trans_data                                 
    ;                                                                    
    ;  trans_code ᮤন 楤                           
    ; ᫥ ⮢   㬭 .                   
    ;                                                                    
    trans_code      segment er    public                                 
    truns_proc      proc    far                                          
    ;                                                                    
    ; ᫨ 㣫     ࠤ   祭              
    ;  ࠤ                                                         
    ;                                                                    
           fldpi                                                         
           fdiv  d180                                                    
    ;                                                                    
    ;   /180                                                 
    ;                                                                    
           fld   st                                                      
           fmul  qword ptr ALPHA_DEG[ecx*8]                              
           fxch  st(1)                                                   
           fmul  qword ptr THETA_DEG[ecx*8]                              
    ;                                                                    
    ;  ( ࠤ)  ST                                             
    ;   ( ࠤ)  ST(1)                                       
    ;                                                                    
    ; ᫥ ⮢                                        
    ;                                                                    
    ;            a11 = COS                                           
    ;            a12 = -COS * SIN                               
    ;            a13 = SIN  * SIN                               
    ;            a14 = A * COS                                       
    ;            a21 = SIN                                           
    ;            a22 = COS  * COS                               
    ;            a23 = -SIN  * COS                              
    ;            a24 = A * SIN                                       
    ;            a32 = SIN                                          
    ;            a33 = COS                                          
    ;            a34 = D                                                 
    ;            a31 = a41= a42 = a43 = 0.0                              
    ;            a44 = 1                                                 
    ;                                                                    
    ;  EBX ᮤন ᬥ饭                            
    ;                                                                    
           fsincos                       ; COS   ST                 
                                         ; SIN   ST(1)              
           fld   st                      ; 㤢 COS               
           fst   [ebx].a11               ; COS   a11                
           fmul  qword ptr A_VECTOR[ecx*8]                               
           fstp  [ebx].a14               ; A * COS   a14            
           fxch  st(1)                   ; SIN   ST                 
           fst   [ebx].a21               ; SIN   a21                
           fld   st                      ; 㤢 SIN               
           fmul  qword ptr A_VECTOR[ecx*8]                               
           fstp  [ebx].a24               ; A * SIN   a24            
           fld   st(2)                   ;   ST                    
           fsincos                       ; COS   ST                
    ;                SIN   ST(1)                                   
    ;                SIN   ST(2)                                    
    ;                COS   ST(3)                                    
           fst   [ebx].a33               ; COS   a33               
           fxch  st(1)                   ; SIN   ST                
           fst   [ebx].a32               ; SIN   a32               
           fld   st(2)                   ; SIN   ST                 
                                         ; SIN   ST(1)             
           fmul  st,st(1)                ; SIN  * SIN           
           fchs  st(2)                   ; -COS  * SIN          
           fstp  [ebx].a23               ; ࠭  a23                
           fld   st(2)                   ; COS   ST                 
                                         ; COS   ST(1)             
                                         ; SIN   ST(2)              
                                         ; COS   ST(3)              
           fmul  st,st(1)                ; COS  * COS           
           fstp  [ebx].a22               ; ࠭  A22                
           fmul  st,st(1)                ; COS  * SIN           
    ;                                                                    
    ;                 ⮣, ⮡  २⢠               
    ;                ࠫ쭮 ࠡ IU  FPU                        
    ;                                                                    
           push  eax                     ; ࠭ EAX                 
    ;                                                                    
    ;                 ᪮७  D  A34                     
    ;                                                                    
           mov   eax, dword ptr D_VECTOR[ecx*8]                          
           mov   dword ptr [ebx + 88],eax                                
           mov   eax, dword ptr D_VECTOR[ecx*8 + 4]                      
           mov   dword ptr [ebx + 92],eax                                
           pop   eax                     ; ⠭ EAX              
           fchs                          ; COS  * SIN           
           fstp  [ebx].a12               ; ࠭  a12                
                                         ;                 
                                         ; 㫥             
                                                                         
           ret                                                           
                                                                         
    trans_proc endp                                                      
                                                                         
    matrix_elem proc far                                                 
    ;                                                                    
    ;     楤  ந i-⮩ ப               
    ;    ࢮ   j-⮣ ⮫ ன :                 
    ;                                                                    
    ;       Tij,  Tij = 㬬 ந Aik x Bkj  k             
    ;                                                                    
    ;    ࠬ, ।  맢襩 楤                  
    ;    matrix_row:                                                     
    ;                                                                    
    ;                    ESI = (i-1)*8                                   
    ;                    EDI = (j-1)*8                                   
    ;                                                                    
    ;  ॣ, EBP = (k-1)*8                                   
    ;                                                                    
           push  ebp             ; ࠭ EBP                         
           push  ecx             ;  ⮣, ⮡ ᯮ짮          
                                 ; ESX  ६ ॣ             
           mov   ecx,esi         ; ࠭  쭥襣             
                                 ;   ஢                      
    ;                                                                    
    ;    ࢮ , A                                  
    ;                                                                    
           imul  ecx,NUM_COL     ; ECX ᮤন ᬥ饭 ।      
                                 ; ப; ᬥ饭   砫     
                                 ;                                
                                                                         
           xor   ebp,ebp         ;  EBP,  㤥 㦥     
                                 ;  ६ ॣ       
                                 ; (k)  i-⮩ ப ࢮ            
                                 ;     j-⮬ ⮫      
                                 ; ன .                       
    ;                                                                    
    ;          Tij    Aik*Bkj                  
    ;                                                                    
           mov   dword ptr [edx][edi],ebp                                
           mov   dword ptr [edx][edi+4],ebp                              
                                                                         
           push  ecx             ; ࠭  ⥪: ESI * num_col      
                                 ; = ᬥ饭 砫 i-⮩ ப      
                                 ; 砫  A                      
                                                                         
           add   ecx,ebp         ;  k-  i-⮩ ப      
                                 ;  A                             
    ;                                                                    
    ;      㧨 Aik  FPU                                           
    ;                                                                    
           fld   qword ptr [eax][ecx]                                    
    ;                                                                    
    ;       Bkj                                                     
    ;                                                                    
           mov ecx,ebp                                                   
           imul  ecx,NUM_ROW     ; ECX ᮤন ᬥ饭 砫          
                                 ; k-⮩ ப  砫  B      
           add   ecx,edi         ;  j-  k-⮩ ப      
                                 ;  B                             
           fmul  qword ptr [ebx][ecx]        ; Aik * Bkj                 
           pop   ecx             ; ESI * num_col                         
                                 ;  ECX ᭮                           
           pop   ecx             ; ⠪  設 ணࠬ          
                                 ; ⥪                                 
    ;                                                                    
    ;        १  室 , Tij                 
    ;                                                                    
           add   ecx,edi                                                 
    ;                                                                    
    ;       㬬  Aik * Bkj                               
    ;                                                                    
           fadd  qword ptr [edx][ecx]                                    
           fstp  qword ptr [edx][ecx]                                    
    ;                                                                    
    ;      㢥   k,                                 
    ;      EBP  8                                                      
    ;                                                                    
           add ebp,8                                                     
    ;                                                                    
    ; ⨣  k ਭ ?                                      
    ;                                                                    
           cmp   ebp, NUM_COL*8                                          
           jl    NXT_k                                                   
    ;                                                                    
    ; ⠭ ॣ                                              
    ;                                                                    
           pop   ecx              ; 㤠  ⥪ ESI * num_col       
           pop   ecx              ; ⠭ ECX                     
           pop   ebp              ; ⠭ EBP                     
                                                                         
    matrix_elem  endp                                                    
                                                                         
    matrix_row       proc     far                                        
           xor       edi,edi                                             
    ;                                                                    
    ;      ன  ப                                              
    ;                                                                    
    NXT_COL:                                                             
           call  matrix_ekem                                             
           add   edi,8                                                   
           cmp   edi, NUM_COL*8                                          
           jl    NXT_COL                                                 
           ret                                                           
                                                                         
    matrix_row endp                                                      
                                                                         
    matrixmul_proc proc far                                              
    ;                                                                    
    ;  楤 ६ , ᯮ                       
    ; 楤 matrix_row  ᫥ ⮢                      
    ;  ப.                                                     
    ;                                                                    
    ;   믮 :                                  
    ;                                                                    
    ; Tij = Aik x Bkj,                                                   
    ;                                                                    
    ;  i  j 㪠뢠   ப  ⮫                     
    ; ᮮ⢥⢥  k -   室  i-⮩                   
    ; ப ࢮ    j-⮬ ⮫ ன                   
    ; .                                                           
    ;                                                                    
           mov   ebp,esp                ; ᯮ  㪠⥫   
                                        ;  ஢             
           mov   edx,dword ptr[ebp+4]   ; ᬥ饭 Tmx  EDX             
           mov   ebx,dword ptr[ebp+8]   ; ᬥ饭 Bmx  EBX             
           mov   eax, dword ptr[ebp+12] ; ᬥ饭 Amx  EAX             
    ;                                                                    
    ;              ⠭ ESI  EDI                                   
    ;              EDI 㪠뢠 ⮫                                 
    ;              ESI 㪠뢠 ப                                  
    ;                                                                    
           xor   esi,esi                ;  ESI                   
                                                                         
    NXT_ROW:                                                             
           call  matrix_row                                              
                                                                         
           add   esi,8                                                   
           cmp   esi,NUM_ROW*8                                           
           jl    NXT_ROW                                                 
           ret   12                ; ⮫ 㪠⥫         
                                                                         
    matrix_proc  endp                                                    
                                                                         
    trans_code   ends                                                    
                                                                         
    ; ********************************************** ;                   
    ;                                                ;                   
    ;                                                ;                   
    ;                                                ;                   
    ;               ணࠬ                 ;                   
    ;                                                ;                   
    ;                                                ;                   
    ;                                                ;                   
    ;                                                ;                   
    ; ********************************************** ;                   
                                                                         
    main_code   segment  er                                              
                                                                         
    START:                                                               
                                                                         
           mov   esp, stackstart trans_stack                             
    ;                                                                    
    ;            ࠭  ॣ                                  
    ;                                                                    
           pushad                                                        
    ;                                                                    
    ; ECX 㪠뢠 ᫮ ᮥ,  ᫮                    
    ; ࠢ NUM_JOINT + 1.                                               
    ;    ( ᭮ ⥬                      
    ; ࢮ ᮥ)    Bmx.                              
    ;                                                                    
           xor   ecx,ecx                   ; ࢮ 楩             
           mov   ebx,offset Bmx            ;                             
           call  trans_proc                ;  Bmx                
           inc   ecx                                                     
                                                                         
    NXT_MATRIX:                                                          
    ;                                                                    
    ;      ࠭  Amx.                     
    ;  㬭  㤥 ࠭                      
    ; Tmx,   ᫥饣 㬭 㤥 㯥                    
    ; १ Bmx.  㡫஢ 室                        
    ; ᫥⥫쭮 㬭 .                             
    ; ⨣  浪 ᫥ 㪠⥫                 
    ;  Bmx  Tmx  ணࠬ ⥪,                     
    ;   楤 ६ .                       
    ; REVERSE ᯮ  ;                                
    ; ᫨ REVERSE = 0,   ,  १                     
    ; 饭  Tmx.                                                     
    ;                                                                    
           mov   ebx,offset Amx                 ;  Amx              
           call  trans_proc                                              
           inc   ecx                                                     
           xor   REVERSE,1h                                              
           jnz   Bmx_as_Tmx                                              
    ;                                                                    
    ;  . Bmx ᯮ   室                     
    ; ,  Tmx -  室 .                             
    ;                                                                    
           push  offset Amx                                              
           push  offset Bmx                                              
           push  offset Tmx                                              
           jmp   CONTINUE                                                
    ;                                                                    
    ; . Tmx ᯮ   室                      
    ; ,  Bmx -  室 .                             
    ;                                                                    
    Bmx_as_Tmx:                                                          
                                                                         
           push  offset Amx                                              
           push  offset Tmx         ;  । 㪠⥫      
           push  offset Bmx                                              
                                                                         
    CONTINUE:                                                            
                                                                         
           call  matrixmul_proc                                          
           cmp   ecx,NUM_JOINT                                           
           jle   NXT_MATRIX                                              
    ;                                                                    
    ; ᫨ REVERSE = 1,   १ 㤥                     
    ; Bmx,    Tmx.                                                
    ;                                                                    
           popad                                                         
                                                                         
    main_code    ends                                                    
                                                                         
    end    START, ds:trans_data, ss:trans_stack                          
                                                                         
                                                                         

