• 【编译原理实验】递归子程序法


    文法:

    E->TG
    G->+TG|-TG|^
    T->FS
    S->*FS|/FS|^
    F->i|(E)

    表达式串的每个数符必须以i代替(懒得优化)

      1 #include<stdio.h>
      2 #include<iostream>
      3 #include<string.h>
      4 #include<stdlib.h>
      5 using namespace std;
      6 
      7 
      8 int step_Counter=0;//计数第几步
      9 char in[82];//存储输入串
     10 char analized_str[82];int top=-1;//存储分析过的字符串
     11 char *ch;//指向当前正在分析的字符
     12 char * left_Function(char[]);//计算并返回剩余串的起始地址 老师请注意:left:剩余,不是左边
     13 
     14 char finished_dri[82];int t_f=-1;//推导式中的已经完成分析的字符串和其栈顶指针
     15 char unfinished_dri[82];int t_uf=-1;//推到是中的未完成分析的字符串和其栈顶指针
     16 char record_div[10000];//记录推导过程的数组
     17 void add(char arr[],char arr1[]);//add方法将未完成部分的栈倒序装入record_div记录数组
     18 
     19 int E();
     20 int T();
     21 int F();
     22 int S();
     23 int G();
     24 
     25 int main()
     26 {
     27     cout<<"请输入长度不大于81的表达式:";
     28     cin>>in;
     29     //cout<<strlen(in)<<endl;
     30     char const_str[10]="分析串";
     31     printf("步骤	文法	%-40s分析字符	剩余串
    ",const_str);
     32     ch=in;
     33 
     34     unfinished_dri[++t_uf]='E';//初始化非终结符栈
     35     strcat(record_div,"E");//记录第一条推导
     36 
     37 
     38     int flag=E();
     39     if(flag==0)
     40         cout<<endl<<"			ERROR !"<<endl;
     41     else
     42     {
     43         cout<<endl<<"			ACCEPT !"<<endl;
     44         cout<<"推导过程:"<<endl;
     45         cout<<record_div<<endl;
     46     }
     47     return 0;
     48 }
     49 int E()
     50 {
     51     t_uf--;//非终结符栈栈顶元素出栈
     52     unfinished_dri[++t_uf]='G';//非终结符倒序入非终结符栈
     53     unfinished_dri[++t_uf]='T';
     54     
     55     unfinished_dri[t_uf+1]='';//给栈顶元素增加结束标识,以免出错
     56     strcat(record_div,"
    =>");//以下三条是记录推导的语句
     57     strcat(record_div,finished_dri);
     58     add(record_div,unfinished_dri);//因为非终结符栈是倒序的,所以不能直接使用strcat函数,要进行一次颠倒才能进行连接
     59     //以上解释使用于下面的几个函数,故不再解释
     60     
     61 
     62     step_Counter++;//标识第几步的变量
     63     analized_str[top+1]='';//为第一次调用此函数做准备
     64     char * left_str=left_Function(analized_str);//得到剩余串的起始地址
     65     printf("%d	E=>TG	%-40s%c		%s
    ",step_Counter,analized_str,*ch,left_str);//格式打印输出
     66     //cout<<"调用了函数E"<<endl;
     67     if(*ch=='#')
     68         return 1;
     69     int flag=T();
     70     if(flag==0)
     71         return 0;
     72     else
     73     {
     74         flag=G();
     75         if(flag==0)
     76             return 0;
     77         else
     78         {
     79             return 1;
     80         }
     81     }
     82 }
     83 int T()
     84 {
     85     t_uf--;
     86     unfinished_dri[++t_uf]='S';
     87     unfinished_dri[++t_uf]='F';
     88 
     89     unfinished_dri[t_uf+1]='';
     90     finished_dri[t_f+1]='';
     91     strcat(record_div,"
    =>");
     92     strcat(record_div,finished_dri);
     93     add(record_div,unfinished_dri);
     94     
     95 
     96     step_Counter++;
     97     analized_str[top+1]='';
     98     char * left_str=left_Function(analized_str);
     99     printf("%d	T=>FS	%-40s%c		%s
    ",step_Counter,analized_str,*ch,left_str);
    100     //cout<<"调用了函数T"<<endl;
    101     if(*ch=='#')
    102         return 1;
    103     int flag=F();
    104     if(flag==0)
    105         return 0;
    106     else
    107     {
    108         flag=S();
    109         if(flag==0)
    110             return 0;
    111         else
    112         {
    113             return 1;
    114         }
    115     }
    116 }
    117 int F()
    118 {
    119     if(*ch=='#')
    120         return 1;
    121     //cout<<"调用了函数F"<<endl;
    122     if(*ch=='i')
    123     {
    124         t_uf--;//未完成的部分栈顶出栈
    125         finished_dri[++t_f]='i';//完成的部分入栈
    126         unfinished_dri[t_uf+1]='';
    127         finished_dri[t_f+1]='';
    128         strcat(record_div,"
    =>");
    129         strcat(record_div,finished_dri);
    130         add(record_div,unfinished_dri);
    131 
    132 
    133 
    134         top++;
    135         analized_str[top]='i';
    136         analized_str[top+1]='';
    137         step_Counter++;
    138         char * left_str=left_Function(analized_str);
    139         printf("%d	F=>i	%-40s%c		%s
    ",step_Counter,analized_str,*ch,left_str);
    140         //cout<<++step_Counter<<"i匹配"<<endl;
    141         ch++;
    142         return 1;
    143     }
    144     else if(*ch=='(')
    145     {
    146 
    147 
    148         t_uf--;//未完成的部分F栈顶出栈
    149         finished_dri[++t_f]='(';//完成的部分入栈
    150         unfinished_dri[++t_uf]=')';//未完成的部分倒序入栈
    151         unfinished_dri[++t_uf]='E';//未完成的部分倒序入栈
    152         unfinished_dri[t_uf+1]='';
    153         finished_dri[t_f+1]='';
    154         strcat(record_div,"
    =>");
    155         strcat(record_div,finished_dri);
    156         add(record_div,unfinished_dri);
    157 
    158 
    159         top++;
    160         analized_str[top]='(';
    161         analized_str[top+1]='';
    162         step_Counter++;
    163         char * left_str=left_Function(analized_str);
    164         printf("%d	F=>(E)	%-40s%c		%s
    ",step_Counter,analized_str,*ch,left_str);
    165         //cout<<++step_Counter<<"(匹配"<<endl;
    166         ch++;
    167         int flag=E();  
    168         if(flag==0)
    169             return 0;
    170         else
    171         {
    172             if(*ch==')')
    173             {
    174                 t_uf--;//完成部分出栈
    175                 finished_dri[++t_f]=')';//完成部分入栈
    176 
    177 
    178                 unfinished_dri[t_uf+1]='';
    179                 finished_dri[t_f+1]='';
    180                 strcat(record_div,"
    =>");
    181                 strcat(record_div,finished_dri);
    182                 add(record_div,unfinished_dri);
    183 
    184                 top++;
    185                 analized_str[top]=')';
    186                 analized_str[top+1]='';
    187                 step_Counter++;
    188                 char * left_str=left_Function(analized_str);
    189                 printf("%d	F=>(E)	%-40s%c		%s
    ",step_Counter,analized_str,*ch,left_str);
    190             //    cout<<++step_Counter<<")匹配"<<endl;
    191                 ch++;
    192                 return 1;
    193             }
    194             else 
    195                 return 0;
    196         }
    197     }
    198     else 
    199     {
    200         return 0;
    201     }
    202 }
    203 int S()
    204 {
    205     //cout<<"调用了函数S"<<endl;
    206     if(*ch=='*')
    207     {
    208         t_uf--;//非终结符S出栈
    209         finished_dri[++t_f]='*';//终结符入栈
    210         unfinished_dri[++t_uf]='S';//非终结符倒序入栈
    211         unfinished_dri[++t_uf]='F';
    212         unfinished_dri[t_uf+1]='';
    213         finished_dri[t_f+1]='';
    214         strcat(record_div,"
    =>");
    215         strcat(record_div,finished_dri);
    216         add(record_div,unfinished_dri);
    217 
    218 
    219 
    220         top++;
    221         analized_str[top]='*';
    222         analized_str[top+1]='';
    223         step_Counter++;
    224         char * left_str=left_Function(analized_str);
    225         printf("%d	S=>*FS	%-40s%c		%s
    ",step_Counter,analized_str,*ch,left_str);
    226     //    cout<<++step_Counter<<"*匹配"<<endl;
    227         ch++;
    228         int flag=F();
    229         if(flag==0)
    230             return 0;
    231         else
    232         {
    233             flag=S();
    234             if(flag==1)
    235                 return 1;
    236             else 
    237                 return 0;
    238         }
    239     }
    240     else if(*ch=='/')
    241     {
    242         t_uf--;//非终结符S出栈
    243         finished_dri[++t_f]='/';//终结符入栈
    244         unfinished_dri[++t_uf]='S';
    245         unfinished_dri[++t_uf]='F';
    246         unfinished_dri[t_uf+1]='';
    247         finished_dri[t_f+1]='';
    248         strcat(record_div,"
    =>");
    249         strcat(record_div,finished_dri);
    250         add(record_div,unfinished_dri);
    251 
    252 
    253         top++;
    254         analized_str[top]='/';
    255         analized_str[top+1]='';
    256         step_Counter++;
    257         char * left_str=left_Function(analized_str);
    258         printf("%d	S=>/FS	%-40s%c		%s
    ",step_Counter,analized_str,*ch,left_str);
    259     //    cout<<++step_Counter<<"/匹配!"<<endl;
    260         ch++;
    261         int flag=F();
    262         if(flag==0)
    263             return 0;
    264         else 
    265         {
    266             flag=S();
    267             if(flag==1)
    268             return 1;
    269             else 
    270                 return 0;
    271         }
    272     }
    273     else  
    274     {
    275         t_uf--;//非终结符S出栈
    276         finished_dri[++t_f]='^';//终结符入栈
    277         unfinished_dri[t_uf+1]='';
    278         finished_dri[t_f+1]='';
    279         strcat(record_div,"
    =>");
    280         strcat(record_div,finished_dri);
    281         add(record_div,unfinished_dri);
    282 
    283 
    284         step_Counter++;
    285         char * left_str=left_Function(analized_str);
    286         printf("%d	S=>^	%-40s%c		%s
    ",step_Counter,analized_str,*ch,left_str);
    287         return 1;
    288     }
    289 }
    290 int G()
    291 {
    292     //cout<<"调用了函数G"<<endl;
    293     if(*ch=='+')
    294     {
    295         t_uf--;//非终结符S出栈
    296         finished_dri[++t_f]='+';//终结符入栈
    297         unfinished_dri[++t_uf]='G';
    298         unfinished_dri[++t_uf]='T';
    299         unfinished_dri[t_uf+1]='';
    300         finished_dri[t_f+1]='';
    301         strcat(record_div,"
    =>");
    302         strcat(record_div,finished_dri);
    303         add(record_div,unfinished_dri);
    304 
    305 
    306 
    307         top++;
    308         analized_str[top]='+';
    309         analized_str[top+1]='';
    310         step_Counter++;
    311         char * left_str=left_Function(analized_str);
    312         printf("%d	G=>+TG	%-40s%c		%s
    ",step_Counter,analized_str,*ch,left_str);
    313     //    cout<<++step_Counter<<"+匹配"<<endl;
    314         ch++;
    315         int flag=T();
    316         if(flag==0)
    317             return 0;
    318         else
    319         {
    320             flag=G();
    321             if(flag==1)
    322             return 1;
    323             else 
    324                 return 0;
    325         }
    326     }
    327     else if(*ch=='-')
    328     {
    329 
    330         t_uf--;//非终结符S出栈
    331         finished_dri[++t_f]='-';//终结符入栈
    332         unfinished_dri[++t_uf]='G';
    333         unfinished_dri[++t_uf]='T';
    334         unfinished_dri[t_uf+1]='';
    335         finished_dri[t_f+1]='';
    336         strcat(record_div,"
    =>");
    337         strcat(record_div,finished_dri);
    338         add(record_div,unfinished_dri);
    339 
    340 
    341 
    342         top++;
    343         analized_str[top]='-';
    344         analized_str[top+1]='';
    345         step_Counter++;
    346         char * left_str=left_Function(analized_str);
    347         printf("%d	G=>-TG	%-40s%c		%s
    ",step_Counter,analized_str,*ch,left_str);
    348     //    cout<<++step_Counter<<"-匹配"<<endl;
    349         ch++;
    350         int flag=T();
    351         if(flag==0)
    352             return 0;
    353         else 
    354         {
    355             flag=G();
    356             if(flag==1)
    357             return 1;
    358             else 
    359                 return 0;
    360         }
    361     }
    362     else
    363     {
    364 
    365         t_uf--;
    366         finished_dri[++t_f]='^';
    367         unfinished_dri[t_uf+1]='';
    368         finished_dri[t_f+1]='';
    369         strcat(record_div,"
    =>");
    370         strcat(record_div,finished_dri);
    371         add(record_div,unfinished_dri);
    372 
    373         step_Counter++;
    374         char * left_str=left_Function(analized_str);
    375         printf("%d	G=>^	%-40s%c		%s
    ",step_Counter,analized_str,*ch,left_str);
    376         return 1;
    377     }
    378 }
    379 
    380 
    381 char * left_Function(char aim[])//获取剩余的字符串 老师请注意:left:剩余,不是左边
    382 {
    383     char * left;
    384     int length=strlen(aim);
    385     left=&in[length];
    386     return left;
    387 }
    388 
    389 void add(char aim[],char source[])
    390 {
    391     char temp[1000];int top=-1;
    392     int len=strlen(source);
    393     for(int i=len-1;i>=0;i--)
    394     {
    395         temp[++top]=source[i];
    396     }
    397     temp[++top]='';
    398     strcat(aim,temp);
    399 }
    400 
    401 //测试数据:((i*i+i)*i/i)-(i*i*(i+i)/i-i-i)*i/i+i-i#
    View Code
  • 相关阅读:
    shell脚本
    数据分析学习笔记(1):工作环境以及建模理论基础
    spark复习笔记(7):sparkstreaming
    mybatis复习笔记(1):
    spark复习笔记(7):sparkSQL
    spark复习笔记(6):RDD持久化
    spark复习笔记(6):数据倾斜
    spark复习笔记(4):RDD变换
    C#重启IIS
    mongodb学习记录
  • 原文地址:https://www.cnblogs.com/kuangdaoyizhimei/p/3871488.html
Copyright © 2020-2023  润新知