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

文法：

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("步骤\t文法\t%-40s分析字符\t剩余串\n",const_str);

 32     ch=in;

 33 

 34     unfinished_dri[++t_uf]='E';//初始化非终结符栈

 35     strcat(record_div,"E\0");//记录第一条推导

 36 

 37 

 38     int flag=E();

 39     if(flag==0)

 40         cout<<endl<<"\t\t\tERROR !"<<endl;

 41     else

 42     {

 43         cout<<endl<<"\t\t\tACCEPT !"<<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]='\0';//给栈顶元素增加结束标识，以免出错

 56     strcat(record_div,"\n=>");//以下三条是记录推导的语句

 57     strcat(record_div,finished_dri);

 58     add(record_div,unfinished_dri);//因为非终结符栈是倒序的，所以不能直接使用strcat函数，要进行一次颠倒才能进行连接

 59     //以上解释使用于下面的几个函数，故不再解释

 60     

 61 

 62     step_Counter++;//标识第几步的变量

 63     analized_str[top+1]='\0';//为第一次调用此函数做准备

 64     char * left_str=left_Function(analized_str);//得到剩余串的起始地址

 65     printf("%d\tE=>TG\t%-40s%c\t\t%s\n",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]='\0';

 90     finished_dri[t_f+1]='\0';

 91     strcat(record_div,"\n=>");

 92     strcat(record_div,finished_dri);

 93     add(record_div,unfinished_dri);

 94     

 95 

 96     step_Counter++;

 97     analized_str[top+1]='\0';

 98     char * left_str=left_Function(analized_str);

 99     printf("%d\tT=>FS\t%-40s%c\t\t%s\n",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]='\0';

127         finished_dri[t_f+1]='\0';

128         strcat(record_div,"\n=>");

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]='\0';

137         step_Counter++;

138         char * left_str=left_Function(analized_str);

139         printf("%d\tF=>i\t%-40s%c\t\t%s\n",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]='\0';

153         finished_dri[t_f+1]='\0';

154         strcat(record_div,"\n=>");

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]='\0';

162         step_Counter++;

163         char * left_str=left_Function(analized_str);

164         printf("%d\tF=>(E)\t%-40s%c\t\t%s\n",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]='\0';

179                 finished_dri[t_f+1]='\0';

180                 strcat(record_div,"\n=>");

181                 strcat(record_div,finished_dri);

182                 add(record_div,unfinished_dri);

183 

184                 top++;

185                 analized_str[top]=')';

186                 analized_str[top+1]='\0';

187                 step_Counter++;

188                 char * left_str=left_Function(analized_str);

189                 printf("%d\tF=>(E)\t%-40s%c\t\t%s\n",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]='\0';

213         finished_dri[t_f+1]='\0';

214         strcat(record_div,"\n=>");

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]='\0';

223         step_Counter++;

224         char * left_str=left_Function(analized_str);

225         printf("%d\tS=>*FS\t%-40s%c\t\t%s\n",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]='\0';

247         finished_dri[t_f+1]='\0';

248         strcat(record_div,"\n=>");

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]='\0';

256         step_Counter++;

257         char * left_str=left_Function(analized_str);

258         printf("%d\tS=>/FS\t%-40s%c\t\t%s\n",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]='\0';

278         finished_dri[t_f+1]='\0';

279         strcat(record_div,"\n=>");

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\tS=>^\t%-40s%c\t\t%s\n",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]='\0';

300         finished_dri[t_f+1]='\0';

301         strcat(record_div,"\n=>");

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]='\0';

310         step_Counter++;

311         char * left_str=left_Function(analized_str);

312         printf("%d\tG=>+TG\t%-40s%c\t\t%s\n",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]='\0';

335         finished_dri[t_f+1]='\0';

336         strcat(record_div,"\n=>");

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]='\0';

345         step_Counter++;

346         char * left_str=left_Function(analized_str);

347         printf("%d\tG=>-TG\t%-40s%c\t\t%s\n",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]='\0';

368         finished_dri[t_f+1]='\0';

369         strcat(record_div,"\n=>");

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\tG=>^\t%-40s%c\t\t%s\n",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]='\0';

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