编译原理实验（算符优先文法）

work.h

 1 #include<iostream>
 2 #include<stdlib.h>
 3 #include<stdio.h>
 4 #include<string.h>
 5 
 6 /*************STRUCT*************/
 7 #ifndef keyword
 8 #define keyword
 9 /*
10  * 关键字结构，用于work2.cpp
11  */
12 struct KEYWORD_NODE{
13     char val[100];
14 };
15 
16 /*
17  * 非终结符结构，用于work3.cpp
18  */
19 struct N_NODE{//非终结符
20     char val;//值
21     int cnt;//产生式数目
22     char ARR[30][30];
23 };
24 #endif
25 
26 /************FUNCTION************/
27 void init();
28 bool isLetter(char ch);
29 void dealSourceCode();
30 void morphologyAnalysis();
31 void dealOperatorPrecedenceGrammar();
32 using namespace std;

init.cpp

 1 /***************************************************************\
 2  *Author:Hu Wenbiao
 3  *Created Time: Mon 15 Nov 2010 09:12:44 PM CST
 4  *File Name: init.cpp
 5  *Description:执行各文件所需的初始化操作
 6 \***************************************************************/
 7 //*========================*Head File*========================*\\
 8 
 9 #include"work.h"
10 /*----------------------*Global Variable*----------------------*/
11 //work2.cpp
12 extern KEYWORD_NODE KEYWORD[30];
13 //work3.cpp
14 extern bool F[30][30],L[30][30];
15 extern N_NODE N_ARRAY[30];
16 extern char T_ARRAY[30];
17 extern char PRECEDENCETABLE[30][30];
18 //*=======================*Main Program*=======================*//
19 
20 /*
21  * 设置关键字，用于work2.cpp的初始化
22  */
23 void setKeyword(int pos,string str){
24     int p=0;
25     while(str[p]){
26         KEYWORD[pos].val[p]=str[p];
27         p++;
28     }
29 }
30 
31 /*
32  * 各文件的初始化
33  */
34 void init(){
35 
36     /*
37      * work2.cpp
38      */
39     memset(KEYWORD,0,sizeof(KEYWORD));
40     setKeyword(1,"const");
41     setKeyword(2,"var");
42     setKeyword(3,"procedure");
43     setKeyword(4,"call");
44     setKeyword(5,"begin");
45     setKeyword(6,"end");
46     setKeyword(7,"if");
47     setKeyword(8,"then");
48     setKeyword(9,"while");
49     setKeyword(10,"do");
50     setKeyword(11,"odd");
51     setKeyword(12,"+");
52     setKeyword(13,"-");
53     setKeyword(14,"*");
54     setKeyword(15,"/");
55     setKeyword(16,">");
56     setKeyword(17,">=");
57     setKeyword(18,"<");
58     setKeyword(19,"<=");
59     setKeyword(20,"=");
60     setKeyword(21,"<>");
61     setKeyword(22,".");
62     setKeyword(23,"(");
63     setKeyword(24,")");
64     setKeyword(25,",");
65     setKeyword(26,";");
66     setKeyword(27,":=");
67 
68     /*
69      * work3.cpp
70      */
71     memset(N_ARRAY,0,sizeof(N_ARRAY));
72     memset(T_ARRAY,0,sizeof(T_ARRAY));
73     memset(F,0,sizeof(F));
74     memset(L,0,sizeof(F));
75     memset(PRECEDENCETABLE,0,sizeof(PRECEDENCETABLE));
76 }

work1.cpp

  1 /***************************************************************\ * Author: Hu Wenbiao
  2  * Created Time: Wed 06 Oct 2010 09:29:56 AM CST
  3  * File Name: work1.cpp
  4  * Description: 处理源代码格式，将多余空格去掉，换行，跳格改成空格
  5  * 去掉注释。
  6 \***************************************************************/
  7 //*========================*Head File*========================*\\
  8 
  9 #include "work.h"
 10 /*----------------------*Global Variable*----------------------*/
 11 
 12 //*=======================*Main Program*=======================*//
 13 
 14 /*
 15  * 处理空格和注释
 16  */
 17 void dealSourceCode(){
 18     bool space=false,multiply=false,slash=false,quote=false;
 19     char ch;
 20     int slash_multiply=0;
 21     while(scanf("%c",&ch)!=EOF){
 22 
 23         if(ch=='\\'){//转义符
 24             printf("\\");
 25             scanf("%c",&ch);
 26             printf("%c",ch);
 27             continue;
 28         }
 29 
 30         if(quote){//有引号
 31             //有printf("\"")这种情况
 32             //有printf("\\")这种情况
 33             //有printf("")这种情况
 34 
 35             if(ch=='\"'){//第三种情况
 36                 printf("\"");
 37                 quote=false;
 38                 continue;
 39             }
 40 
 41              /* 处理前两种情况*/
 42             char buf[10000];
 43             int p=0;
 44             buf[p++]=ch;
 45             while(scanf("%c",&buf[p])!=EOF&&(buf[p]!='\"'||(buf[p-1]=='\\'&&(p==1||buf[p-2]!='\\'))))p++;
 46             buf[p+1]='\0';
 47             printf("%s",buf);
 48             quote=false;
 49             continue;
 50         }
 51 
 52         if(ch==' '||ch=='\n'||ch=='\t'){//空格处理
 53             if(!space){
 54                 printf(" ");
 55                 space=true;
 56             }
 57             while(scanf("%c",&ch)!=EOF&&(ch==' '||ch=='\n'||ch=='\t'));
 58         }
 59 
 60         if(ch=='/'){//有可能是注释，注释处理
 61             scanf("%c",&ch);
 62 
 63             if(ch=='/'){//单行注释
 64                 while(scanf("%c",&ch)!=EOF&&ch!='\n');
 65             }
 66             else if(ch=='*'){//多行注释
 67                 slash_multiply=1;
 68                 slash=multiply=false;
 69                 while(slash_multiply){
 70                     if(scanf("%c",&ch)==EOF)break;//输入源文件语法错误
 71                     if(ch=='/'){
 72                         if(multiply){
 73                             slash_multiply--;
 74                             multiply=slash=false;
 75                         }
 76                         else
 77                           slash=true;
 78                     }
 79                     else if(ch=='*'){
 80                         if(slash){
 81                             slash_multiply++;
 82                             multiply=slash=false;
 83                         }
 84                         else
 85                           multiply=true;
 86                     }
 87                 }
 88             }
 89             else{//不是注释
 90                 printf("/");
 91                 if(ch==' '||ch=='\n'||ch=='\t')
 92                   space=true;
 93                 printf("%c",ch);
 94             }
 95         }
 96         else if(ch=='\"'){//发现第一个引号"\""
 97             printf("\"");
 98             quote=true;
 99         }
100         else{//普通字符
101             printf("%c",ch);
102             space=false;
103         }
104     }
105 }
106 /*
107 int main(){
108     freopen("input.txt","r",stdin);
109     freopen("output.txt","w",stdout);
110     dealSourceCode();
111     return 0;
112 }
113 */

work2.cpp

/***************************************************************\
 *Author:Hu Wenbiao
 *Created Time: Mon 15 Nov 2010 07:09:54 PM CST
 *File Name: work2.cpp
 *Description:词法分析器
\***************************************************************/
//*========================*Head File*========================*\\

#include"work.h"
/*----------------------*Global Variable*----------------------*/

KEYWORD_NODE KEYWORD[30];
//*=======================*Main Program*=======================*//

bool isLetter(char ch){//判断是否是字母
    return (ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')||(ch>='0'&&ch<='9');
}

bool isNumber(char ch){//判断是否是数字
    return ch>='0'&&ch<='9';
}

/*
 *判断是否是关键字，是则返回编码，否则返回28(标识符)
 */
int getKeywordId(char* str,int s,int t){
    int i,p;
    for(i=0;i<12;i++){
        p=0;
        while (KEYWORD[i].val[p] && s+p<=t && 
                    KEYWORD[i].val[p]==str[s+p]){
            p++;
        }

        if(KEYWORD[i].val[p]=='\0' && s+p>t)
          return i;
    }
    return 28;//id
}

/*
 *判断是否是分隔符或操作符，是则返回编码，否则返回0(Error)
 */
int getSepOrOprId(char* str,int s,int t){
    int i,p;
    for(i=12;i<28;i++){
        p=0;
        while (KEYWORD[i].val[p] && s<=t && 
                    KEYWORD[i].val[p]==str[s]){
            p++,s++;
        }

        if(KEYWORD[i].val[p]=='\0' && s>t)
          return i;
    }
    return 0;//Error
}

/*
 * 按要求的格式输出
 */
void printOut(int id,char* str,int s,int t){
    printf("%d: ",id);
    for(;s<=t;s++)
      printf("%c",str[s]);
    printf("\n");
}

/*
 * 是否是分隔符或操作符组成元素
 */
bool isSepOrOpr(char ch){
    return ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='>'||ch=='<'||ch=='='
        ||ch=='.'||ch=='('||ch==')'||ch==','||ch==';'||ch==':';
}

/*
 * 对字符串str进行分析
 */
void dealMorphology(char* str){
    int p=0,s,t;
    while(str[p]){
        s=t=p;
        if(isNumber(str[p])){//整型
            while(str[p]&&isNumber(str[p])) p++;
            t=p-1;
            if(isLetter(str[p])){//整型中有字母，错误
                printOut(0,str,s,t);
            }
            else{//整型
                printOut(29,str,s,t);
            }
        }
        else if(isLetter(str[p])){//标识符
            while(str[p]&&(isLetter(str[p])||isNumber(str[p]))) p++;
            t=p-1;
            printOut(getKeywordId(str,s,t),str,s,t);
        }
        else if(isSepOrOpr(str[p])){//分隔符或操作符
            while(str[p] && isSepOrOpr(str[p])) p++;
            t=p-1;
            printOut(getSepOrOprId(str,s,t),str,s,t);
        }
        else if(s==t&&str[s]=='\n'){
            p++;
            continue;
        }
        else{
            printf("ERROR:\n");
            p++;
        }
    }
}

/*
 * 将dealSourceCode()处理后代码按空格进行分成若干字符串进行分别处理
 */
void morphologyAnalysis(){
    char str[1000]; int p; bool flag=true;
    while(flag){
        p=0;
        while((flag=(scanf("%c",&str[p])!=EOF))&&str[p]!=' ') p++;
        str[p]=0;
        dealMorphology(str);
    }
}

work3.cpp

  1 /***************************************************************\
  2  *Author:Hu Wenbiao
  3  *Created Time: Tue 16 Nov 2010 05:11:20 PM CST
  4  *File Name: work3.cpp
  5  *Description:算符优先文法
  6  * 1.非终结符和终结符的编号（id）都是它们在数组中的下标
  7  * 2.算法只能处理单字符的非终结符和终结符（大写字母为非终结符，
  8  * 其他为终结符）
  9  * 3.处理的表达式必须含有:=且其左边不能含有运算符，否则会被作为
 10  * 标识符的一部分处理
 11  * 4.表达式的标识符可以是字符串如：aa=bb+cc+dd*eef
 12  * 5.处理表达式时先将标识符转化为i（因为文法中只用i表示标识符），
 13  * 标识符的名称在NAME中记录，另外产生的中间标识符（如T1、E2）
 14  * 的名称也在NAME中记录，名称的id为其下标，NAME[0]记录等号“:=”
 15  * 左边的那个标识符，对于其他的标识符若id为0表示出错
 16 \***************************************************************/
 17 //*========================*Head File*========================*\\
 18 
 19 #include<stack>
 20 #include"work.h"
 21 
 22 /*----------------------*Global Variable*----------------------*/
 23 
 24 N_NODE N_ARRAY[30];//非终端符数组（下标从1开始）
 25 char T_ARRAY[30];//终端符数组（下标从1开始）
 26 bool F[30][30],L[30][30];//F[i][j]表示id为j的终结符是否属于
 27                         //id为i的非终结符的FIRSTVT，L相同。
 28 stack<pair<int,int> > S;//用于求FIRSTVT和LASTVT
 29 char PRECEDENCETABLE[30][30];//算符优先关系表
 30 char NAME[100][10];//用来存放标识符名称，NAME[i]表示id为i的标识符
 31 int name_foot[100];//分配中间标识符的下标，如T1中的1
 32 //*=======================*Main Program*=======================*//
 33 
 34 int getTnodeId(char ch){//返回终端符编码（下标），不存在返回0
 35     int p=1;
 36     while(T_ARRAY[p]&&T_ARRAY[p]!=ch) p++;
 37     if(T_ARRAY[p])
 38         return p;
 39     else
 40         return 0;
 41 }
 42 
 43 int getNnodeId(char ch){//返回非终端符编码（下标），不存在返回0
 44     int pos=1;
 45     while(N_ARRAY[pos].val && N_ARRAY[pos].val!=ch) pos++;
 46     if(N_ARRAY[pos].val)
 47       return pos;
 48     else
 49       return 0;
 50 }
 51 
 52 int getNameId(char* str,int s,int t){//给str[s]~str[t]分配位置，并返回id
 53     int ptr=0;
 54     while(NAME[ptr][0])ptr++;
 55 
 56     for(int i=0;s+i<=t;i++)
 57       NAME[ptr][i]=str[s+i];
 58 
 59     return ptr;
 60 }
 61 
 62 int getNameId(char ch){//同上，重载
 63     name_foot[ch]++;
 64     int ptr=0;
 65     while(NAME[ptr][0])ptr++;
 66 
 67     NAME[ptr][0]=ch;
 68     NAME[ptr][1]=char(name_foot[ch]+'0');
 69 
 70     return ptr;
 71 }
 72 
 73 void insertN_ARRAY(char val,char* str,int s,int t){//增加非终结符
 74     int pos=1;
 75     while(N_ARRAY[pos].val&&N_ARRAY[pos].val!=val) pos++;
 76     N_ARRAY[pos].val=val;
 77     int cnt=N_ARRAY[pos].cnt,p=0;
 78     for(;s<=t;p++,s++){
 79         N_ARRAY[pos].ARR[cnt][p]=str[s];
 80     }
 81     N_ARRAY[pos].cnt++;
 82 }
 83 
 84 void insertT_ARRAY(char ch){//增加终结符
 85     int p=1;
 86     while(T_ARRAY[p]) p++;
 87     T_ARRAY[p]=ch;
 88 }
 89 
 90 bool isNnode(char ch){//判断是否是非终结符
 91     return ch>='A'&&ch<='Z';
 92 }
 93 
 94 /*
 95  * 求解所有非终结符的FIRSTVT
 96  */
 97 
 98 void getFIRSTVT(){
 99     pair<int,int> cur;//cur.first是非终结符的id，cur.second是终结符的id
100     int nr_Nnode=1;
101     while(N_ARRAY[nr_Nnode].val) nr_Nnode++;//其实nr_Nnode=(nr of Nnode)+1
102     for(int i=1;i<nr_Nnode;i++){//每个非终结符
103         for(int j=0;j<N_ARRAY[i].cnt;j++){//每个产生式
104             if(!isNnode(N_ARRAY[i].ARR[j][0])){//N_ARRAY[i].ARR[j][0]是终结符
105                 int id_Tnode=getTnodeId(N_ARRAY[i].ARR[j][0]);
106                 if(F[i][id_Tnode])continue;
107                 F[i][id_Tnode]=true;
108                 S.push(pair<int,int>(i,id_Tnode));
109             }
110             //N_ARRAY[i].ARR[j][1]是终结符
111             else if(N_ARRAY[i].ARR[j][1] && !isNnode(N_ARRAY[i].ARR[j][1])){
112                 int id_Tnode=getTnodeId(N_ARRAY[i].ARR[j][1]);
113                 if(F[i][id_Tnode])continue;
114                 F[i][id_Tnode]=true;
115                 S.push(pair<int,int>(i,id_Tnode));
116             }
117         }
118     }
119     while(!S.empty()){
120         cur=S.top(),S.pop();
121         char curNnodeVal=N_ARRAY[cur.first].val;
122 
123         for(int i=1;i<nr_Nnode;i++){
124             if(F[i][cur.second])continue;//cur.second已经属于FIRSTVT(i)
125             for(int j=0;j<N_ARRAY[i].cnt;j++){//查找哪个产生式右边以curNnodeVal为首
126                 if(N_ARRAY[i].ARR[j][0]==curNnodeVal){
127                     F[i][cur.second]=true;
128                     S.push(pair<int,int>(i,cur.second));
129                     break;
130                 }
131             }
132         }
133     }
134     /*输出FIRSTVT*/
135     for(int i=1;i<nr_Nnode;i++){
136         for(int j=1;j<30;j++){
137             if(F[i][j]){
138                 printf("FIRSTVT(%c): {",N_ARRAY[i].val);
139                 while(j<30){
140                     if(F[i][j])
141                       printf("%c ",T_ARRAY[j]);
142                     j++;
143                 }
144                 printf("}\n");
145             }
146         }
147     }
148     printf("\n");
149     /**/
150 }
151 
152 /*
153  * 求解所有非终结符的LASTVT
154  */
155 
156 void getLASTVT(){
157     pair<int,int> cur;
158     int nr_Nnode=1;
159     while(N_ARRAY[nr_Nnode].val) nr_Nnode++;
160     for(int i=1;i<nr_Nnode;i++){
161         for(int j=0;j<N_ARRAY[i].cnt;j++){
162             int ptr=0;
163             while(N_ARRAY[i].ARR[j][ptr]) ptr++;
164             ptr--;
165             if(!isNnode(N_ARRAY[i].ARR[j][ptr])){
166                 int id_Tnode=getTnodeId(N_ARRAY[i].ARR[j][ptr]);
167                 if(L[i][id_Tnode])continue;
168                 L[i][id_Tnode]=true;
169                 S.push(pair<int,int>(i,id_Tnode));
170             }
171             else if(ptr>0&&!isNnode(N_ARRAY[i].ARR[j][ptr-1])){
172                 int id_Tnode=getTnodeId(N_ARRAY[i].ARR[j][ptr-1]);
173                 if(L[i][id_Tnode])continue;
174                 L[i][id_Tnode]=true;
175                 S.push(pair<int,int>(i,id_Tnode));
176             }
177         }
178     }
179     while(!S.empty()){
180         cur=S.top(),S.pop();
181         char curNnodeVal=N_ARRAY[cur.first].val;
182 
183         for(int i=1;i<nr_Nnode;i++){
184             for(int j=0;j<N_ARRAY[i].cnt;j++){
185                 int ptr=0;
186                 while(N_ARRAY[i].ARR[j][ptr]) ptr++;
187                 ptr--;
188                 if(N_ARRAY[i].ARR[j][ptr]==curNnodeVal &&
189                         !L[i][cur.second]){
190                     L[i][cur.second]=true;
191                     S.push(pair<int,int>(i,cur.second));
192                     break;
193                 }
194             }
195         }
196     }
197     /*输出LASTVT*/
198     for(int i=1;i<nr_Nnode;i++){
199         for(int j=1;j<30;j++){
200             if(L[i][j]){
201                 printf("LASTVT(%c): {",N_ARRAY[i].val);
202                 while(j<30){
203                     if(L[i][j])
204                       printf("%c ",T_ARRAY[j]);
205                     j++;
206                 }
207                 printf("}\n");
208             }
209         }
210     }
211     printf("\n");
212     /**/
213 }
214 
215 /*
216  * 求算符优先表
217  */
218 
219 void getPrecedenceTable(){
220     int nr_Nnode=1,nr_Tnode=1;
221     while(N_ARRAY[nr_Nnode].val) nr_Nnode++;
222     while(T_ARRAY[nr_Tnode]) nr_Tnode++;
223 
224     /**关于#的比较**/
225     int id_sharp=getTnodeId('#');
226     for(int j=1;j<nr_Tnode;j++){
227         if(F[1][j]){
228             PRECEDENCETABLE[id_sharp][j]='<';
229         }
230         if(L[1][j]){
231             PRECEDENCETABLE[j][id_sharp]='>';
232         }
233     }
234 
235     /***************/
236 
237     for(int i=1;i<nr_Nnode;i++){//每个非终结符
238         for(int j=0;j<N_ARRAY[i].cnt;j++){//每个产生式
239             int tail=0;
240             while(N_ARRAY[i].ARR[j][tail]) tail++;
241             tail--;//最后一位（非零）
242             for(int p=0;p<tail;p++){
243                 //tt
244                 if(!isNnode(N_ARRAY[i].ARR[j][p]) && 
245                             !isNnode(N_ARRAY[i].ARR[j][p+1])){
246                     int id1=getTnodeId(N_ARRAY[i].ARR[j][p]);
247                     int id2=getTnodeId(N_ARRAY[i].ARR[j][p+1]);
248                     if(PRECEDENCETABLE[id1][id2]){
249                         printf("ERROR:不是算符优先文法!");
250                         exit(EXIT_FAILURE);
251                     }
252                     PRECEDENCETABLE[id1][id2]='=';
253                 }
254                 //tNt
255                 if(p<=tail-2&&!isNnode(N_ARRAY[i].ARR[j][p])&&
256                             isNnode(N_ARRAY[i].ARR[j][p+1])&&
257                             !isNnode(N_ARRAY[i].ARR[j][p+2])){
258                     int id1=getTnodeId(N_ARRAY[i].ARR[j][p]);
259                     int id2=getTnodeId(N_ARRAY[i].ARR[j][p+2]);
260                     if(PRECEDENCETABLE[id1][id2]){
261                         printf("ERROR:不是算符优先文法!");
262                         exit(EXIT_FAILURE);
263                     }
264                     PRECEDENCETABLE[id1][id2]='=';
265                 }
266                 //tN
267                 if(!isNnode(N_ARRAY[i].ARR[j][p]) &&
268                             isNnode(N_ARRAY[i].ARR[j][p+1])){
269                     int id1=getTnodeId(N_ARRAY[i].ARR[j][p]);
270                     int id_Nnode=getNnodeId(N_ARRAY[i].ARR[j][p+1]);
271                     int id2=1;
272                     while(T_ARRAY[id2]){
273                         if(F[id_Nnode][id2]){
274                             if(PRECEDENCETABLE[id1][id2]){
275                                 printf("ERROR:不是算符优先文法!");
276                                 exit(EXIT_FAILURE);
277                             }
278                             PRECEDENCETABLE[id1][id2]='<';
279                         }
280                         id2 ++;
281                     }
282                 }
283                 //Nt
284                 if(isNnode(N_ARRAY[i].ARR[j][p]) &&
285                                 !isNnode(N_ARRAY[i].ARR[j][p+1])){
286                     int id_Nnode=getNnodeId(N_ARRAY[i].ARR[j][p]);
287                     int id2=getTnodeId(N_ARRAY[i].ARR[j][p+1]);
288                     int id1=1;
289                     while(T_ARRAY[id1]){
290                         if(L[id_Nnode][id1]){
291                             if(PRECEDENCETABLE[id1][id2]){
292                                 printf("ERROR:不是算符优先方法!");
293                                 exit(EXIT_FAILURE);
294                             }
295                             PRECEDENCETABLE[id1][id2]='>';
296                         }
297                         id1++;
298                     }
299                 }
300             }
301         }
302     }
303     //////输出优先表////////
304     cout<<"  ";
305     for(int i=1;i<nr_Tnode;i++){
306         cout<<T_ARRAY[i]<<" ";
307     }
308     cout<<endl;
309     for(int i=1;i<nr_Tnode;i++){
310         cout<<T_ARRAY[i]<<" ";
311         for(int j=1;j<nr_Tnode;j++){
312             if(PRECEDENCETABLE[i][j])
313               cout<<PRECEDENCETABLE[i][j]<<" ";
314             else
315               cout<<"  ";
316         }
317         cout<<endl;
318     }
319     cout<<endl;
320     //////////////////////
321 }
322 
323 /*
324  * 比较ARR[s]~ARR[t]中的id和str中的符号是否匹配
325  * 其中非终结符的id是取负值的，比较时也不比较非
326  * 终结符是否相同，只要求终结符相同，非终结符相
327  * 对应就返回true
328  */
329 
330 bool cmpIdNodeVal(pair<int,int>* ARR,int s,int t,char* str){
331     int ptr=0,id;
332     while(s<=t && str[ptr]){
333         if(isNnode(str[ptr])){//非终结符
334             if(ARR[s].first>0)
335               return false;
336         }
337         else if(ARR[s].first!=getTnodeId(str[ptr]))
338           return false;
339         ptr++;
340         s++;
341     }
342     if(s<=t || str[ptr])
343       return false;
344     return true;
345 }
346 
347 /*
348  * 将STACK[s]~STACK[t]归约，返回归约后的非终结符的值，
349  * 分配并由name返回非终结符的名称id
350  */
351 
352 char reduction(pair<int,int>* STACK,int s,int t,int& name){
353     int i=1;
354     while(N_ARRAY[i].val){
355         for(int j=0;j<N_ARRAY[i].cnt;j++){
356             if(cmpIdNodeVal(STACK,s,t,N_ARRAY[i].ARR[j])){//查找成功
357 
358 
359                 ///输出///
360 
361                 if(s==t&&STACK[s].first>0){// 1
362                     name=STACK[s].second;
363                 }
364 
365                 if(s+1==t){// 2
366                         name=getNameId(N_ARRAY[i].val);
367                     if(STACK[s].first>0){
368                         printf("(%c,_,%s,%s)\n",
369                                     T_ARRAY[STACK[s].first],NAME[STACK[t].second],NAME[name]);
370                     }
371                     else{
372                         printf("(%c,%s,_,%s)\n",
373                                     T_ARRAY[STACK[t].first],NAME[STACK[s].second],NAME[name]);
374                     }
375                 }
376                 if(s+2==t){// 3
377                     if(STACK[s].first>0&&STACK[t].first>0){//(T)这种情况
378                         name=STACK[s+1].second;
379                     }
380                     else{
381                         name=getNameId(N_ARRAY[i].val);
382                         printf("(%c,%s,%s,%s)\n",T_ARRAY[STACK[s+1].first],
383                                 NAME[STACK[s].second],NAME[STACK[t].second],NAME[name]);
384                     }
385                 }
386 
387                 //////////
388 
389                 return N_ARRAY[i].val;
390             }
391         }
392         i++;
393     }
394     return 0;
395 }
396 
397 /*
398  * 核心函数，处理传入的单句表达式，要求表达式必须为
399  * abc:=x*y+zuv 的形式，即必须有:=号且其左边不能有运
400  * 算符，否则会被当作标识符的一部分处理
401  */
402 
403 void operatorPrecedenceParser(char* str0){
404     ///将空格去掉///
405     int s=0,t=0,p;
406     while(str0[t]){
407         if(str0[t]!=' '){
408             str0[s]=str0[t];
409             s++;
410         }
411         t++;
412     }
413     str0[s]=0;
414 
415     ///将str0转换成str，由文法符号表示///
416     char str[1000];
417     int str_name[1000];//str_name[i]是str[i]的名称，当str[i]为操作符时无意义
418 
419     memset(NAME,0,sizeof(NAME));
420     memset(name_foot,0,sizeof(name_foot));
421 
422     s=0;
423     while(str0[s]&&str0[s]!=':')s++;
424     if(str0[s]==0){
425         printf("ERROR:表达式不合法\n");
426         return;
427     }
428     getNameId(str0,0,s-1);//放在NAME[0]，在下面进行归约时标识符id为0时表示出错
429     s+=2;// :=右边首字符
430     p=0;
431     while(str0[s]){
432         if(isLetter(str0[s])){//标识符
433             t=s;
434             while(str0[t]&&isLetter(str0[t]))t++;
435             str[p]='i';
436             str_name[p]=getNameId(str0,s,t-1);
437             s=t,p++;
438         }
439         else{//操作符
440             str[p]=str0[s];
441             s++,p++;
442         }
443     }
444     str[p]='#';//结束符
445     str[p+1]=0;
446     //////////////
447     
448     pair<int,int> STACK[1000];//STACK[i].first保存id，正数是Tnode，负数是Nnode
449                               //STACK[i].second保存标识符id 
450     int k=0,j;STACK[k].first=getTnodeId('#');//STACK[k]栈顶
451     p=0;//str[p]当前字符
452     int q,cid;
453 
454     while(str[p]){
455         cid=getTnodeId(str[p]);//当前字符id
456 
457         if(STACK[k].first>0) j=k;
458         else j=k-1;
459 
460         while(PRECEDENCETABLE[STACK[j].first][cid]=='>'){
461             do{
462                 q=STACK[j].first;
463                 j=STACK[j-1].first>0?j-1:j-2;
464             }while(PRECEDENCETABLE[STACK[j].first][q]=='=');
465 
466             int tmp_name=0;
467             char tmp=reduction(STACK,j+1,k,tmp_name);//归约
468             k=j+1;
469             STACK[k].first=-getNnodeId(tmp);
470             if(tmp_name)
471               STACK[k].second=tmp_name;
472             else // name为0表示错误
473               printf("ERROR:tmp_name,when reduction");
474         }
475         if(PRECEDENCETABLE[STACK[j].first][cid]=='<' ||
476                     PRECEDENCETABLE[STACK[j].first][cid]=='='){
477             k++;
478             STACK[k].first=cid,STACK[k].second=str_name[p];
479             p++;
480         }
481         else{
482             if(str[p]=='#'&&j==0){
483 
484                 //给:=左边的符号赋值
485                 printf("(:=,%s,_,%s)\n",NAME[STACK[1].second],NAME[0]);
486 
487                 printf("Done!\n");
488                 return;
489             }
490             else{
491                 printf("ERROR:归约时出错！");
492                 exit(-1);
493             }
494         }
495     }
496     
497 }
498 
499 /*
500  * 读入文法
501  */
502 
503 void readGrammar(){
504     char str[30];
505     
506     while(scanf("%[^\n]%*c",str)!=EOF){
507         ///将空格去掉///
508         int s=0,t=0;
509         while(str[t]){
510             if(str[t]!=' '){
511                 str[s]=str[t];
512                 s++;
513             }
514             t++;
515         }
516         str[s]=0;
517         //////////////
518 
519         if(str[0]<'A'||str[0]>'Z'){//检查首字母是否大写
520             printf("ERROR:首字母不是非终结符\n");
521             continue;
522         }
523         int p=0;
524         while(str[p]&&(str[p]!='-'||str[p+1]!='>')) p++;//检查是否有符号"->"
525         if(!str[p]){
526             printf("ERROR:不是产生式\n");
527             continue;
528         }
529         p+=2;
530         ///找终结符///
531         t=p;
532         while(str[t]){
533             if(!isNnode(str[t])&&str[t]!='|')
534               insertT_ARRAY(str[t]);
535             t++;
536         }
537         //////////////
538 
539         ///找产生式///
540         while(str[p]){
541             s=t=p; 
542             while(str[p]&&str[p]!='|') p++;
543             if(str[p]){
544                 t=p-1,p++;
545             }
546             else
547                 t=p;
548 
549             insertN_ARRAY(str[0],str,s,t);
550         }
551         //////////////
552     }
553     insertT_ARRAY('#');//加入终结符'#'
554 }
555 
556 /*
557  * 算符优先文法主函数
558  */
559 
560 void dealOperatorPrecedenceGrammar(){
561     freopen("input31","r",stdin);
562     freopen("output3","w",stdout);
563     readGrammar();
564     getFIRSTVT();
565     getLASTVT();
566     getPrecedenceTable();
567 
568     freopen("input32","r",stdin);
569     char str[100];
570     while(scanf("%[^\n]%*c",str)!=EOF){
571         operatorPrecedenceParser(str);
572     }
573 }

work.cpp

 1 /***************************************************************\
 2  *Author:Hu Wenbiao
 3  *Created Time: Mon 15 Nov 2010 09:58:46 PM CST
 4  *File Name: work.cpp
 5  *Description:主函数
 6 \***************************************************************/
 7 //*========================*Head File*========================*\\
 8 
 9 #include"work.h"
10 /*----------------------*Global Variable*----------------------*/
11 
12 //*=======================*Main Program*=======================*//
13 
14 int main(){
15     init();
16     freopen("input1","r",stdin);
17     freopen("output1","w",stdout);
18     dealSourceCode();
19     freopen("output1","r",stdin);
20     freopen("output2","w",stdout);
21     morphologyAnalysis();
22 
23     dealOperatorPrecedenceGrammar();//输入的设置在该函数中
24 }