zoukankan      html  css  js  c++  java
  • 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
  • 相关阅读:
    vue 之 vuex
    vue中this.$router.push() 传参
    ES6新特性
    css优先级
    创建第一个vue工程
    对Vue.js的认知
    前端的认知与见解
    Web前端常见问题
    数据库如何进行索引优化
    Python FAQ
  • 原文地址:https://www.cnblogs.com/Saurus/p/7091755.html
Copyright © 2011-2022 走看看