编译原理测试

LL(1)预测表匹配过程

void test(int &state){

     Inital_AnalysisTableMap();
     Print_AnalysisTable();

     SqStack Analysis_Stack;                //定义分析栈
     InitalStack(Analysis_Stack);           //初始化分析栈
     PushStack(Analysis_Stack,'#');         //先将#压入栈
     PushStack(Analysis_Stack,'E');         //将开始符号E压入分析栈底



     SqStack Input_Stack;                   //定义输入栈
     InitalStack(Input_Stack);              //初始化输入栈
     PushStack(Input_Stack,'#');            //将#压入输入栈底

//     string input_str = "i+i*i";          //输入将要匹配的字符串

     string input_str ;                     //输入将要匹配的字符串
     cout<<"请输入待匹配的字符串:";
     cin>>input_str;

    if (input_str.length()==3 & input_str[0]=='e' && input_str[1]=='n' && input_str[2]=='d'){  //退出
        state=0;
        return;
    }


     Push_Str_resverse(Input_Stack,input_str);  //将输入的字符逆序压入输入栈当中
//     PrintStackUpToDown(Input_Stack);


    cout<<"Analysis_Stack"<<"\t"<<"     input_Stack"<<"\t"<<"    production"<<endl;

    while (Input_Stack.top!=-1){  //输入栈非空
            char top_analysis_stack;                                //用于接收查看分析栈顶元素
            getStackTop(Analysis_Stack,top_analysis_stack);    //查看当前分析栈的栈顶元素

            char top_input_Stack;                                     //用于接收查看输入栈顶元素
            getStackTop(Input_Stack,top_input_Stack);           //查看当前输入栈顶元素

           int indexOfNonterminal =getNonterminalCharIndex(top_analysis_stack);  //该非终结符对应下标
           int indexOfCharacter  = getCharacterIndex(top_input_Stack);           //该输入字符在字符表当中的下标


            if(indexOfNonterminal!=-1){    //当前分析栈顶元素是不是产生式左部的非终结符 不是-1代表是非终结符
                int status = AnalysisTableMap[indexOfNonterminal][indexOfCharacter];     //分析表当中对应产生式右部的下标
                if(status==-1){          //不存在该字符的后选式
                    cout<<"匹配失败!"<<endl;
                    return;
                }else if(status!=999){   //存在候选式但是不为空

                     PrintStackDownToUp(Analysis_Stack);
                     cout<<"\t\t\t";
                     PrintStackUpToDown(Input_Stack);
                     cout<<"\t\t\t";
                     cout<<product_left[indexOfNonterminal]<<"->"<<product_right[status]<<endl;

                    PopStack(Analysis_Stack,top_analysis_stack);    //分析栈出栈

                    string str=product_right[status];                     //获取当前产生式右部
                    Push_Str_resverse(Analysis_Stack,str);             //将产生式逆序压入分析栈中


                }else{                   //存在空候候选式,直接弹出
                    PrintStackDownToUp(Analysis_Stack);
                    cout<<"\t\t\t";
                    PrintStackUpToDown(Input_Stack);
                    cout<<"\t\t\t";
                    cout<<product_left[indexOfNonterminal]<<"->"<<"$"<<endl;
                    PopStack(Analysis_Stack,top_analysis_stack);    //弹出当前分析栈栈顶元素
                }

            }else if(top_analysis_stack!='#'){    //当前分析栈顶元素不为非非终结符，是终结字符，不是'#'

                PrintStackDownToUp(Analysis_Stack);
                cout<<"\t\t\t";
                PrintStackUpToDown(Input_Stack);
                cout<<"\t\t\t";
                if(top_analysis_stack==top_input_Stack){   //当前分析栈顶元素跟输入栈顶元素相等(终结符)
                    cout<<top_analysis_stack<<"匹配"<<endl;
                    PopStack(Analysis_Stack,top_analysis_stack);
                    PopStack(Input_Stack,top_input_Stack);
                }else{                                  //当前分析栈顶元素跟输入栈顶元素不相等(终结符)匹配失败退出
                    cout<<"匹配失败"<<endl;   //匹配失败
                    return;
                }

            }else{                                //当前分析栈顶元素是'#'
                PrintStackDownToUp(Analysis_Stack);
                cout<<"\t\t\t";
                PrintStackUpToDown(Input_Stack);
                cout<<"\t\t\t";
                if(top_analysis_stack==top_input_Stack){
                    cout<<"接受"<<endl;
                    PopStack(Analysis_Stack,top_analysis_stack);
                    PopStack(Input_Stack,top_input_Stack);
                }else{
                    cout<<"匹配失败"<<endl;
                    return;
                }
            }

    }
     cout<<endl<<"---------------------------------------------"<<endl<<endl<<endl<<endl;
}

DFA

int  DFA(int start_index,char end_index){

    char test[100];
    printf("请输入字符串:");
    scanf("%s",&test);


    int length=0;
    for(int i=0;test[i]!='\0';i++){
        length++;
    }

    if(length==3 && test[0]=='e' && test[1]=='n' && test[2] == 'd'){    //终止匹配
        printf("停止工作!\n");
        return 0;
    }


    int flag=1;   //判断循环是否正常进行，若中途break flag=0
    int current_state=start_index;

    for (int i = 0; test[i]!='\0' ; ++i) {
//        printf("%d: %c\n",i,test[i]);
        if(isInAlphabet(test[i])==1){     //该字符存在于字母表当中
            int al_index=getAlphabetIndex(test[i]);
            if(Map[current_state][al_index] != -1){
                printf("%c --%c-->%c\n",state[current_state],alphabet[al_index],state[Map[current_state][al_index]]);
                current_state = Map[current_state][al_index];
            } else{
                flag =0;                 //不存在该映射关系
                break;
            }
        }else{                            //该字符不存在于字母表当中
            flag = 0;
            break;
        }
    }

    if(flag==1 && current_state == end_index){
        printf("%s match YES!!!\n",test);
        return 1;
    }else{
        printf("%s match NO!!!\n",test);
        return 1;
    }
}