如何使用emu8086检查平衡括号

如何解决如何使用emu8086检查平衡括号

为了检查 prenthesis 是否平衡，我是用 C++ 语言编写的，但是我如何将此代码转换为汇编 emu8086 程序。

#include <iostream> //main header file
#include <stack>
using namespace std;
void balance_parentheses();
int main()
{
    int t;
    cout << "Enter number of test cases:";
    cin >> t;

    for (int i = 0; i < t; i++) {
        //calling of function for checking of brackets
        balance_parentheses();
    }    
    return 0;
}

void balance_parentheses()
{
    stack<char> a;
    string s;
    cout << "Enter string may or may not containing parentheses:";
    cin >> s;

    int flag = 0; //flag is an arbitrary variable

    for (int i = 0; i < s.length(); i++)
    //for length of the string calculated by number of letters
    {
        if (s[i] == '{' || s[i] == '[' || s[i] == '(') {
            //push function to enter terms in a stack
            a.push(s[i]);
            flag = 1;
        }
        if (!a.empty()) {
            if (s[i] == '}') {
                if (a.top() == '{')
                // top of the stack
                {
                    a.pop();
                    //pop function to delete terms from the top of array
                    continue;
                }
                else
                    break;
            }
            if (s[i] == ']') {
                if (a.top() == '[') {
                    a.pop();
                    continue;
                }
                else
                    break;
            }
            if (s[i] == ')') {
                if (a.top() == '(') {
                    a.pop();
                    continue;
                }
                else
                    break;
            }
        }
        else {
            break;
        }
    }

    if ((a.empty()) && (flag == 1))
        cout << "Balaned" << endl;
    else
        cout << "Not Balanced" << endl;
}

为简单起见，测试输入长度为8 个固定，并且在正好取 8 个字符后，打印输出。
用于检查输入（示例如下）：

[[]({})] ------ 平衡

{({}[])} ------ 平衡

[]({)}[] ------ 不平衡

}()[(]){ ------ 不平衡

解决方法

这里首先，@ 表示标签开始，$ 表示过程开始。如果汇编代码中存在多个标签和过程。然后可以轻松区分标签和程序。这只是我自己的编码方式。您可以忽略此样式。

.model small               ; declaring this code will be consists of one data segment and one code segment
.stack 100h                ; stack is initializeed to offset address at 100h

.data                      ; Data segment

n_line db 0ah,0dh,"$"      ; for new line
msg1 db 10,13,"Balanced$" 
msg2 db 10,"Not Balanced$"

a1 dw 5bh ; '['
a2 dw 5dh ; ']'
b1 dw 7bh ; '{'
b2 dw 7dh ; '}'
c1 dw 28h ; '('
c2 dw 29h ; ')' 

flag db 0
i db ?  

.code                      ; Code segment

main proc
    mov ax,@data           ; copying starting address of data segment into ax register
    mov ds,ax              ; by copying ax into ds we are initializing data segment 
        
    mov cx,8               ; length is 8 fixed here    
    mov i,0d               ; https://stackoverflow.com/questions/45904075/displaying-numbers-with-dos
    xor ax,ax              ; clearing ax     
    xor bx,bx              ; clearing bx
    xor dx,dx              ; clearing dx
@input: 
    cmp i,8d
    jge @input_end
                                                  
        mov ah,1           ; taking input
        int 21h
        
        mov ah,0           ; clearing previously stored 1 in ah
        mov bp,sp          ; checking stack is empty or not using bp. it can be done sp in this code
        
        @if1:              ; in this @if1 level: checking if current input is opening bracket or not
           cmp ax,a1
           je @push_it
           cmp ax,b1
           je @push_it
           cmp ax,c1
           je @push_it
           
           jmp @if2
        @push_it:          ; if  current input is opening bracket then push it
            push ax 
            mov flag,1     ; and alter the default flag value
        
        @if2:
             cmp bp,100h   ; checking if stack is empty or not
             je @if2_end   ; if not empty then  
             
             @inner_if1:   ; in this @inner_if1 level,checking if top of the stack is co-responding closing bracket of '{' or not
                cmp ax,b2  ; top==}
                je @inner_if1_perform
                jne @inner_if2
                @inner_if1_perform:  
                    pop bx       ; top is popped and storing it to bx
                    cmp bx,b1
                    jne @inner_push1
                    je @inner_if2
                    
                    @inner_push1:
                        push bx   ; if not matched,then that popped value should be pushed
                  
              @inner_if2:   ; in this @inner_if2 level,checking if top of the stack is co-responding closing bracket of '[' or not
                 cmp ax,a2  ; top==]
                 je @inner_if2_perform
                 jne @inner_if3
                 @inner_if2_perform:
                    pop bx       ; top is popped and storing it to bx
                    cmp bx,a1
                    jne @inner_push2
                    je @inner_if3
                    
                    @inner_push2:
                        push bx   ; if not matched,then that popped value should be pushed
                 
              @inner_if3:   ; in this @inner_if3 level,checking if top of the stack is co-responding closing bracket of '(' or not
                 cmp ax,c2  ; top== )
                 je @inner_if3_perform
                 jne @inner_if3_end
                 @inner_if3_perform:
                    pop bx        ; top is popped and storing it to bx
                    cmp bx,c1
                    jne @inner_push3
                    je @inner_if3_end
                    
                    @inner_push3:
                        push bx    ; if not matched,then that popped value should be pushed
                        
               @inner_if3_end:                        
        @if2_end:
    inc i
    jmp @input   
    
@input_end:                ; if ( (flag == 1) && (stack.empty()) )
    cmp flag,1
    je @next_level:
    jne @print_msg2
    
    @next_level:          
    cmp sp,100h            ; cheking the stack pointer is returned to initial address or not means empty or not
    je @print_msg1
    jne @print_msg2                            

    @print_msg1:
        lea dx,msg1  
        mov ah,9
        int 21h 
@stop:     
    mov ah,4ch             ; terminate the code
    int 21h     
main endp                  ; ending of main procedure

@print_msg2:
    lea dx,msg2  
    mov ah,9
    int 21h  
    
    jmp @stop  
end main                   ; ending of code segment

;    Input:    
;    [[]({})] ------ Balanced
;    {({}[])} ------ Balanced
;    []({)}[] ------ Not Balanced
;    }()[(]){ ------ Not Balanced