8086汇编语言 高精度编写与计算器初步

交完作业了

这里把代码贴在这

支持

1、高精度浮点数运算

2、越界检测

3、算式合法性检测

4、音乐播放

 

算是熟悉一下汇编语言了orz

assume cs:debugs
debugs segment
    str db 'wtf', '$'
    debug:
        push ax
        push ds
        push dx

        mov ax, debugs
        mov ds, ax
        mov dx, 0
        mov ah, 9
        int 21h

        pop dx
        pop ds
        pop ax

        retf

    input:
        push ax
        push ds
        push dx

        mov ax, stringget
        mov ds, ax
        lea dx, inputstr
        mov ah, 9
        int 21h

        pop dx
        pop ds
        pop ax

        retf
    output:
        push ax
        push ds
        push dx

        mov ax, stringget
        mov ds, ax
        lea dx, outputstr
        mov ah, 9
        int 21h

        pop dx
        pop ds
        pop ax

        retf
    illegalf:
        push ax
        push ds
        push dx

        mov ax, stringget
        mov ds, ax
        lea dx, illegal
        mov ah, 9
        int 21h

        pop dx
        pop ds
        pop ax

        retf
    oorf:
        push ax
        push ds
        push dx

        mov ax, stringget
        mov ds, ax
        lea dx, OOR
        mov ah, 9
        int 21h

        pop dx
        pop ds
        pop ax

        retf

    music:
        ; DI frequency
        push ax
        push bx
        push cx
        push dx
        push si
        push di
        mov bx, 1
        mov al, 0b6h
        out 43h, al
        mov dx, 12h
        mov ax, 348ch
        div di
        out 42h, al
        mov al, ah
        out 42h, al
        in al, 61h
        mov ah, al
        or al, 3
        out 61h, al
        musicwait: mov cx, 2800h
        musicdelay:
            loop musicdelay
            dec bx
            jnz musicwait
        mov al, ah
        out 61h, al
        pop di
        pop si
        pop dx
        pop cx
        pop bx
        pop ax
        retf

debugs ends



assume ds:stringget
stringget segment
    BUFFER db 111
           db ?
    STRING db 111 DUP(?)
    inputstr db 'Please input your formula:$'
    outputstr db 'The result:$'
    illegal db 'Illegal formula!$'
    OOR db 'Out of range!$'
stringget ends

assume es:extra
extra segment
    MESS DB 111 DUP(?)
    ENTER DB 10,13,'$'
    INTA DW 111 DUP(0)
    INTB DW 111 DUP(0)
    INTC DW 111 DUP(0)
    INTD DW 111 DUP(0)
    INTE DW 111 DUP(0)
    ZERO DW 111 DUP(0)
extra ends

assume es:musictable
musictable segment
    DW 50, 147, 165, 175, 196, 220, 247, 262, 294, 330, 349
musictable ends

assume cs:cins   ; get string, save in MESS, length save in bl
cins segment
cin:
    push cx
    push ax
    push dx
    push di
    push si

    mov ax, stringget
    mov ds, ax
    lea si, BUFFER

    mov ds:[si], dl
    inc si
    mov ax, extra
    mov es, ax

    lea dx, BUFFER
    mov ah, 0ah
    int 21h

    lea si,STRING
    lea di,MESS
    mov ch,0
    mov cl,BUFFER+1
    cld
    rep movsb
    mov al,'$'
    mov es:[di],al

    push es
    pop ds
    mov bl, BUFFER+1

    pop si
    pop di
    pop dx
    pop ax
    pop cx
    retf

check:
    ;si check the string
    ;return bx
    push ax
    push cx
    push dx
    push si
    push di

    mov ax, extra
    mov ds, ax
    sub bx, bx
    dec si
    check1:
        inc si
        mov ah, ds:[si]
        cmp ah, 36
        je check2
        mov ch, ah
        and ch, 16
        cmp ch, 0
        ja check1
        cmp ah, 43
        je check1
        cmp ah, 45
        je check1
        cmp ah, 46
        je check1
        cmp ah, 42
        je check1
        mov bx, 1
    check2:
    pop di
    pop si
    pop dx
    pop cx
    pop ax

    retf
cins ends

assume cs:couts
couts segment
cout:
    push ds
    push ax
    mov ax, extra
    mov ds, ax
    sub ax, ax
    mov ah, 09h
    lea dx, ENTER
    int 21h
    pop ax
    pop ds
    retf
couts ends

assume cs:bigint
bigint segment

checkoor:
    push ax
    push bx
    push cx
    push dx
    push si
    push di


    mov si, ax
    mov ax, extra
    mov ds, ax
    mov di, si
    add si, 180
    add di, 220
    checkoor1:
        mov ax, ds:[si]
        cmp ax, 0
        jne returnoor
        add si, 2
        cmp si, di
        je checkoor2
        jmp checkoor1
    returnoor:
        call far ptr oorf
        mov ah, 4ch
        int 21h
    checkoor2:
    pop di
    pop si
    pop dx
    pop cx
    pop bx
    pop ax
    retf

cinint:
    ; di: address of INT; si: address of str
    ; exit di and si
    push ax
    push bx
    push cx
    push dx

    mov ax, extra
    mov ds, ax

    sub ax, ax
    mov ds:[di], ax
    mov dx, di
    add di, 100

    mov al, ds:[si]
    mov cl, al
    and cl, 16
    je rreturn1
    jmp rreturn2
    rreturn1: call far ptr return1
    rreturn2:

    mov bx, 0
    cinint1:
        mov al, ds:[si]
        mov cx, ax
        and cx, 16

        je cinint2
        sub ah, ah
        sub ax, 48
        push ax
        inc si
        inc bx
        jmp cinint1
    cinint2:
        pop ds:[di]
        add di, 2
        dec bx
        jne cinint2
    sub bx, bx
    mov di, dx
    add di, 100

    mov cx, ax
    cmp cx, 46
    je cinint3
    jmp cinint4
    cinint3:
        inc si
        sub ax, ax
        mov al, ds:[si]
        mov cx, ax
        and cx, 16
        je cinint4
        sub ah, ah
        sub ax, 48
        sub di, 2
        mov ds:[di], ax
        jmp cinint3
    cinint4:

    pop dx
    pop cx
    pop bx
    pop ax
    retf

coutint:
    ;di address of bigint
    push ax
    push bx
    push cx
    push dx
    push si
    push di

    mov ax, extra
    mov ds, ax
    mov dx, di
    mov ax, ds:[di]
    add di, 2
    cmp ax, 0
    jne coutint1
    jmp coutint2
    coutint1:   ;signal
        mov ah, 02h
        push dx
        mov dl, 45
        int 21h
        pop dx
    coutint2:
        mov cx, dx
        add cx, 100
        mov bx, dx
        add bx, 2
        coutint3:
            mov ax, ds:[bx]
            add bx, 2
            cmp bx, cx
            je coutint4
            cmp ax, 0
            je coutint3
    coutint4:
        mov si, dx
        add si, 200
        coutint5:
            mov ax, ds:[si]
            cmp si, cx
            je coutintsave
            sub si, 2
            cmp ax, 0
            je coutint5
        add si, 2
    coutintsave:
        mov di, si
    coutint6:
        mov ah, 02h
        mov dx, ds:[si]
        add dx, 48
        int 21h
        cmp si, cx
        je coutint7
        sub si, 2
        jmp coutint6
    coutint7:
        mov ah, 02h
        mov dx, 46
        int 21h
        sub si, 2
        sub bx, 2
        coutint8:
            mov ah, 02h
            mov dx, ds:[si]
            add dx, 48
            int 21h
            cmp si, bx
            je coutint9
            sub si, 2
            jmp coutint8
    coutint9:
    coutmusic:
        push di
        mov si, di
        mov ax, musictable
        mov es, ax
        coutmusic1:
            mov ax, ds:[si]
            shl ax, 1
            mov di, ax
            mov di, es:[di]
            call far ptr music
            sub si, 2
            cmp si, bx
            je coutmusic2
            jmp coutmusic1
    coutmusic2:
        pop di
        jmp coutmusic
    pop di
    pop si
    pop dx
    pop cx
    pop bx
    pop ax

    retf

sumint:
    ; address of ax, bx
    push dx
    push cx
    push si
    push di

    mov si, extra
    mov ds, si
    mov si, ax
    mov di, bx
    ; 0 + 1 -
    mov cx, ds:[si]
    mov dx, ds:[di]
    shl cx, 1
    add cx, dx
    cmp cx, 3
    je case11
    cmp cx, 2
    je case10
    cmp cx, 1
    je case01
    cmp cx, 0
    je case00
    case11:
        call far ptr addint
        jmp sumint2
    case00:
        call far ptr addint
        jmp sumint2
    case10:
        mov cx, ax
        mov ax, bx
        mov bx, cx
        call far ptr subint
        jmp sumint2
    case01:
        call far ptr subint
    sumint2:

    pop di
    pop si
    pop dx
    pop cx
    retf

cmpint:
    ;return cx, cx = 1 > , cx = 0 <
    push ax
    push bx
    push dx
    push si
    push di

    mov si, ax
    mov di, bx
    mov dx, si
    add si, 200
    add di, 200
    cmpint1:
        mov ax, ds:[si]
        mov bx, ds:[di]
        sub si, 2
        sub di, 2
        cmp si, dx
        je cmpint10
        cmp ax, bx
        je cmpint1
        cmp ax, bx
        ja cmpint11
        jmp cmpint10

    cmpint10:
        sub cx, cx
        jmp cmpint2
    cmpint11:
        mov cx, 1
        jmp cmpint2

    cmpint2:
    pop di
    pop si
    pop dx
    pop bx
    pop ax
    retf

addint:
    push ax
    push bx
    push cx
    push dx
    push si
    push di

    sub cx, cx
    sub dx, dx
    mov si, ax
    mov di, bx
    mov bx, 1
    addint1:
        add si, 2
        add di, 2
        mov ax, ds:[si]
        add ax, ds:[di]
        add ax, cx
        cmp ax, 9
        ja addcx
        sub cx, cx
        jmp naddcx
        addcx:
            mov cx, 1
            sub ax, 10
        naddcx:
        mov ds:[si], ax
        inc bx
        cmp bx, 100
        je addint2
        jmp addint1
    addint2:

    pop di
    pop si
    pop dx
    pop cx
    pop bx
    pop ax
    retf

subint:
    ; ax - bx
    push ax
    push bx
    push cx
    push dx
    push si
    push di
    call far ptr cmpint
    cmp cx, 0
    je subint1
    jmp subint2
    subint1:
        mov dx, ax
        mov ax, bx
        mov bx, dx
    subint2:
    mov si, ax
    mov di, bx
    xor cx, 1
    mov ds:[si], cx
    mov dx, 1
    sub bx, bx
    ;bx record -1
    subint3:
        add si, 2
        add di, 2
        mov ax, ds:[si]
        sub ax, ds:[di]
        sub ax, bx
        cmp ax, 9
        ja subint4
        mov bx, 0
        jmp subint5
        subint4:
            mov bx, 1
            add ax, 10
        subint5:
        mov ds:[si], ax
        inc dx
        cmp dx, 100
        je subint6
        jmp subint3

    subint6:
    cmp cx, 1
    je subint7
    jmp subint8
    subint7:
        sub si, 198
        sub di, 198
        mov bx, si
        mov ax, di
        call far ptr equalint
    subint8:
    pop di
    pop si
    pop dx
    pop cx
    pop bx
    pop ax
    retf

equalint:
    ; mov bx to ax
    push ax
    push bx
    push cx
    push dx
    push si
    push di
    mov si, ax
    mov di, bx
    mov ax, extra
    mov ds, ax
    sub ax, ax
    equalint1:
        mov bx, ds:[di]
        mov ds:[si], bx
        add si, 2
        add di, 2
        inc ax
        cmp ax, 110
        je equalint2
        jmp equalint1
    equalint2:
    pop di
    pop si
    pop dx
    pop cx
    pop bx
    pop ax
    retf

shrint:
    ;ax:address of X, cx:shr
    push ax
    push bx
    push cx
    push dx
    push si
    push di

    mov bx, extra
    mov ds, bx
    mov si, ax
    shrint1:
        inc cx
        mov di, si
        add di, 2
        shrint2:
            add di, 2
            mov bx, ds:[di]
            sub di, 2
            mov ds:[di], bx
            add di, 2
            mov bx, si
            add bx, 200
            cmp di, bx
            je shrint3
            jmp shrint2
        shrint3:
        cmp cx, 50
        je shrint4
        jmp shrint1
    shrint4:
    pop di
    pop si
    pop dx
    pop cx
    pop bx
    pop ax
    retf

shlint:
    ;ax:address of X, cx:shl
    push ax
    push bx
    push cx
    push dx
    push si
    push di
    inc cx
    mov bx, extra
    mov ds, bx
    mov si, ax
    cmp cx, 50
    je shlint4
    cmp cx, 50
    ja shlint1
    call far ptr shrint
    jmp shlint4
    shlint1:
        dec cx
        mov di, si
        add di, 200
        shlint2:
            mov bx, ds:[di]
            add di, 2
            mov ds:[di], bx
            sub di, 4
            cmp di, si
            je shlint3
            jmp shlint2
        shlint3:
        add di, 2
        sub bx, bx
        mov ds:[di], bx
        cmp cx, 50
        je shlint4
        jmp shlint1
    shlint4:
    pop di
    pop si
    pop dx
    pop cx
    pop bx
    pop ax
    retf

mulint:
    push ax
    push bx
    push cx
    push dx
    push si
    push di
    mov cx, extra
    mov ds, cx
    mov si, ax
    mov di, bx

    mov cx, ds:[di]
    xor ds:[si], cx

    lea ax, INTD
    lea bx, ZERO
    call far ptr equalint

    mov cx, -1
    mulint1:
        inc cx
        cmp cx, 100
        je mulint3
        add di, 2
        lea ax, INTE
        lea bx, ZERO
        call far ptr equalint
        mov dx, ds:[di]
        cmp dx, 0
        je mulint1
        mulint2:
            lea ax, INTE
            mov bx, si
            call far ptr addint
            dec dx
            jne mulint2
        lea ax, INTE
        call far ptr shlint
        lea ax, INTD
        lea bx, INTE
        call far ptr addint
        jmp mulint1
    mulint3:
    add si, 2
    mov ax, si
    lea bx, INTD+2
    call far ptr equalint

    pop di
    pop si
    pop dx
    pop cx
    pop bx
    pop ax
    retf

bigint ends

;子程序及段的说明
;debugs:用于debug测试输出
;debug：输出一行"wtf"（测试输出）
;input:输出提示信息"Please input..."
;output:输出结果信息"The result:"
;illegalf:提示非法输入"illegal formula"
;oorf:提示运算越界"out of range"
;stringget:字符串储存位置
;extra：数的储存位置
;cin:用于用户输入数学算式，并将结果存到MESS中
;cout:输出一个换行
;check:检测用户读入中是否有非法字符
;cinint:从指定的字符串si中读取一个实数每一位，存入di指向的内存空间中，
;并检测是否有非法输入（如读不到数字就为非法）
;coutint:从指定的di内存空间中读取，并在屏幕上输出一个实数
;checkoor:从指定的di内存空间中读取一个实数，并检测它是否越界（大于10的40次方视为越界）
;sumint:根据2个数（取ax，bx指向的空间）的正负情况进行运算，将情况分成4种
;addint:将2个实数（取ax，bx指向的空间）相加，结果存到ax指向的内存空间中
;subint:将2个实数（取ax，bx指向的空间）相减，结果存到ax指向的内存空间中
;mulint:将2个实数（取ax，bx指向的空间）相乘，结果存到ax指向的内存空间中
;shlint:将实数（取ax指向的空间）左移，位数由cx决定，结果存到a指向的内存空间中
;shrint:将实数（取ax指向的空间）右移，位数由cx决定，结果存到a指向的内存空间中
;cmpint:将2个实数（取ax，bx指向的空间）进行比较，如果大于则cx为1，小于等于则cx为0
;equalint:将实数B赋值给实数A（取ax，bx指向的空间）

assume cs:code
code segment
    start:
        mov ax, extra
        mov ds, ax
        sub ax, ax
        mov ah, 00h
        int 10h

        call far ptr input
        call far ptr cout

        call far ptr cin
        call far ptr cout
        lea si, MESS
        call far ptr check
        cmp bx, 1
        je return1
        jmp return2
        return1:
            call far ptr illegalf
            mov ah, 4ch
            int 21h
        return2:


        lea si, MESS
        lea di, INTB
        call far ptr cinint
        lea ax, INTA
        lea bx, ZERO
        call far ptr equalint
        loop1:
            lea ax, INTA
            call far ptr checkoor
            lea ax, INTB
            call far ptr checkoor
            lea ax, INTC
            lea bx, ZERO
            call far ptr equalint
            mov al, ds:[si]
            cmp al, 36
            je overall
            jmp noverall
            overall: call loop2
            noverall:
            inc si
            lea di, INTC
            call far ptr cinint

           jia:
                cmp al, 43
                jne jian
                lea ax, INTA
                lea bx, INTB
                call far ptr sumint
                mov cx, ax
                lea ax, INTA
                mov bx, cx
                call far ptr equalint
                lea ax, INTB
                lea bx, INTC
                call far ptr equalint
                jmp loop1
            jian:
                cmp al, 45
                jne cheng
                lea ax, INTA
                lea bx, INTB
                call far ptr sumint
                mov cx, ax
                lea ax, INTA
                mov bx, cx
                call far ptr equalint
                lea ax, INTB
                lea bx, INTC
                mov cx, 1
                mov ds:[bx], cx
                call far ptr equalint
                jmp loop1
            cheng:
                cmp al, 42
                jne forcheck
                lea ax, INTB
                lea bx, INTC
                call far ptr mulint
                jmp loop1
            forcheck:
                cmp al, 36
                jne freturn1
                jmp loop2
                freturn1: call far ptr return1
        loop2:
        lea ax, INTA
        lea bx, INTB
        call far ptr sumint
        call far ptr cout
        call far ptr output
        mov di, ax
        call far ptr coutint
        mov ah, 4ch
        int 21h

code ends
end start