简单的计算器模拟程序的设计和实现

简单的计算器模拟程序的设计和实现1.问题描述
对任意给定的正确四则运算表达式，程序计算其结果值并输出。

程序无需查错功能，假定所输入的都是正确的四则运算表达式，并且表达式中运算分量均为无正负号整数，运算符为 +、-、*、/，表达式以字符 "=" 结束。

程序应有操作提示、输入和输出，界面追求友好，最好是菜单式的界面。

2.设计说明
2.1简要的分析
根据要求，要先输入包含有+，-，*，/的运算符的表达式，然后经过计算得到正确的答案。

从键盘中输入的是ASCII码，因此要将其转换为十进制的数据然后才能进行计算。

如果输入混合表达式，要将中缀式先变化成后缀式，然后再进行计算。

2.2概要分析
2.2.1 定义的数据段
用于定义一些中间变量，并将显示在试验界面上，以及提示信息。

data segment
stri db 50 dup(0)
exp db 30 dup(0)
track db 30 dup(0)
instr db 100 dup(0)
msg0 db 'please input your formular:',0dh,0ah,'$'
msg1 db 0dh,0ah,'wrong input','$'
msg2 db 0dh,0ah,') and ( does not match','$'
msg3 db 0dh,0ah,'div zero error','$'
msg4 db 0dh,0ah,'sorry,minus data appears','$'
msg5 db 0dh,0ah,'any key to continue,esc to exit','$'
data ends
2.2.2 定义的堆栈段
声明用于将中缀表达式转换为后缀表达式，以及进行后缀表达式求值过程用到的堆栈段。

stack segment para stack
dw 256 dup(0)
stack ends
2.2.3 用到的子过程
2.2.
3.1 compare子过程
作用：用于判断键盘输入的符号是否合法，若合法，则在屏幕上显示，否则报错。

2.2.
3.2 mult子过程
作用：用于对输入的数字进行乘10累加操作，以便将连续输入的数字字符串转换为相对应的数值。

2.2.
3.3 trans子过程
作用：将输入的中缀表达式转换为后缀表达式。

2.2.
3.4 value子过程
作用：将后缀表达式结合堆栈结构进行表达式求值。

2.2.
3.5 divi子过程
作用：通过除以10以及进一步处理将某数值转换为相应的ASCII字符串。

2.2.
3.6 print子过程
作用：将表达式求值结果输出到屏幕上。

3.详细的算法描述
3.1.程序运行流程
3.2程序代码
STACK SEGMENT PARA STACK
DW 256 DUP(0)
STACK ENDS
DATA SEGMENT
STRI DB 50 DUP(0)
EXP DB 30 DUP(0)
TRACK DB 30 DUP(0)
INSTR DB 100 DUP(0)
MSG0 DB 'please input the formular:',0DH,0AH,'$'
MSG1 DB 0DH,0AH,'sorrry,wrong input','$'
MSG2 DB 0DH,0AH,') and ( does not match','$'
MSG3 DB 0DH,0AH,'div by zero error','$'
MSG4 DB 0DH,0AH,'sorry,minus data appears','$'
MSG5 DB 0DH,0AH,'any key to continue,esc to exit','$'
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,SS:STACK,DS:DATA START: MOV AX,STACK
MOV SS,AX
MOV AX,DATA
MOV DS,AX
MOV DX,OFFSET MSG0
MOV AH,9
INT 21H
XOR AX,AX
;READ
MOV BX,OFFSET INSTR
MOV DL,20H
JMP L2
COMPARE PROC NEAR
CMP AL,0DH
JZ L2
MOV DL,AL
MOV AH,2
INT 21H
RET
COMPARE ENDP
L2: MOV AH,8
INT 21H
CALL COMPARE
CMP AL,3DH ;end with '='
JZ L2_OVER
MOV AH,39H
CMP AH,AL ;del the wrong data ( > 9 )
JNB CONTI
MOV AH,2
MOV DL,8
INT 21H
MOV DL,20H
INT 21H
MOV DL,8
INT 21H
JMP L2
CONTI: CMP AL,28H ;'('
JZ L2_YES
CMP AL,29H
JZ L2_YES ;')'
CMP AL,2AH ;'*'
JZ L2_YES
CMP AL,2BH ; '+'
JZ L2_YES
CMP AL,2DH ; '-'
JZ L2_YES
CMP AL,2FH ; '/'
JZ L2_YES
; back function ' <- '
CMP AL,08H
JNZ NO_8
L2_NEXT: PUSH DX
MOV DL,20H
MOV AH,2
INT 21H
MOV DL,8
MOV AH,2
INT 21H
CMP BX,OFFSET INSTR
JZ L2
DEC BX
MOV AL,0
MOV [BX],AL
POP DX
JMP L2
;
NO_8: MOV AH,2FH
CMP AH,AL ;del the wrong data ( < 0 )
JB L2_YES
MOV AH,2
MOV DL,8
INT 21H
MOV DL,20H
INT 21H
MOV DL,8
INT 21H
JMP L2
L2_YES: MOV DH,DL
MOV DL,AL
CMP DL,20H
JNZ L2_NO20
CMP DH,20H
JZ L2
L2_NO20: MOV [BX],AL
INC BX
JMP L2
L2_OVER: MOV AH,3DH
MOV [BX],AH
;check input
MOV SI,OFFSET INSTR
MOV AH,30H
MOV CH,0 ;record ( )
MOV CL,0
L3: MOV AL,[SI]
INC SI
CMP AL,3DH
JZ L3_OVER
CMP AL,2AH
JNB MAY_WRONG
CMP AL,29H
JZ L3_29
INC CH
JMP L3_RIGHT
L3_29: INC CL
JMP L3_RIGHT
MAY_WRONG: CMP AL,30H
JNB L3_RIGHT
CMP AL,28H
JZ L3_RIGHT
CMP AH,29H
JZ L3_RIGHT
;cmp ah,28h
;jz L3_right
CMP AH,30H
JNB L3_RIGHT
MOV DX,OFFSET MSG1
MOV AH,9
INT 21H
JMP OVER3
L3_RIGHT: MOV AH,AL
JMP L3
L3_OVER: CMP CH,CL
JZ INPUT_WRIGHT
MOV DX,OFFSET MSG2
MOV AH,9
INT 21H
JMP OVER3
;
;chech over
INPUT_WRIGHT: MOV BX,OFFSET STRI
MOV SI,OFFSET INSTR
;read
READ: ;mov ah,1
;int 21h
MOV AL,[SI] ;reserve the data by decimal{test}
INC SI
MOV AH,28H ;(
CMP AH,AL
JZ IN_STRI
MOV AH,29H ;)
CMP AH,AL
JZ IN_STRI
MOV AH,2AH ;*
CMP AH,AL
JZ IN_STRI
MOV AH,2BH ;+
CMP AH,AL
JZ IN_STRI
MOV AH,2DH ;-
CMP AH,AL
JZ IN_STRI
MOV AH,2FH ;/
CMP AH,AL
JZ IN_STRI
MOV AH,2FH ;delete the wrong input
CMP AH,AL
JNB READ
MOV AH,3DH ;=
CMP AH,AL
JZ IN_STRI
MOV AH,39H ;delete the wrong input
CMP AH,AL
JB READ
CALL NEAR PTR MULT
JMP READ ; the end of reserve
;
IN_STRI: MOV AH,0
CMP AH,[BX]
JZ NO_BX ;inc bx
INC BX
NO_BX: MOV [BX],AL
MOV AH,3DH
CMP AH,AL
JNZ NO_OVER
SUB AL,25 ;transplant '=' to '$'
MOV [BX],AL
JMP OVER
NO_OVER: JMP READ
MULT PROC NEAR ;mult data*10,add up
PUSH DX
PUSH CX
PUSH AX
MOV AH,0
CMP [BX],AH
JZ NO_INC_BX
MOV AH,30H
CMP [BX],AH
JNB NO_INC_BX
INC BX
NO_INC_BX: MOV DX,0
MOV CX,10
MOV AH,[BX]
CMP AH,30H
JB NO_SUB
SUB AH,30H
NO_SUB: MOV [BX],AH
NEXT: ADD DX,[BX]
LOOP NEXT
SUB AL,30H ;tras to decimal
ADD DL,AL
MOV [BX],DL
MOV AH,[BX]
ADD AH,30H
MOV [BX],AH
POP AX
POP CX
POP DX
RET
MULT ENDP
;
;end of read
OVER: CALL NEAR PTR TRANS ;the outlet of the program
OVER1: CALL NEAR PTR VALUE ;jmp instead of ret in
procedure trans
OVER2: CALL NEAR PTR PRINT
OVER3: MOV AH,9
MOV DX,OFFSET MSG5
INT 21H
MOV AH,8
INT 21H
CMP AL,1BH
JZ OVER4
MOV CX,210
MOV BX,OFFSET STRI
MOV AL,0
OVER_LOOP: MOV [BX],AL
INC BX
LOOP OVER_LOOP
MOV AH,2
MOV DL,0DH
INT 21H
MOV DL,0AH
INT 21H
JMP START
OVER4: MOV AH,4CH
INT 21H
;
;trans
TRANS PROC NEAR ;
PUSH AX
PUSH BX
PUSH CX
PUSH DX
PUSH SI
PUSH DI
XOR CX,CX
MOV BX,OFFSET STRI
MOV SI,OFFSET EXP
MOV DI,OFFSET TRACK
TRANS_WHILE:
MOV AL,[BX]
INC BX
MOV AH,24H ;'$'
CMP AH,AL
JZ TRANS_OVER ;end with '='
MOV AH,2FH ;judge L digital
CMP AH,AL
JNB NO_DIGITAL
MOV [SI],AL
INC SI
JMP TRANS_WHILE
NO_DIGITAL: MOV AH,28H ;judge L '('
CMP AH,AL
JNZ NO_9
MOV [DI],AL ;push al
INC DI
JMP TRANS_WHILE
NO_9: MOV AH,29H ;judge L ')'
CMP AH,AL
JNZ NO_0
POP_WHILE: DEC DI
MOV AL,[DI] ; pop al
MOV AH,28H
CMP AH,AL
JZ OVER_POP_WHILE
MOV [SI],AL
INC SI
JMP POP_WHILE
OVER_POP_WHILE:
;mov al,dl
JMP TRANS_WHILE
NO_0: MOV AH,2BH
CMP AH,AL
JZ OR1_YES
MOV AH,2DH
CMP AH,AL ;if al is '+' or '-'
JNZ NO_OR1
OR1_YES:
CMP DI,OFFSET TRACK ;jmp if stack is blank
JZ STACK_BLANK
DEC DI ;pop al
MOV CL,[DI]
MOV AH,28H
CMP AH,CL
JZ OVER_OR1_YES
MOV [SI],CL
INC SI
JMP OR1_YES
OVER_OR1_YES: MOV [DI],CL
INC DI
;reserve the ')'
STACK_BLANK: MOV [DI],AL ;push al
INC DI
JMP TRANS_WHILE
NO_OR1: MOV AH,2AH
CMP AH,AL
JZ OR2_YES
MOV AH,2FH
CMP AH,AL
JNZ NO_OR2 ;if al is '*' or '/' OR2_YES: DEC DI ;push dl
MOV CL,[DI]
MOV AH,2AH
CMP AH,CL
JZ OR2_YES_OR
MOV AH,2FH
CMP AH,CL
JNZ OR2_OVER
OR2_YES_OR: MOV [SI],CL
INC SI
JMP OR2_YES
OR2_OVER: MOV [DI],CL
INC DI ;push al
MOV [DI],AL
INC DI
NO_OR2: ;mov al,[bx]
;inc bx
;
JMP TRANS_WHILE
TRANS_OVER: CMP DI,OFFSET TRACK
JZ POP_OVER
DEC DI
MOV AL,[DI]
MOV [SI],AL
INC SI
JMP TRANS_OVER
POP_OVER: MOV AL,24H ;end with '='
MOV [SI],AL
POP DI
POP SI
POP DX
POP CX
POP BX
POP AX
JMP OVER1
TRANS ENDP
; end of trans
;start value
VALUE PROC NEAR ;get the value
PUSH AX
PUSH BX
PUSH CX
PUSH DX
PUSH SI
MOV BX,OFFSET EXP
MOV SI,OFFSET TRACK
XOR AX,AX
VALUE_WHILE: MOV AL,[BX]
INC BX
MOV AH,24H
CMP AH,AL
JZ VALUE_OVER
MOV AH,2FH ;judge L digital
CMP AH,AL
JNB VALUE_NO_DIGITAL
SUB AL,30H
MOV [SI],AL
INC SI
JMP VALUE_WHILE
VALUE_NO_DIGITAL: MOV AH,2BH ;+ CMP AH,AL
JNZ NO_ADD
DEC SI
MOV DL,[SI]
DEC SI
MOV DH,[SI]
ADD DH,DL
MOV [SI],DH
INC SI
JMP VALUE_WHILE
NO_ADD: MOV AH,2DH ;-
CMP AH,AL
JNZ VALUE_NO_SUB
DEC SI
MOV DL,[SI]
DEC SI
MOV DH,[SI]
CMP DH,DL
JNB SUB_RIGHT
MOV DX,OFFSET MSG4
MOV AH,9
INT 21H
JMP OVER3
SUB_RIGHT: SUB DH,DL
MOV [SI],DH
INC SI
JMP VALUE_WHILE
VALUE_NO_SUB: MOV AH,2AH ;*
CMP AH,AL
JNZ NO_MUL
DEC SI
MOV DH,[SI]
DEC SI
MOV AL,[SI]
MUL DH
MOV [SI],AL
INC SI
JMP VALUE_WHILE
NO_MUL: MOV AH,2FH ;/
CMP AH,AL
JNZ NO_DIV
DEC SI
MOV DH,[SI]
DEC SI
MOV AL,[SI]
XOR AH,AH
CMP DH,0
JNZ DIV_RIGHT
MOV DX,OFFSET MSG3
MOV AH,9
INT 21H
JMP OVER3
DIV_RIGHT: DIV DH
MOV [SI],AL
INC SI
NO_DIV: JMP VALUE_WHILE
;
VALUE_OVER: POP SI
POP DX
POP CX
POP BX
POP AX
RET
VALUE ENDP
; end value procedure
;
;start print
PRINT PROC NEAR
PUSH AX
PUSH DX
;mov dl,al
;mov ah,2
;int 21h
;mov dl,0dh
;mov ah,2
;int 21h
;mov dl,0ah
;mov ah,2
;int 21h
MOV BX,OFFSET TRACK
CALL NEAR PTR DIVI
DEC AL
OK: POP DX
POP AX
RET
PRINT ENDP ;end of print
;
DIVI PROC NEAR ;div data/10 funtion:print the data PUSH BX
PUSH AX
PUSH DX
MOV AL,[BX]
XOR AH,AH
XOR CX,CX
NEXT1: MOV BL,0AH
DIV BL
MOV DL,AH
ADD DL,30H
XOR DH,DH
PUSH DX
INC CX
MOV DH,0H ;judge L the end
CMP DH,AL
JNB DIVI_OVER1
XOR AH,AH
JMP NEXT1
DIVI_OVER1: POP DX
MOV AH,2
INT 21H
LOOP DIVI_OVER1
MOV DL,20H
MOV AH,2
INT 21H
POP DX
POP AX
POP BX
RET
DIVI ENDP
; end of print
CODE ENDS
END START 4.测试结果
进行加法运算得到的结果为
进行结果为负数的减法运算
进行除数为0的除法运算
进行加减乘除混合运算
5.使用说明
当进入操作界面后，提示输入正确的表达式，以等号结束，然后程序
给出正确结果。

输入的表达式只能含有加减乘除和数字括号，最后以等号结束。

程序计算的结果范围最大为65535，当输入结果超出范围，
结果会溢出，给出错误答案。

6.总结
6.1设计过程中的体会
实验中为了模拟简单计算器，需要对输入的ASCII字符串进行处理，首先要将输入的表达式转换为相应的能被识别的正确的表达式，然后，对表达式进行有效处理，将中缀表达式转换为便于计算机计算的后缀表达式。

在进行计算的过程中，利用后缀表达式和堆栈结果是非常容易进行四则混合运算的。

但是，在设计的过程中，如何将中缀表达式
转换为后缀表达式，是本实验的一个难点。

在试验的过程中，将中缀式转换成后缀式对我来说相当困难，因此在查阅大量资料和余同学讨论后，才完成相应目的。

因为本实验应用的是汇编语言进行设计，而汇编语言每次只能处理一个有效字符比如运算符，括号等和一个数值比如由ASCII码转换而来的相应的数值。

而且在中缀式向后缀式转换的过程中，也用到了堆栈结构。

6.2设计的优缺点
6.2.1 优点
可以进行四则混合运算，并得到结果。

可以提示用户输入错误。

可以正确计算带括号的表达式。

6.2.2缺点
界面没有达到友好，人性化。

支持的数据处理较小。

7．设计体会
这次试验主要是模拟计算器的功能，在试验的过程中，我进一步熟悉了汇编语言的应用，了解到了汇编语言的使用格式和方法。

在程序的编写中，得到了很多同学的帮助，学会了将设计进行分层，简化了设计过程，降低了设计难度。

试验中使用到了算术运算指令，比较运算指令，循环运算指令，跳转指令，使我对这些指令的使用有了自己的体会和理解。

在程序的编写中，将中缀式变成后缀式，键盘输入的ASCII码和十进制数之间的转换，寻址方式与寄存器的结合都是重点内容，在编写的过程中得到了深刻理解。

通过这次实验，我明白了要学习的东西很多，并且要在实
践中锻炼自己，提高自己的逻辑思考和编程设计能力。