.model large
.stack 64
.data 
  num1 db 6 dup(' ')
  num2 db 6 dup(' ')
  num3 db 6 dup(' '),"$"
  num dw 0
  num11 dw 0
  dolar db "$"
  msg1 db 13,10,"num1 : $",13,10
  msg2 db 13,10,"num2 : $",13,10
  msg3 db 13,10,"res : $",13,10
.code
main proc far
mov ax,@data
mov ds,ax

call cls

mov ah,9
lea dx,msg1
int 21h

lea dx,num1
call get_num
mov bx,num
mov num11,bx

mov ah,9
lea dx,msg2
int 21h

lea dx,num2
call get_num
mov bx,num
add bx,num11

mov ax,bx
mov dx,0
mov cx,10
div cx
add dl,30h
lea si,num3
mov [si],dl

cmp ax,0
jz l1
mov dx,0
div cx
add dl,30h
mov [si+1],dl

cmp ax,0
jz l1
mov dx,0
div cx
add dl,30h
mov [si+2],dl

cmp ax,0
jz l1
mov dx,0
div cx
add dl,30h
mov [si+3],dl

cmp ax,0
jz l1
mov dx,0
div cx
add dl,30h
mov [si+4],dl

cmp ax,0
jz l1
mov dx,0
div cx
add dl,30h
mov [si+5],dl

l1:
mov ah,9
lea dx,msg3
int 21h

mov ah,9
lea dx,num3
int 21h

mov ax,4c00h
int 21h
main endp

cls   proc       far
         push      ax
         push      bx
         push      dx
         pushf   
         mov      ah, 6h   ;clear screen
         mov      al, 25   ;number of rows
         mov      ch, 0
         mov      cl, 0
         mov      dh, 24   ;row
         mov      dl, 79   ;column
         mov      bh, 7    ;attribute
         int      10h
         popf
         pop      dx
         pop      bx
         pop      ax
         
         retf

cls   endp
get_num       proc       far       
            push    bp 
            mov     bp, sp
            push      si 
            push      bx
            push      cx
            push      dx

            
            mov     ah, 3fh
            mov     dx, [bp+06] 
            mov     bx, 0000h
            mov     cx,8
            int     21h

              
              mov      si, dx 
while_blank:  cmp      byte ptr [bx], ' '        ; skip leading blank
              jne      end_while_blank   ; exit while
              inc      bx
              jmp      while_blank
end_while_blank:
              mov      bl, 1               ;default sign multiplier
              cmp      byte ptr [si], '+'  ;leadin + ?
              je       skip_sign           ;if so skip over
              cmp      byte ptr [si], '-'  ;leading - ?
              jne      save_sign           ;if not save default +
              mov      bl, -1              ;-1 for minus sign
skip_sign:    inc      si                  ;past sign

save_sign:    mov      ax, 0               ;number being accumulated
              mov      bh, 0               ;count of digits so far
while_digit:  cmp      byte ptr [si], '0'  ;compare next car to '0'
              jl       end_while_digit     ;if not a digit exit
              cmp      byte ptr [si], '9'  ;compare to '9'
              jg       end_while_digit     ;not a digit if bigger than '9'
              mov      cx, 10              ;multiplier
              mul      cx                  ;multiply old number by 10
              mov      cl, [si]            ;mov ascii char to bl
              and      cx, 000fh           ;convert to single digit integer
              add      ax, cx              ;add to sum
              inc      bh               ;increment digit count
              inc      si                  ;increment character pointer
              jmp      while_digit         ;go next char
end_while_digit:
              ; imul      bl
               cmp        bl, 1
               je         exit1
               neg        ax
            exit1:
               mov       num, ax
              
              pop      dx
              pop      bx
              pop      cx
              pop      si 
              pop       bp

               retf 2
get_num        endp


convert_num_string   proc      far

              push      bp
              mov       bp, sp
              push      si 
              push      ax
              push      bx
              push      cx
              push      dx
              mov      ax, word ptr[bp+08]
              mov      si, word ptr[bp+06]

              add      si, 5
              mov      bh, ' '
              cmp      ax, 0
              jge      setup         ; skip if not negative
              mov      bh, '-'
              neg      ax            ; now ax > 0

setup:        mov      cx, 10        ; divisor
divloop:      mov      dx, 0         ; extend number to double word
              div      cx            ; divide by 10
              add      dl, 30h       ; convert
              mov      [si], dl
              dec      si
              cmp      ax, 0
              jne      divloop
              mov      cl, bh       ; insert sign to string
              mov      [si], cl
              
              pop      dx
              pop      bx
              pop      cx
              pop      ax
              pop      si
              pop       bp
              
              retf     4

convert_num_string   endp
end main

• Re:asm2 (5560) maryamajdari 2008-12-01 19:00:58
• Re:asm2 (5560) negarabdol 2008-12-31 19:22:11
  • Re:asm2 (6) Jiessie 2009-02-19 12:30:53