WebSVN – Kolibri OS – Diff – /programs/calc/trunk/calc.asm

-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-;;
 ;;   Calculator for MenuetOS
-;;
+;;  (c)Ville Turjanmaa
 ;;   Compile with FASM for Menuet
 ;;
+;;    «ìªã«ïâ®à 1.1 alpha
+;;  (c)Pavel Rymovski aka Heavyiron
+;;What's new:1)changed design
+;;           2)new procedure of draw window (10 decimal digits, 23 binary, "+" not displayed now)
+;;           3)window with skin
+;;           4)I had used macroses
+;;   Calc 1.2 alpha
+;;           1)added some useful functions, such as arcsin, arccos, arctg, 1/x, x^2
+;;   Calc 1.3
+;;           1)optimised program
+use32
-use32
-               org    0x0
+							 org    0x0
-               db     'MENUET01'              ; 8 byte id
+               db    'MENUET01'               ; 8 byte id
                dd     0x01                    ; header version
                dd     START                   ; start of code
                dd     I_END                   ; size of image
                dd     0x1000                  ; memory for app
-               dd     0x1000                  ; esp
-               dd     0x0 , 0x0               ; I_Param , I_Icon
+               dd     0x1000                  ; esp
-include 'lang.inc'
-include 'macros.inc'
-START:                          ; start of execution
+               dd     0x0 , 0x0               ; I_Param , I_Icon
-     call draw_window
-still:
-    mov  eax,10                 ; wait here for event
-    int  0x40
-    cmp  eax,1                  ; redraw request ?
-    je   red
-    cmp  eax,2                  ; key in buffer ?
-    je   key
-    cmp  eax,3                  ; button in buffer ?
-    je   button
+include 'macros.inc'
-    jmp  still
+START:
-  red:                          ; redraw
+red:
+    call draw_window
+still:
+    push 10
+    pop eax
+    int 40h
+    dec eax
-    call draw_window
+    jz red
+    dec eax
+    jz key
+button:
+    mcall 17 	  ; ¯®«ãç¨âì ¨¤¥â¨ä¨ª â®à  ¦ â®© ª®¯ª¨
-    jmp  still
+    shr  eax,8
+    jmp  testbut
   key:                          ; key
-    mov  eax,2
+ key:
-    int  0x40
+    mcall 2         ; ¯®«ãç¨âì ASCII-ª®¤  ¦ â®© ª« ¢¨è¨
     shr  eax,8
-    mov  edi,asci             ;translation & emulation
+    mov  edi,asci	  ; ¯¥à¥¢®¤ ASCII ¢ ¨¤¥â¨ä¨ª â®à ª®¯ª¨
-    mov  ecx,35               ;of button ID's
+    mov  ecx,18
     cld
     repne scasb
-    jne  still
-    sub  edi,asci
+    jne  still
-    dec  edi
-    mov  esi,butid
-    add  esi,edi
-    lodsb
-    jmp  testbut
     sub  edi,asci
-  button:                       ; button
+    dec  edi
-    mov  eax,17                 ; get id
+    mov  esi,butid
-    int  0x40
+    add  esi,edi
+    lodsb
     shr  eax,8
-  testbut:
-    cmp  eax,1                   ; button id=1 ?
+  testbut:
-    jne  noclose
+  	cmp  eax,1	  ; ª®¯ª  1 - § ªàëâ¨¥ ¯à®£à ¬¬ë
-    mov  eax,-1                  ; close this program
+    jne  noclose
-    int  0x40
+    mcall -1
   noclose:
     cmp  eax,2
-    jne  no_reset
-    call clear_all
+    jne  no_reset
-    jmp  still
+    call clear_all
-  no_reset:
+    jmp  still
-    finit
   no_reset:
-    mov    ebx,muuta1    ; Transform to fpu format
+    finit
-    mov    esi,18
+    mov    ebx,muuta1	 ; ¥à¥¢®¤ ¢ ä®à¬ â FPU
-    call   atof
+    mov    esi,18
-    fstp   [trans1]
-    mov    ebx,muuta2
-    mov    esi,18
+    call   atof
-    call   atof
+    fstp   [trans1]
-    fstp   [trans2]
+    mov    ebx,muuta2
     mov    esi,18
-    fld    [trans2]
+    call   atof
     fst    [trans2]
-    cmp  eax,30
+    cmp  eax,33
+    jne  no_sign
-    jne  no_sign
+    cmp  [dsign],byte '-'
-    cmp  [dsign],byte '-'
+    jne  no_m
-    jne  no_m
+    mov  [dsign],byte '+'
-    mov  [dsign],byte '+'
+    call print_display
+    jmp  still
     call print_display
-    jmp  still
   no_m:
     mov  [dsign],byte '-'
     call print_display
     jmp  still
   no_sign:
   no_sign:
+    cmp  eax,3
-    cmp  eax,3
+    jne  no_display_change
-    jne  no_display_change
+    inc  [display_type]
-    inc  [display_type]
+    cmp  [display_type],2
-    cmp  [display_type],2
+    jbe  display_continue
-    jbe  display_continue
+    mov  [display_type],0
     mov  [display_type],0
   display_continue:
     mov  eax,[display_type]
-    mov  eax,[multipl+eax*4]
-    mov  [entry_multiplier],eax
-    call print_display
+    mov  eax,[multipl+eax*4]
-    jmp  still
+    mov  [entry_multiplier],eax
-  multipl:  dd  10,16,2
+    call print_display
+    jmp  still
-  no_display_change:
+  multipl:  dd	10,16,2
   no_display_change:
-    cmp  eax,6
-    jb   no_10_15
+    cmp  eax,6
+    jb	 no_a_f
     cmp  eax,11
-    jg   no_10_15
+    jg	 no_a_f
     add  eax,4
     call number_entry
     jmp  still
    no_10_15:
    no_a_f:
+    cmp  eax,12
-    cmp  eax,12
+    jb	 no_13
-    jb   no_13
     cmp  eax,14
-    jg   no_13
+    jg	 no_13
     sub  eax,11
     call number_entry
     jmp  still
    no_13:
    no_13:
+    cmp  eax,19
-    cmp  eax,12+6
+    jb	 no_46
-    jb   no_46
-    cmp  eax,14+6
+    cmp  eax,21
-    jg   no_46
+    jg	 no_46
-    sub  eax,11+3
+    sub  eax,15
     call number_entry
     jmp  still
    no_46:
    no_46:
+    cmp  eax,26
-    cmp  eax,12+12
+    jb	 no_79
-    jb   no_79
-    cmp  eax,14+12
+    cmp  eax,28
-    jg   no_79
+    jg	 no_79
-    sub  eax,11+6
+    sub  eax,19
     call number_entry
     jmp  still
-   no_79:
+   no_79:
-    cmp  eax,13+18
+    cmp  eax,34
     jne  no_0
     mov  eax,0
     call number_entry
     jmp  still
     no_0:
+   no_0:
     cmp  eax,35
-    cmp  eax,32
     jne  no_id
     inc  [id]
     and  [id],1
     mov  [new_dec],100000
     jmp  still
   no_id:
+    cmp  eax,17
+    jne  no_sin
+    fld  [trans1]
+    fsin
+    jmp  show_result
+  no_sin:
+    cmp  eax,18
+    jne  no_asin
+    fld  [trans1]
+    fld  st0
+    fmul st,st1
-    cmp  eax,16
+    fld1
-    jne  no_sin
+    fsubrp  st1,st0
-    fld  [trans1]
+    fsqrt
-    fsin
+    fpatan
     jmp  show_result
-  no_sin:
+  no_asin:
+    cmp  eax,16
+    jne  no_int
+    fld  [trans1]
+    frndint
+    jmp  show_result
+  no_int:
+    cmp  eax,23
-    cmp  eax,17
+    jne  no_1x
-    jne  no_int
+    fld  [trans1]
-    fld  [trans1]
+    fld1
-    frndint
+    fdiv st,st1
     jmp  show_result
-  no_int:
+  no_1x:
-    cmp  eax,22
+    cmp  eax,24
     jne  no_cos
+    fld  [trans1]
+    fcos
+    jmp  show_result
-    fld  [trans1]
+  no_cos:
+    cmp  eax,25
+    jne  no_acos
+    fld  [trans1]
+    fld1
-    fcos
+    fsub st,st1
-    jmp  show_result
-  no_cos:
+    fsqrt
+    fld1
+    fadd st,st2
-    cmp  eax,23
+    fsqrt
-    jne  no_lg2
+    fpatan
+    fadd st,st0
+    jmp  show_result
-    fldlg2
+  no_acos:
+    cmp  eax,30
-    jmp  show_result
+    jne  no_x2
-  no_lg2:
+    fld  [trans1]
+    fmul st,st0
-    cmp  eax,28
+    jmp  show_result
     jne  no_tan
+  no_x2:
-    fld  [trans1]
+    cmp  eax,31
+    jne  no_tan
+    fld  [trans1]
+    fptan
+    fstp st2
+    jmp  show_result
-    fcos
+  no_tan:
+    cmp  eax,32
-    fstp [tmp2]
+    jne  no_atan
     fld  [trans1]
-    fsin
+    fld1
-    fdiv [tmp2]
+    fpatan
+    jmp  show_result
     jmp  show_result
-  no_tan:
+   no_atan:
-    cmp  eax,29
+    cmp  eax,38
     jne  no_pi
     fldpi
     jmp  show_result
    no_pi:
-    cmp  eax,34
+    cmp  eax,37
     jne  no_sqrt
     fld  [trans1]
-    fsqrt
-    jmp  show_result
+    fsqrt
-  no_sqrt:
+    jmp  show_result
+  no_sqrt:
     cmp  eax,15
-    jne  no_add
-    call calculate
+    jne  no_add
-    call print_display
+    call calculate
     call new_entry
-    mov  [calc],'+'
-    jmp  still
+    mov  [calc],'+'
-  no_add:
+    jmp  still
+  no_add:
-    cmp  eax,21
+    cmp  eax,22
-    jne  no_sub
-    call calculate
+    jne  no_sub
-    call print_display
+    call calculate
     call new_entry
-    mov  [calc],'-'
-    jmp  still
+    mov  [calc],'-'
-  no_sub:
+    jmp  still
+  no_sub:
-    cmp  eax,27
+    cmp  eax,29
-    jne  no_div
-    call calculate
+    jne  no_div
-    call print_display
+    call calculate
     call new_entry
-    mov  [calc],'/'
-    jmp  still
+    mov  [calc],'/'
-  no_div:
+    jmp  still
+  no_div:
-    cmp  eax,33
+    cmp  eax,36
-    jne  no_mul
-    call calculate
+    jne  no_mul
-    call print_display
+    call calculate
     mov  [calc],'*'
     call new_entry
+    jmp  still
     jmp  still
-  no_mul:
   no_mul:
-    cmp    eax,35
+    cmp    eax,39
-    jne    no_calc
-    call   calculate
+    jne    no_calc
-    jmp    still
+    call   calculate
-  no_calc:
     jmp    still
     jmp  still
-  show_result:
+  no_calc:
-    call   ftoa
+    jmp  still
-    call   print_display
-    jmp    still
   show_result:
-error:
+    call   ftoa
-    jmp  still
+    call   print_display
     jmp    still
+error:
-calculate:
+    jmp  still
     pusha
 calculate:
-    cmp  [calc],' '
+    pusha
+    cmp  [calc],' '
-    je   no_calculation
+    je	 no_calculation
     cmp  [calc],'/'
     jne  no_cdiv
     fdiv [trans1]
   no_cdiv:
     cmp  [calc],'*'
     jne  no_cmul
     fmul [trans1]
   no_cmul:
     cmp  [calc],'+'
-    jne  no_cadd
-    fadd [trans1]
+    jne  no_cadd
-  no_cadd:
+    fadd [trans1]
-    cmp  [calc],'-'
+  no_cadd:
-    jne  no_cdec
-    fsub [trans1]
+    cmp  [calc],'-'
-  no_cdec:
-    call   ftoa
+    jne  no_cdec
-    call   print_display
+    fsub [trans1]
-  no_calculation:
+  no_cdec:
-    popa
+    call   ftoa
-    ret
   no_calculation:
+    call   print_display
     popa
-number_entry:
     ret
     pusha
 number_entry:
     cmp  eax,[entry_multiplier]
-    jge  no_entry
+    pusha
-    cmp  [id],1
+    cmp  eax,[entry_multiplier]
-    je   decimal_entry
     jge  no_entry
-    mov  ebx,[integer]
-    test ebx,0xF0000000
+    cmp  [id],1
-    jnz  no_entry
+    je	 decimal_entry
     mov  ebx,[integer]
-    mov  ebx,eax
+    test ebx,0xc0000000
-    mov  eax,[integer]
+    jnz  no_entry
-    mov  ecx,[entry_multiplier]
-    mul  ecx
+    mov  ebx,eax
-    add  eax,ebx
+    mov  eax,[integer]
-    mov  [integer],eax
+    mov  ecx,[entry_multiplier]
-    call print_display
+    mul  ecx
     add  eax,ebx
-    call to_muuta
     mov  [integer],eax
-    popa
-    ret
+    call print_display
-  decimal_entry:
+    call to_muuta
-    imul eax,[new_dec]
+    popa
-    add  [decimal],eax
+    ret
-    mov  eax,[new_dec]
-    xor  edx,edx
+  decimal_entry:
-    mov  ebx,[entry_multiplier]
     div  ebx
-    mov  [new_dec],eax
+    imul eax,[new_dec]
-    call print_display
+    add  [decimal],eax
+    mov  eax,[new_dec]
-    call to_muuta
+    xor  edx,edx
-    popa
+    mov  ebx,[entry_multiplier]
-    ret
+    div  ebx
     mov  [new_dec],eax
-  no_entry:
+    call print_display
     call to_muuta
-    call print_display
+    popa
-    call to_muuta
+    ret
-    popa
-    ret
+  no_entry:
     call print_display
+    call to_muuta
     popa
-to_muuta:
+    ret
-    pusha
+ to_muuta:
-    mov  al,[dsign]
+    pusha
     mov  al,[dsign]
     mov  esi,muuta0
-    mov  edi,muuta1
-    mov  ecx,18
+    mov  edi,muuta1
-    cld
+    mov  ecx,18
+    cld
     rep  movsb
+    mov  [muuta1],al
     mov  edi,muuta1+10	    ; æ¥«®¥
-    mov  [muuta1],al
+    mov  eax,[integer]
-    mov  edi,muuta1+10      ; INTEGER
+  new_to_muuta1:
     mov  eax,[integer]
-  new_to_muuta1:
+    mov  ebx,10
-    mov  ebx,10
+    xor  edx,edx
-    xor  edx,edx
+    div  ebx
-    div  ebx
-    mov  [edi],dl
-    add  [edi],byte 48
-    dec  edi
+    mov  [edi],dl
-    cmp  edi,muuta1+1
+    add  [edi],byte 48
-    jge  new_to_muuta1
-    mov  edi,muuta1+17      ; DECIMAL
-    mov  eax,[decimal]
-  new_to_muuta2:
-    mov  ebx,10
-    xor  edx,edx
-    div  ebx
-    mov  [edi],dl
-    add  [edi],byte 48
-    dec  edi
-    cmp  edi,muuta1+12
-    jge  new_to_muuta2
-    call print_muuta
-    popa
-    ret
-print_muuta:
-    pusha
-    mov  eax,13
-    mov  ebx,25*65536+125
-    mov  ecx,200*65536+22
-    mov  edx,0xffffff
-    int  0x40
-    mov  eax,4
+    dec  edi
-    mov  ebx,25*65536+200
+    cmp  edi,muuta1+1
-    mov  ecx,0x0
-    mov  edx,muuta1
+    jge  new_to_muuta1
-    mov  esi,18
+    mov  edi,muuta1+17	    ; ¤à®¡®¥
-    int  0x40
+    mov  eax,[decimal]
-    mov  eax,4
+  new_to_muuta2:
-    mov  ebx,25*65536+210
     mov  ecx,0x0
-    mov  edx,muuta2
+    mov  ebx,10
-    mov  esi,18
+    xor  edx,edx
-    int  0x40
+    div  ebx
     mov  [edi],dl
-    popa
-    ret
+    add  [edi],byte 48
     dec  edi
     cmp  edi,muuta1+12
     jge  new_to_muuta2
-new_entry:
+    popa
-    pusha
+    ret
-    mov  esi,muuta1
+new_entry:
-    mov  edi,muuta2
-    mov  ecx,18
+    pusha
-    cld
+    mov  esi,muuta1
-    rep  movsb
+    mov  edi,muuta2
     mov  ecx,18
-    mov  esi,muuta0
+    cld
-    mov  edi,muuta1
-    mov  ecx,18
-    cld
-    rep  movsb
+    rep  movsb
-    mov  [integer],0
-    mov  [decimal],0
+    mov  esi,muuta0
-    mov  [id],0
+    mov  edi,muuta1
-    mov  [new_dec],100000
-    mov  [sign],byte '+'
+    mov  ecx,18
-    popa
-    ret
+    cld
-ten        dd    10.0,0
-tmp        dw       1,0
+    rep  movsb
-sign       db       1,0
-tmp2       dq     0x0,0
+    mov  [integer],0
-exp        dd     0x0,0
-new_dec    dd  100000,0
+    mov  [decimal],0
-id         db     0x0,0
+    mov  [id],0
     mov  [new_dec],100000
-k8         dd 10000000
+    mov  [sign],byte '+'
-k8r        dq 0
+    popa
-res     dd   0
+    ret
-trans1  dq   0
+ten	   dd	 10.0,0
-trans2  dq   0
+tmp	   dw	    1,0
+sign	   db	    1,0
-controlWord dw 1
+tmp2	   dq	  0x0,0
 exp	   dd	  0x0,0
+new_dec    dd  100000,0
 id	   db	  0x0,0
-ftoa:     ; fpu st0 -> [integer],[decimal]
+res	dd   0
-    pusha
+trans1	dq   0
 trans2	dq   0
-    fst    [tmp2]
 controlWord dw 1
-    fstcw  [controlWord]      ; set truncate integer mode
     mov    ax,[controlWord]
-    mov    [tmp], ax
+ftoa:                         ; fpu st0 -> [integer],[decimal]
-    or     [tmp], word 0x0C00
+    pusha
+    fst    [tmp2]
-    fldcw  [tmp]
+    fstcw  [controlWord]      ; set truncate integer mode
-    ftst                      ; test if st0 is negative
+    mov    ax,[controlWord]
-    fstsw  ax
+    mov    [tmp], ax
-    and    ax, 4500h
+    or	   [tmp], word 0x0c00
-    mov    [sign], 0
-    cmp    ax, 0100h
+    fldcw  [tmp]
-    jne    no_neg
+    ftst                      ; test if st0 is negative
-    mov    [sign],1
-  no_neg:
+    fstsw  ax
     and    ax, 0x4500
-    fld    [tmp2]
+    mov    [sign], 0
-    fistp  [integer]
     cmp    ax, 0x0100
-    fld    [tmp2]
+    jne    no_neg
-    fisub  [integer]
     mov    [sign],1
-    fldcw  [controlWord]
-    cmp  byte [sign], 0     ; change fraction to positive
     je   no_neg2
-    fchs
+  no_neg:
-  no_neg2:
-    mov    [res],0          ; convert 6 decimal numbers
+    fistp  [integer]
-    mov    edi,6
-   newd:
+    fld    [tmp2]
+    fisub  [integer]
-    fimul  [kymppi]
-    fist   [decimal]
+    fldcw  [controlWord]
     cmp  byte [sign], 0     ; change fraction to positive
-    mov    ebx,[res]
-    imul   ebx,10
+    je	 no_neg2
-    mov    [res],ebx
+    fchs
-    mov    eax,[decimal]
-    add    [res],eax
+  no_neg2:
-    fisub  [decimal]
     mov    [res],0	    ; convert 6 decimal numbers
-    fst    [tmp2]
+    mov    edi,6
    newd:
-    ftst
-    fstsw  ax
+    fimul  [kymppi]
-    test   ax,1
+    fist   [decimal]
-    jnz    real_done
+    mov    ebx,[res]
     imul   ebx,10
-    fld    [tmp2]
+    mov    [res],ebx
     mov    eax,[decimal]
-    dec    edi
+    add    [res],eax
-    jz     real_done
+    fisub  [decimal]
+    ftst
     fstsw  ax
-    jmp    newd
-  real_done:
     dec    edi
-    mov    eax,[res]
+    jz	   real_done
-    mov    [decimal],eax
     jmp    newd
-    cmp    [integer],0x80000000      ; out of fpu limits
     jne    no_error
-    mov    [integer],0
+  real_done:
-    mov    [decimal],0
-    call   clear_all
+    mov    eax,[res]
-    mov    [calc],'E'
+    mov    [decimal],eax
-  no_error:
+    cmp    [integer],0x80000000
+    jne    no_error
-    mov    [dsign],byte '+'
-    cmp    [sign],byte 0             ; convert negative result
+    call   clear_all
-    je     no_negative
-    mov    eax,[integer]
+    mov    [calc],'E'
     not    eax
-    inc    eax
+  no_error:
-    mov    [integer],eax
+    mov    [dsign],byte '+'
+    cmp    [sign],byte 0	     ; convert negative result
-    mov    [dsign],byte '-'
+    je	   no_negative
-  no_negative:
     mov    eax,[integer]
-    call   to_muuta
+    not    eax
+    inc    eax
-    popa
+    mov    [integer],eax
+    mov    [dsign],byte '-'
     ret
   no_negative:
     call   to_muuta
-atof:
     popa
-    push ax
+    ret
-    push di
     fldz
-    mov di, 0
-    cmp si, 0
+atof:
-    je .error           ; Jump if string has 0 length.
+    push ax
+    push di
+    fldz
-    mov byte [sign], 0
+    mov di, 0
-    cmp byte [bx], '+'   ; Take care of leading '+' or '-'.
+    cmp si, 0
-    jne .noPlus
+    je .error				; Jump if string has 0 length.
-    inc di
+    mov byte [sign], 0
-    jmp .noMinus
+    cmp byte [bx], '+'	 		; Take care of leading '+' or '-'.
-  .noPlus:
+    jne .noPlus
     inc di
-    cmp byte [bx], '-'
+    jmp .noMinus
     jne .noMinus
-    mov byte [sign], 1       ; Number is negative.
-    inc di
+  .noPlus:
-  .noMinus:
-    cmp si, di
+    cmp byte [bx], '-'
-    je .error
+    jne .noMinus
     mov byte [sign], 1	            ; Number is negative.
-    call atof_convertWholePart
+    inc di
     jc .error
-    call atof_convertFractionalPart
+  .noMinus:
-    jc .error
+    cmp si, di
     je .error
-    cmp byte [sign], 0
-    je  .dontNegate
+    call atof_convertWholePart
-    fchs           ; Negate value
+    jc .error
-  .dontNegate:
+    call atof_convertFractionalPart
     jc .error
     ; Multiply current value by 10 and add in digit.
-    fmul dword [ten]
-    fiadd word [tmp]
+    fmul dword [ten]
+    fiadd word [tmp]
     inc di
-    cmp si, di     ; Jump if end of string has been reached.
+    cmp si, di	   ; Jump if end of string has been reached.
     je .exit
     jmp .mainLoop
   .error:
-    stc            ; Set error (carry) flag.
+    stc 	   ; Set error (carry) flag.
     ret
-  .exit:
-    clc            ; Clear error (carry) flag.
+  .exit:
-    ret
+    clc 	   ; Clear error (carry) flag.
+    ret
 atof_convertFractionalPart:
-    fld1      ; Load 1 to TOS.  This will be the value of the decimal place.
+atof_convertFractionalPart:
-  .mainLoop:
+    fld1           ; Load 1 to TOS.  This will be the value of the decimal place.
-    cmp si, di     ; Jump if end of string has been reached.
-    je .exit
+  .mainLoop:
     cmp si, di	   ; Jump if end of string has been reached.
-    inc di         ; Move past the decimal point.
+    je .exit
-    cmp si, di     ; Jump if end of string has been reached.
+    inc di	       ; Move past the decimal point.
-    je .exit
-    mov al, [bx + di]
+    cmp si, di	   ; Jump if end of string has been reached.
-    cmp al, '0'    ; Make sure character is a digit.
+    je .exit
-    jb .error
+    mov al, [bx + di]
-    cmp al, '9'
+    cmp al, '0'    ; Make sure character is a digit.
-    ja .error
+    jb .error
     cmp al, '9'
-    fdiv dword [ten]     ; Next decimal place
+    ja .error
     fdiv dword [ten]	 ; Next decimal place
     sub al, '0'
-    mov ah, 0
-    mov [tmp], ax
+    mov ah, 0
     mov [tmp], ax
-    ; Load digit, multiply by value for appropriate decimal place,
-    ; and add to current total.
+    ; Load digit, multiply by value for appropriate decimal place,
-    fild  word [tmp]
+    ; and add to current total.
     fmul  st0, st1
-    faddp st2, st0
+    fild  word [tmp]
-    jmp .mainLoop
+    fmul  st0, st1
     faddp st2, st0
-  .error:
-    stc            ; Set error (carry) flag.
-    fstp st0       ; Pop top of fpu stack.
+    jmp .mainLoop
-    ret
   .error:
-  .exit:
     stc 	       ; Set error (carry) flag.
+    fstp st0	   ; Pop top of fpu stack.
+    ret
-    clc            ; Clear error (carry) flag.
-    fstp st0       ; Pop top of fpu stack.
-    ret
-;   *********************************************
-;   *******  WINDOW DEFINITIONS AND DRAW ********
-;   *********************************************
-draw_window:
-    mov  eax,12                    ; function 12:tell os about windowdraw
-    mov  ebx,1                     ; 1, start of draw
-    int  0x40
-                                   ; DRAW WINDOW
-    mov  eax,0                     ; function 0 : define and draw window
-    mov  ebx,100*65536+230         ; [x start] *65536 + [x size]
-    mov  ecx,100*65536+185         ; [y start] *65536 + [y size]
-    mov  edx,0x02ffffff            ; color of work area RRGGBB,8->color gl
-    mov  esi,0x805977bb            ; color of grab bar  RRGGBB,8->color gl
-    mov  edi,0x005977bb            ; color of frames    RRGGBB
-    int  0x40
-                                   ; CLOSE BUTTON
-    mov  eax,8                     ; function 8 : define and draw button
+  .exit:
-    mov  ebx,(230-18)*65536+12     ; [x start] *65536 + [x size]
+    clc 	   		 ; Clear error (carry) flag.
-    mov  ecx,4*65536+12            ; [y start] *65536 + [y size]
+    fstp st0	   ; Pop top of fpu stack.
-    mov  edx,1                     ; button id
+    ret
     mov  esi,0x335599              ; button color RRGGBB
-    int  0x40
+;   *********************************************
 ;   *******     ********
-                                   ; WINDOW LABEL
+;   *********************************************
-    mov  eax,4                     ; function 4 : write text to window
-    mov  ebx,8*65536+8             ; [x start] *65536 + [y start]
+draw_window:
     mov  ecx,0x00ddeeff            ; color of text RRGGBB
-    mov  edx,labelt                ; pointer to text beginning
+    mcall 12,1
-    mov  esi,labellen-labelt       ; text length
+    mcall 0,200*65536+255,200*65536+180,0x03ddeeff   ; äãªæ¨ï 0: ®¯à¥¤¥«¨âì ¨ ®âà¨á®¢ âì ®ª®
-    int  0x40
     mcall 4,8*65536+8,0x10000000,labelt,label_len    ;
     mov  ebx,24*65536+25+3
-    mov  ecx,70*65536+17
+    mov  ebx,24*65536+28
-    mov  edx,6
+    mov  ecx,70*65536+18
-    mov  esi,0x303090;cc2211
+    mov  edx,6
-    mov  edi,7
+    mov  esi,0x0066ee
-  newbutton:
-    dec  edi
-    jnz  no_new_row
-    mov  edi,6
-    mov  ebx,24*65536+25+3
-    add  ecx,20*65536
+    mov  edi,7
-  no_new_row:
-    mov  eax,8
-    int  0x40
-    add  ebx,30*65536
-    inc  edx
+  newbutton:
-    cmp  edx,11+24
+    dec  edi
-    jbe  newbutton
+    jnz  no_new_row
     mov  edi,7
-    mov  eax,8                     ; CLEAR ALL
+    mov  ebx,24*65536+25+3
+    add  ecx,20*65536
-    mov  ebx,25*65536+27
+  no_new_row:
-    mov  ecx,41*65536+15
+    mcall 8
-    mov  edx,2
-    int  0x40
+    add  ebx,30*65536
+    inc  edx
-    mov  eax,8                     ; CHANGE DISPLAY TYPE
+    cmp  edx,39
-    mov  ebx,203*65536+7
+    jbe  newbutton
-    mov  ecx,28*65536+7
     mov  edx,3
-    int  0x40
-    mov  ebx,25*65536+35           ; draw info text with function 4
-    mov  ecx,0xffffff ; 224466
+    mcall 8,225*65536+8,28*65536+8,3                    ; 'dec-bin-hex'
-    mov  edx,text
-    mov  esi,30
+    mcall 8,204*65536+28,70*65536+18,2,0xcc0000         ; 'C'
-  newline:
-    mov  eax,4
     int  0x40
-    add  ebx,10
-    add  edx,30
+    mov  ebx,25*65536+75                                ; à®à¨á®¢ª  ¯®¤¯¨á¥© ª®¯®ª
-    cmp  [edx],byte 'x'
-    jne  newline
+    mov  ecx,0xffffff
-    call print_display
+    mov  edx,text
+    mov  esi,34
-    mov  eax,12                    ; function 12:tell os about windowdraw
-    mov  ebx,2                     ; 2, end of draw
     int  0x40
+  newline:
-    ret
-print_display:
-    pusha
     mcall 4
-    mov  eax,13
+    add  ebx,20
-    mov  ebx,59*65536+143
+    add  edx,34
-    mov  ecx,24*65536+44
+    cmp  [edx],byte 'x'
-    mov  edx,0xffffff
+    jne  newline
-    int  0x40
+    call print_display
+    mcall 12,2
-    mov  eax,4
+    ret
+print_display:
+    pusha
+    mcall 13,100*65536+120,25*65536+13,0x00ddeeff
+    mcall 13,23*65536+210,40*65536+13,0xffffff
-    mov  ebx,120*65536+28
+    mcall 4,140*65536+28,0,calc,1
-    mov  ecx,0
-    mov  edx,calc
-    mov  esi,1
-    int  0x40
     mov  eax,4
-    mov  ebx,175*65536+28
+    mov  ebx,203*65536+29
-    mov  ecx,0
-    mov  edx,[display_type]
-    shl  edx,2
+    mov  ecx,0
-    add  edx,display_type_text
-    mov  esi,3
+    mov  edx,[display_type]
+    shl  edx,2
-    int  0x40
+    add  edx,display_type_text
+    mov  esi,3
-    cmp  [display_type],0   ; display as desimal
+    int  0x40
-    jne  no_display_decimal
-    mov  eax,47
+    cmp  [dsign],byte '+'
-    mov  ebx,11*65536   ; 11 decimal digits for 32 bits
-    mov  ecx,[integer]
-    mov  edx,84*65536+44
+    je  positive
-    mov  esi,0x0
-    int  0x40
+    mcall 4,28*65536+43,0x0,dsign,1
-    mov  eax,47
-    mov  ebx,6*65536
-    mov  ecx,[decimal]
+positive:
-    mov  edx,156*65536+44
+    cmp  [display_type],0                            ; ¤¥áïâ¨ç ï á¨áâ¥¬  áç¨á«¥¨ï
-    mov  esi,0x0
+    jne  no_display_decimal
-    int  0x40
+    cmp  [decimal],0
+    je   whole
+    mcall 47,10*65536,[integer],125*65536+43,0x0     ; ®â®¡à ¦ âì 10 æ¨äà
-    mov  eax,4
+    mcall 4,185*65536+43,0x0,dot,1
-    mov  ebx,150*65536+44
+    mcall 47,6*65536,[decimal],192*65536+43,0x0      ; ®â®¡à ¦ âì 6 æ¨äà ¯®á«¥ § ¯ïâ®©
-    mov  ecx,0x0
-    mov  edx,dot
-    mov  esi,1
-    int  0x40
-    mov  eax,4
-    mov  ebx,77*65536+44
-    mov  ecx,0x0
-    mov  edx,dsign
-    mov  esi,1
+    popa
-    int  0x40
-  no_display_decimal:
+    ret
-    cmp  [display_type],1
+whole:
-    jne  no_display_hexadecimal
+    cmp  [integer],0
+    je  null
-    mov  eax,4
+    mcall 47,10*65536,[integer],165*65536+43,0x0
-    mov  ebx,138*65536+44
+    mcall 4,225*65536+43,0x0,dot,1
-    mov  ecx,0x0
-    mov  edx,dsign
-    mov  esi,1
+    popa
-    int  0x40
+    ret
-    mov  eax,47
-    mov  ebx,1*256+8*65536   ; 8 hexadecimal digits for 32 bits
-    mov  ecx,[integer]
+  no_display_decimal:
-    mov  edx,144*65536+44
+    cmp  [integer],0
-    mov  esi,0x0
+    je  null
-    int  0x40
+    cmp  [display_type],1
-  no_display_hexadecimal:
+    jne  no_display_hexadecimal
+    mcall 47,1*256+8*65536,[integer],178*65536+43,0x0    ; ®â®¡à ¦ âì 8 è¥áâ ¤æ â¨à¨çëå æ¨äà
+    popa
-    cmp  [display_type],2
+    ret
-    jne  no_display_binary
-    mov  eax,4
+  no_display_hexadecimal:
-    mov  ebx,96*65536+44
+    cmp  [integer],0
-    mov  ecx,0x0
-    mov  edx,dsign
+    je  null
-    mov  esi,1
-    int  0x40
+    cmp  [display_type],2
-    mov  eax,47
+    jne  null
-    mov  ebx,2*256+15*65536   ; 16 binary digits for 32 bits
+    mcall 47,2*256+32*65536,[integer],37*65536+43,0x0    ; ®â®¡à ¦ âì 32 ¤¢®¨çë¥ æ¨äàë
-    mov  ecx,[integer]
+    popa
-    mov  edx,102*65536+44
+    ret
     mov  esi,0x0
     mov  esi,muuta0
     mov  edi,muuta2
     mov  ecx,18
     cld
     rep  movsb
-    call print_muuta
     call print_display
     popa
     ret
-; DATA AREA
+;¡« áâì ¤ ëå
-display_type       dd   0   ; 0 = decimal, 1 = hexadecimal, 2= binary
+display_type       dd  0    ; 0 = decimal, 1 = hexadecimal, 2= binary
-entry_multiplier   dd  10
-display_start_y    dd  0x0
-display_type_text  db 'dec hex bin'
+entry_multiplier   dd  10
 display_start_y    dd  0x0
-dot     db  '.'
+display_type_text  db  'dec hex bin'
 calc    db  ' '
 dot	db  '.'
-integer dd    0
+calc	db  ' '
-decimal dd    0
+integer dd    0
+decimal dd    0
-kymppi  dd   10
 kymppi  dd   10
-dsign:
-muuta1  db   '+0000000000.000000'
-muuta2  db   '+0000000000.000000'
-muuta0  db   '+0000000000.000000'
-text:
+dsign:
-    db '                              '
-    db '  C                           '
+muuta1	db   '+0000000000.000000'
-    db '                              '
-    db '                              '
+muuta2	db   '+0000000000.000000'
-    db '  A    B    C    D    E    F  '
-    db '                              '
+muuta0	db   '+0000000000.000000'
-    db '  1    2    3    +   SIN  INT '
-    db '                              '
-    db '  4    5    6    -   COS  LG2 '
-    db '                              '
-    db '  7    8    9    /   TAN   P  '
-    db '                              '
+text:
+    db '  A    B    C    D    E    F    C '
-    db ' -/+   0    .    *   SQR   =  '
+    db '  1    2    3    +   Int  Sin Asin'
-    db '                              '
+    db '  4    5    6    -   1/x  Cos Acos'
-    db 'x <- END MARKER, DONT DELETE  '
+    db '  7    8    9    /   x^2  Tan Atan'
-asci:  db 49,50,51,52,53,54,55,56,57,48,43,61,45,42,47,44,46,52,13,97,98,99,100
-       db 101,102,65,66,67,68,69,70,112,80,27,182
+    db ' +/-   0    .    *   Sqr  Pi    = '
-butid: db 12,13,14,18,19,20,24,25,26,31,15,35,21,33,27,32,32,33,35,6,7,8,9,10,11
-       db 6,7,8,9,10,11,29,29,2,2
-labelt:
-      db   'FPU CALCULATOR'
-labellen:
+    db 'x'

Subversion Repositories Kolibri OS

(root)/programs/calc/trunk/calc.asm – Rev 31 → 107