Chinaunix首页 | 论坛 | 博客

瓶ahutwgs.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

ahutwgs

  • 博客访问： 173589
  • 博文数量： 35
  • 博客积分： 287
  • 博客等级： 二等列兵
  • 技术积分： 353
  • 用 户 组： 普通用户
  • 注册时间： 2011-08-02 21:01
个人简介

君子务本，本立则道生。

文章分类

全部博文（35）

文章存档

2014年（4）

2013年（12）

2012年（19）

我的朋友
最近访客
推荐博文
相关博文
判断是不是LL1文法

分类： C/C++

2012-05-04 08:47:58

编最近上的编译原理课呢做实验，输入一个文法，然后判断是不是LL1文法，根据清华大学张素琴老师主编的《编译原理》第二版80页的算法，写了短程序：

  1. //compile.c

  3. #include<stdio.h>
  4. #include<stdlib.h>
  5. #include<string.h>
  6. #define length 100

  8. typedef struct {
  9.     char T[length];
  10.     char first[length][length];
  11.     int len;
  12. } ter,*Ter;


  15. typedef struct {
  16.     char N[length];
  17.     char first[length][length];
  18.     char follow[length][length];
  19.     char p_emp[length];
  20.     char n_emp[length];
  21.     int len;
  22. }*NTer,nter;

  24. //define Produce data
  25. typedef struct {
  26.     char front;
  27.     char back[length];

  29. }*Pro,prox;

  31. typedef struct {
  32.     Pro pro[length];
  33.     char string_first[length][length];
  34.     char select[length][length];
  35.     int len;

  37. }*Prod,prodx;

  39. //define G

  41. typedef struct {
  42.     Ter t_symbol;
  43.     NTer n_symbol;
  44.     Prod produce;
  45.     char start_symbol;
  46. }*G,grame;

  48. int belong_Arr(char x,char arr[])
  49. {
  50.     int i=0;
  51.     while(arr[i]!='\0') {
  52.         if(arr[i]==x)
  53.             return 1;
  54.         i++;
  55.     }
  56.     return 0;
  57. }

  59. int join(char a[],char b[],int a_len,int b_len)
  60. {
  61.     int i;

  63.     for(i=0; i<b_len; i++)
  64.         if((!belong_Arr(b[i],a))&&(b[i]!='&')) {
  65.             a[a_len]=b[i];
  66.             a_len++;
  67.         }
  68.     return a_len;

  70. }

  72. int join_arr(char a[],char b[])
  73. {
  74.     int i,len;
  75.     len=0;
  76.     while(a[len]!='\0')
  77.         len++;

  79.     i=0;
  80.     while(b[i]!='\0') {
  81.         if((!belong_Arr(b[i],a))&&(b[i]!='&')) {
  82.             a[len]=b[i];
  83.             len++;
  84.         }
  85.         i++;

  87.     }
  88.     return len;
  89. }

  91. int belong_N(char x,NTer n)
  92. {
  93.     int i=0;
  94.     for(; i<n->len; i++) {
  95.         if(x==n->N[i])
  96.             return 1;
  97.     }
  98.     return 0;
  99. }

  101. int belong_T(char x,Ter t)
  102. {
  103.     int i=0;
  104.     for(; i<t->len; i++) {
  105.         if(x==t->T[i])
  106.             return 1;
  107.     }
  108.     return 0;
  109. }


  112. typedef struct {
  113.     char syb;
  114.     int tag;
  115. }*elm,el;

  117. typedef struct {
  118.     elm elms[length];
  119.     int len;
  120. }*x_table,x_tab;





  126. void find_null(Prod pr,NTer n,Ter t)
  127. {
  128.     int i=0;
  129.     int j=0;
  130.     int k=0;
  131.     int m,a;
  132.     int b;
  133.     int q;
  134.     int loop=1;
  135.     int flag[n->len];
  136.     char temp;
  137.     //作为标记,辨别产生世是否删除
  138.     int tags[pr->len];
  139.     x_table tab=(x_table)malloc(sizeof(x_tab));
  140.     Prod p=(Prod)malloc(sizeof(prodx));


  143.     p->len=pr->len;

  145.     for(i=0; i<pr->len; i++) {
  146.         p->pro[i]=(Pro)malloc(sizeof(prox));
  147.         p->pro[i]->front=pr->pro[i]->front;
  148.         strcpy(p->pro[i]->back,pr->pro[i]->back);
  149.     }

  151.     for(i=0; i<p->len; i++) {
  152.         tags[i]=1;
  153.     }

  155.     for(i=0; i<n->len; i++) {
  156.         tab->elms[i]=(elm)malloc(sizeof(el));
  157.         tab->elms[i]->syb=n->N[i];
  158.         tab->elms[i]->tag=0;
  159.     }


  162.     tab->len=n->len;

  164.     for(i=0; i<p->len; i++) {
  165.         j=0;
  166.         while((temp=p->pro[i]->back[j++])!='#') {
  167.             if(belong_T(temp,t)) {
  168.                 tags[i]=0;
  169.                 break;
  170.             }

  172.         }
  173.     }



  177.     //确定以某一非终结符为左部的产生是的个数;判断以某一非终结符为左部的所有产生是都被删除,则将此非终结符标记否 即为 2 此为 步骤2_1



  181.     for(i=0; i<tab->len; i++) {
  182.         k=0;
  183.         m=0;
  184.         for(j=0; j<p->len; j++) {
  185.             if(tab->elms[i]->syb==p->pro[j]->front) {
  186.                 k++;
  187.                 if(tags[j]==0)
  188.                     m++;
  189.             }
  190.         }
  191.         if(k==0)
  192.             continue;
  193.         else if(k==m) {
  194.             tab->elms[i]->tag=2;

  196.         }


  199.     }


  202.     //判断 右部 是不是 yi bu xiu 是则 标记 1 , 此为步骤 2_2

  204.     for(i=0; i<p->len; i++) {
  205.         if(p->pro[i]->back[0]=='#') {
  206.             tags[i]=0;
  207.             for(j=0; j<tab->len; j++) {
  208.                 if(tab->elms[j]->syb==p->pro[i]->front) {
  209.                     tab->elms[j]->tag=1;
  210.                 }
  211.             }
  212.         }
  213.     }




  218.     k=0,j=0;
  219.     for(i=0; i<tab->len; i++) {
  220.         if(tab->elms[i]->tag==1) {
  221.             n->p_emp[k]=tab->elms[i]->syb;
  222.             k++;
  223.         } else if(tab->elms[i]->tag==2) {
  224.             n->n_emp[j]=tab->elms[i]->syb;
  225.             j++;
  226.         }


  229.     }

  231.     n->p_emp[k]='\0';
  232.     n->n_emp[j]='\0';

  234.     printf("==============================================\n");
  235.     printf("==============================================\n");
  236.     printf("U---------Unknown\n");
  237.     printf("Y---------Can produce empty set\n");
  238.     printf("N---------Can't produce empty set\n");



  242.     printf("The first time scaning\n");
  243.     for(i=0; i<tab->len; i++)
  244.         printf("%c ",tab->elms[i]->syb);
  245.     printf("\n");
  246.     for(i=0; i<tab->len; i++) {
  247.         if(tab->elms[i]->tag==0)
  248.             printf("U ");
  249.         else if(tab->elms[i]->tag==1)
  250.             printf("Y ");
  251.         else
  252.             printf("N ");
  253.     }
  254.     printf("\n");

  256.     m=0,j=0,k=0;




  261.     //步骤3_1



  265.     while(loop==1) {
  266.         loop=0;
  267.         for(j=0; j<tab->len; j++) {
  268.             flag[j]=tab->elms[j]->tag;
  269.         }


  272.         for(i=0; i<p->len; i++) {

  274.             if(tags[i]==1) {
  275.                 k=0;
  276.                 while(p->pro[i]->back[k]!='#') {
  277.                     if(belong_N(p->pro[i]->back[k],n)) {

  279.                         for(j=0; j<tab->len; j++) {
  280.                             if(tab->elms[j]->syb==p->pro[i]->back[k]) {
  281.                                 if(tab->elms[j]->tag==1) {

  283.                                     m=k;
  284.                                     while('\0'!=p->pro[i]->back[m]) {
  285.                                         p->pro[i]->back[m]=p->pro[i]->back[m+1];

  287.                                         //printf("%c\n",p->pro[i]->back[m]);
  288.                                         m++;
  289.                                     }
  290.                                     k=k-1;
  291.                                     if('#'==p->pro[i]->back[0]) {

  293.                                         for(b=0; b<tab->len; b++) {
  294.                                             if(tab->elms[b]->syb==p->pro[i]->front) {
  295.                                                 tab->elms[b]->tag=1;
  296.                                                 q=b;
  297.                                             }

  299.                                         }


  302.                                         for(b=0; b<p->len; b++) {
  303.                                             if(p->pro[b]->front==tab->elms[q]->syb) {
  304.                                                 tags[b]=0;
  305.                                             }
  306.                                         }
  307.                                     }
  308.                                 }

  310.                                 else if(tab->elms[j]->tag==2) {
  311.                                     tags[i]=0;

  313.                                     b=0;
  314.                                     for(a=0; a<p->len; a++) {
  315.                                         if((p->pro[a]->front==p->pro[i]->front)&&(tags[a]==1)) {
  316.                                             tags[a]=0;
  317.                                         }
  318.                                     }
  319.                                     for(a=0; a<p->len; a++) {
  320.                                         if((p->pro[a]->front==p->pro[i]->front)&&(tags[a]==1)) {
  321.                                             b++;
  322.                                         }

  324.                                     }

  326.                                     if(b==0) {
  327.                                         for(a=0; a<tab->len; a++) {
  328.                                             if((tab->elms[a]->syb==p->pro[i]->front)&&(tab->elms[a]->tag==0)) {
  329.                                                 tab->elms[a]->tag=2;
  330.                                             }
  331.                                         }


  334.                                     }


  337.                                 }
  338.                             }


  341.                         }


  344.                     }
  345.                     k++;
  346.                 }

  348.             }
  349.         }
  350.         for(i=0; i<tab->len; i++) {
  351.             if(tab->elms[i]->tag!=flag[i]) {
  352.                 loop=1;
  353.                 break;
  354.             }
  355.         }

  357.     }

  359.     printf("The second time scaning\n");
  360.     for(i=0; i<tab->len; i++)
  361.         printf("%c ",tab->elms[i]->syb);
  362.     printf("\n");
  363.     for(i=0; i<tab->len; i++) {
  364.         if(tab->elms[i]->tag==0)
  365.             printf("U ");
  366.         else if(tab->elms[i]->tag==1)
  367.             printf("Y ");
  368.         else
  369.             printf("N ");
  370.     }


  373.     k=0,j=0,m;
  374.     for(i=0; i<tab->len; i++) {
  375.         if(tab->elms[i]->tag==1) {
  376.             //n_pro_e[k]=tab->elms[i]->syb;
  377.             n->p_emp[k]=tab->elms[i]->syb;
  378.             k++;
  379.         } else if(tab->elms[i]->tag==2) {
  380.             //npro_e[j]=tab->elms[i]->syb;
  381.             n->n_emp[j]=tab->elms[i]->syb;
  382.             j++;
  383.         }


  386.     }
  387.     n->p_emp[k]='\0';
  388.     n->n_emp[j]='\0';




  393.     return ;
  394. }
  395. void get_first_set(Prod p,NTer n,Ter t)
  396. {

  398.     int i,j,k,temp;
  399.     int flag,a,b;
  400.     int m;
  401.     int tags[n->len];
  402.     //int lock[n->len];
  403.     int loop=1;
  404.     int judge[n->len];

  406.     printf("\n==============================================\n");
  407.     printf("\nBeging finding first set\n");




  412.     //X is included in Vt,F(X)={X};
  413.     for(i=0; i<t->len; i++) {
  414.         t->first[i][0]=t->T[i];
  415.     }

  417.     printf("The terminal symnol's First Set\n");
  418.     for(i=0; i<t->len; i++)
  419.         printf("First(%c)={%c}\n",t->T[i],t->first[i][0]);


  422.     printf("\n");

  424.     for(i=0; i<n->len; i++)
  425.         tags[i]=0;
  426.     

  428.     for(i=0; i<p->len; i++) {
  429.         //X->a..... a is included in first[X]
  430.         if(belong_T(p->pro[i]->back[0],t)) {
  431.             for(j=0; j<n->len; j++) {
  432.                 if(p->pro[i]->front==n->N[j]) {
  433.                     temp=tags[j]++;
  434.                     n->first[j][temp]=p->pro[i]->back[0];

  436.                     //lock[j]=0;
  437.                     break;
  438.                 }
  439.             }
  440.         }
  441.         //X-># & is included in First[X]
  442.         else if(p->pro[i]->back[0]=='#') {
  443.             for(j=0; j<n->len; j++) {
  444.                 if(p->pro[i]->front==n->N[j]) {
  445.                     temp=tags[j]++;
  446.                     n->first[j][temp]='&';

  448.                     //    lock[j]=0;
  449.                     break;
  450.                 }
  451.             }

  453.         }
  454.     }

  456.     while(loop==1) {
  457.         loop=0;
  458.         for(i=0; i<n->len; i++)
  459.             judge[i]=tags[i];
  460.         for(i=0; i<p->len; i++) {

  462.             //flag=0;
  463.             if(p->pro[i]->back[0]=='#')
  464.                 continue;
  465.             if(belong_T(p->pro[i]->back[0],t))
  466.                 continue;
  467.             for(a=0; a<n->len; a++)
  468.                 if(n->N[a]==p->pro[i]->front)
  469.                     break;
  470.             j=0;
  471.             while('#'!=p->pro[i]->back[j]) {
  472.                 if(belong_Arr(p->pro[i]->back[j],n->p_emp)) {
  473.                     for(b=0; b<n->len; b++)
  474.                         if(n->N[b]==p->pro[i]->back[j])
  475.                             break;
  476.                     tags[a]=join(n->first[a],n->first[b],tags[a],tags[b]);
  477.                     j++;
  478.                 } else if(belong_Arr(p->pro[i]->back[j],n->n_emp)) {
  479.                     for(b=0; b<n->len; b++)
  480.                         if(n->N[b]==p->pro[i]->back[j])
  481.                             break;
  482.                     tags[a]=join(n->first[a],n->first[b],tags[a],tags[b]);

  484.                     break;
  485.                 } else if(belong_T(p->pro[i]->back[j],t)) {
  486.                     if(!belong_Arr(p->pro[i]->back[j],n->first[a])) {
  487.                         n->first[a][tags[a]++]=p->pro[i]->back[j];
  488.                     }
  489.                     break;

  491.                 }

  493.             }
  494.             if(p->pro[i]->back[j]=='#')
  495.                 if(!belong_Arr('&',n->first[a]))
  496.                     n->first[a][tags[a]++]='&';
  497.         }

  499.         for(i=0; i<n->len; i++)
  500.             if(judge[i]!=tags[i]) {
  501.                 loop=1;
  502.                 break;
  503.             }

  505.     }

  507.     printf("The not_terminal symbol's First Set\n");
  508.     for(m=0; m<n->len; m++) {
  509.         printf("First(%c)={",n->N[m]);
  510.         //printf("%d ",tags[i]);
  511.         for(j=0; j<tags[m]; j++)
  512.             printf("%c ",n->first[m][j]);

  514.         printf("}\n");
  515.     }

  517.     printf("\n");
  518.     printf("\n");
  519.     for(i=0; i<p->len; i++) {
  520.         if(p->pro[i]->back[0]=='#') {
  521.             p->string_first[i][0]='&';
  522.         }

  524.         else if(!belong_Arr(p->pro[i]->back[0],n->p_emp))
  525.             if(belong_T(p->pro[i]->back[0],t)) {
  526.                 for(j=0; j<t->len; j++)
  527.                     if(p->pro[i]->back[0]==t->T[j])
  528.                         break;
  529.                 join_arr(p->string_first[i],t->first[j]);
  530.             } else {
  531.                 for(j=0; j<n->len; j++)
  532.                     if(p->pro[i]->back[0]==n->N[j])
  533.                         break;
  534.                 join_arr(p->string_first[i],n->first[j]);
  535.             }
  536.         else {
  537.             j=0;
  538.             while(p->pro[i]->back[j]!='#') {
  539.                 if(belong_Arr(p->pro[i]->back[j],n->p_emp)) {
  540.                     for(k=0; k<n->len; k++)
  541.                         if(n->N[k]==p->pro[i]->back[j])
  542.                             break;
  543.                     temp=join_arr(p->string_first[i],n->first[k]);
  544.                 } else {
  545.                     for(k=0; k<n->len; k++)
  546.                         if(n->N[k]==p->pro[i]->back[j])
  547.                             break;
  548.                     temp=join_arr(p->string_first[i],n->first[k]);
  549.                     break;
  550.                 }
  551.                 j++;
  552.             }
  553.             if(p->pro[i]->back[j]=='#')
  554.                 p->string_first[i][temp]='&';
  555.         }
  556.     }
  557.     printf("-----------------------------------------\n");
  558.     printf("The First Set of the right of produce\n");

  560.     for(i=0; i<p->len; i++) {

  562.         printf("First(");
  563.         j=0;
  564.         if(p->pro[i]->back[0]=='#')
  565.             printf("&");
  566.         else
  567.             while(p->pro[i]->back[j]!='#') {
  568.                 printf("%c",p->pro[i]->back[j]);
  569.                 j++;
  570.             }
  571.         printf(")={");
  572.         j=0;
  573.         while(p->string_first[i][j]!='\0') {
  574.             printf("%c ",p->string_first[i][j]);
  575.             j++;
  576.         }
  577.         printf("}\n");
  578.     }
  579.     printf("\n\n");

  581.     return ;


  584. }
  585. void get_follow_set(Prod p,NTer n,Ter t,char s_syb)
  586. {
  587.     int i,j,k,len,m,x,loop;
  588.     int tags[n->len];
  589.     int flags[n->len];
  590.     for(i=0; i<n->len; i++) {
  591.         tags[i]=0;
  592.         flags[i]=0;
  593.     }
  594.     printf("=====================================================\n");

  596.     printf("start finding follow set\n");
  597.     for(i=0; i<n->len; i++)
  598.         if(s_syb==n->N[i]) {
  599.             n->follow[i][0]='#';
  600.             tags[i]++;
  601.             break;
  602.         }
  603.     loop=1;
  604.     while(loop==1) {
  605.         loop=0;
  606.         for(i=0; i<n->len; i++)
  607.             flags[i]=tags[i];
  608.         for(i=0; i<p->len; i++) {
  609.             j=0;
  610.             while(p->pro[i]->back[j]!='#') {
  611.                 if(belong_N(p->pro[i]->back[j],n)) {
  612.                     for(k=0; k<n->len; k++)
  613.                         if(n->N[k]==p->pro[i]->back[j])
  614.                             break;
  615.                     if(p->pro[i]->back[j+1]!='#') {
  616.                         if(belong_N(p->pro[i]->back[j+1],n)) {
  617.                             for(m=0; m<n->len; m++)
  618.                                 if(n->N[m]==p->pro[i]->back[j+1])
  619.                                     break;
  620.                             tags[k]=join_arr(n->follow[k],n->first[m]);
  621.                             if(belong_Arr(n->N[m],n->p_emp)) {
  622.                                 for(x=0; x<n->len; x++)
  623.                                     if(n->N[x]==p->pro[i]->front)
  624.                                         break;
  625.                                 tags[k]=join_arr(n->follow[k],n->follow[x]);

  627.                             }
  628.                         } else if(belong_T(p->pro[i]->back[j+1],t)) {
  629.                             if(!belong_Arr(p->pro[i]->back[j+1],n->follow[k])) {
  630.                                 len=strlen(n->follow[k]);
  631.                                 n->follow[k][len]=p->pro[i]->back[j+1];
  632.                                 tags[k]++;
  633.                             }
  634.                         }

  636.                     }


  639.                     else {
  640.                         for(x=0; x<n->len; x++)
  641.                             if(n->N[x]==p->pro[i]->front)
  642.                                 break;
  643.                         tags[k]=join_arr(n->follow[k],n->follow[x]);
  644.                     }
  645.                 }
  646.                 j++;
  647.             }
  648.         }

  650.         for(i=0; i<n->len; i++)
  651.             if(flags[i]!=tags[i]) {
  652.                 loop=1;
  653.                 break;
  654.             }
  655.     }


  658.     printf("The not terminal symbols follow sets are:\n");

  660.     for(i=0; i<n->len; i++) {
  661.         j=0;
  662.         printf("Follow(%c)={",n->N[i]);
  663.         while(n->follow[i][j]!='\0') {
  664.             printf("%c ",n->follow[i][j]);
  665.             j++;
  666.         }
  667.         printf("}\n");
  668.     }
  669. }
  670. void get_select_set(Prod p, NTer n, Ter t) {
  671.     int i, j, k;
  672.     int flag = 0;
  673.     for (i = 0; i < p->len; i++) {

  675.         if (p->pro[i]->back[0] == '#') {
  676.             for (k = 0; k < n->len; k++)
  677.                 if (n->N[k] == p->pro[i]->front)
  678.                     break;

  680.             join_arr(p->select[i], n->follow[k]);
  681.             continue;
  682.         }
  683.         j = 0;
  684.         flag = 0;
  685.         while (p->pro[i]->back[j] != '#') {
  686.             if (!belong_Arr(p->pro[i]->back[j], n->p_emp)) {
  687.                 //flag=1;
  688.                 break;
  689.             }
  690.             j++;
  691.         }
  692.         if (p->pro[i]->back[j] == '#') {
  693.             flag = 1;
  694.         }
  695.         if (flag == 0) {
  696.             join_arr(p->select[i], p->string_first[i]);
  697.         } else if (flag == 1) {
  698.             join_arr(p->select[i], p->string_first[i]);
  699.             for (k = 0; k < n->len; k++)
  700.                 if (n->N[k] == p->pro[i]->front)
  701.                     break;
  702.             join_arr(p->select[i], n->follow[k]);
  703.         }

  705.     }

  707.     printf("=============================================\n");
  708.     printf("\nThe select set:\n");

  710.     for (i = 0; i < p->len; i++) {
  711.         printf("select(%c->", p->pro[i]->front);
  712.         j = 0;
  713.         while (p->pro[i]->back[j] != '#') {
  714.             printf("%c", p->pro[i]->back[j]);
  715.             j++;
  716.         }
  717.         printf(")={");
  718.         j = 0;
  719.         while (p->select[i][j] != '\0') {
  720.             printf("%c ", p->select[i][j]);
  721.             j++;
  722.         }
  723.         printf("}\n");

  725.     }
  726.     printf("=============================================\n");
  727. }
  728. int isLL1(Prod p)
  729. {
  730.     int i=0;
  731.     int j;
  732.     for(i=0;i<p->len-1;i++)
  733.         for(j=i+1;j<p->len;j++){
  734.             if(p->pro[i]->front==p->pro[j]->front)
  735.             if(strcmp(p->select[i],p->select[j])==0){
  736.                 printf("\nThis is not LL1\n");
  737.                 return 0;
  738.             }
  739.         }


  742.     printf("\nThis is LL1\n");
  743.     printf("\n===========================================\n");
  744.     printf("\n===========================================\n");
  745.     return 1;
  746. }

  748. int main()
  749. {
  750.     int i=0,j=0;
  751.     char temp;
  752.     char tem[100];

  754. //char pro_e[length],npro_e[length];//the symbol can can't produce empty

  756.     G g=(G)malloc(sizeof(grame));
  757.     g->t_symbol=(Ter)malloc(sizeof(ter));
  758.     g->n_symbol=(NTer)malloc(sizeof(nter));
  759.     g->produce=(Prod)malloc(sizeof(prodx));



  763. //get not-terminal symbol
  764.     printf("Enter not-terminal\n");
  765.     while(1) {
  766.         scanf("%c",&temp);
  767.         if(temp=='$') {
  768.             g->n_symbol->len=i;
  769.             i=0;
  770.             break;
  771.         }
  772.         g->n_symbol->N[i++]=temp;

  774.     }




  779. //get terminal symbol
  780.     getchar();
  781.     printf("Enter terminal\n");
  782.     while(1) {
  783.         scanf("%c",&temp);
  784.         if(temp=='$') {
  785.             g->t_symbol->len=i;
  786.             i=0;
  787.             break;
  788.         }
  789.         g->t_symbol->T[i++]=temp;

  791.     }

  793. //get start symbol-------->S

  795.     printf("Enter the start symbol(end pressing Enter)\n");
  796.     getchar();
  797.     scanf("%c",&temp);
  798.     g->start_symbol=temp;

  800. //get produce
  801.     j=0;
  802.     printf("Enter Produce\n");

  804.     while(1) {
  805.         scanf("%s",tem);

  807.         if(tem[0]=='$') {
  808.             g->produce->len=j;
  809.             j=0;
  810.             break;
  811.         }

  813.         g->produce->pro[j]=(Pro)malloc(sizeof(prox));
  814.         g->produce->pro[j]->front=tem[0];
  815.         for(i=3; i<sizeof(tem); i++) {
  816.             g->produce->pro[j]->back[i-3]=tem[i];
  817.         }
  818.         j++;
  819.     }

  821. //printf("%s\n",g->produce->pro[0]->back);

  823.     find_null(g->produce,g->n_symbol,g->t_symbol);
  824.     get_first_set(g->produce,g->n_symbol,g->t_symbol);
  825.     get_follow_set(g->produce,g->n_symbol,g->t_symbol,g->start_symbol);
  826.     get_select_set(g->produce,g->n_symbol,g->t_symbol);
  827.     isLL1(g->produce);
  828.     return 0;

  830. }
这段代码呢，里面写了点注释，如果各位高手们看到我写的代码的不足之处，请之处，谢谢……

对了，这里附上两个测试用例：
1：EeTtF$ +*()i$ E E->Te# e->+Te# e-># T->Ft# t->*Ft# t-># F->i# F->(E)# $
2 : SACB$ ab$ S S->Ab# S->Ba# A->aC# C->A# C-># B->a# $

如果在Linux环境下的话，我们可以用管道命令来简化输入，把上面的两个例子分别放在两个文件两面，如果命名为test，则在终端输入:cat test|./compile
 
声明：此程序，我是在gcc编译环境下编译的，在windows中用VC的话运行好像是有错的，可以试试用Dev
阅读(7688) | 评论(1) | 转发(0) |
0

上一篇：GTK(二)

下一篇：GUI 主循环设计及其在 MiniGUI, GTK, QT 的实现

给主人留下些什么吧！~~

七星鲁王宫2018-12-19 15:59:41

小写字母是终结符 怎么会有产生式

回复 | 举报
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6