用flex和bison做的一个程序用gcc编译的时候出来莫名其妙的错误

icoming

我用flex和bison写一个很简单的程序，可是用gcc编译的时候怎么都不对，请大虾帮我看看。我已经快不行了，感觉这些编译的错误简直是莫名其妙

compile_6_30.l

1. 
   
2. %{
   
3. #include <stdio.h>;
   
4. #include "common.h"
   
5. #include "compile_6_30.tab.h"
   
6. void yyerror(char *str);
   
7. %}
   
8. 
   
9. %%
   
10. 
    
11. "int" return INT;
    
12. "bool" return BOOL;
    
13. "array" return ARRAY;
    
14. "of" return OF;
    
15. "or" return OR;
    
16. "true" return TRUE;
    
17. "false" return FALSE;
    
18. "if" return IF;
    
19. "then" return THEN;
    
20. 
    
21. [a-zA-Z]*    {
    
22. /*int len=;*/
    
23.         yylval.id=(char *)malloc(strlen(yytext)+1);
    
24.         strncpy(yylval.id , yytext , strlen(yytext)+1);
    
25.         printf("id:%s\n" , yylval.id);
    
26.         return ID;
    
27. }
    

复制代码

compile_6_30.y

1. 
   
2. %{
   
3.   #include <stdio.h>;
   
4.   #include <stdlib.h>;
   
5.   #include "common.h"
   
6. 
   
7.   void yyerror(char *s);
   
8.   /*the function will try to search whether the id has been inserted
   
9.     if id has been inserted, the program exit with an error
   
10.    */
    
11.   void insert(char *id , nodetype *type);
    
12.   nodetype*new_type(nodetype *);
    
13.   void type_error(const char *);
    
14.   /*the nodetype is just a type expression
    
15.     so return nodetype pointer here
    
16.    */
    
17.   nodetype *lookup(const char *);
    
18.   /*
    
19.     if the length of one of arrays is zero, just compare their type
    
20.    */
    
21.   int type_equal(nodetype * , nodetype *);
    
22. 
    
23.   nodetype node1,node2,node3;
    
24. #define INTEGER (&node1)
    
25. #define BOOLEAN (&node2)
    
26. #define ARRAYTYPE (&node3)
    
27. 
    
28.   table global_table;
    
29. %}
    
30. 
    
31. %union{
    
32.   char *id;
    
33.   int num;
    
34.   nodetype *ptr;
    
35. }
    
36. 
    
37. %token<id>; ID
    
38. %token<num>; NUM
    
39. %token INT BOOL IF THEN ASSIGN OF ARRAY OR TRUE FALSE
    
40. %type <ptr>; program var_decls stmts var_decl type_exp stmt exp
    
41. 
    
42. %%
    
43. 
    
44. program:
    
45. var_decls ';' stmts {}
    
46. ;
    
47. 
    
48. var_decls:
    
49. var_decls ';' var_decl{}
    
50. |var_decl {}
    
51. 
    
52. var_decl:
    
53. ID ':' type_exp {
    
54.   insert($1 , $3);
    
55.   free($3);
    
56. }
    
57. 
    
58. type_exp:
    
59. INT {$$=new_type(INTEGER);}
    
60. |BOOL {$$=new_type(BOOLEAN);}
    
61. |ARRAY '[' NUM ']' OF type_exp {
    
62.   ARRAYTYPE->;len=$3;
    
63.   ARRAYTYPE->;child_type=$6;
    
64.   $$=new_type(ARRAYTYPE);
    
65.   free($6);
    
66. }
    
67. ;
    
68. 
    
69. stmts:
    
70. stmts ';' stmt {}
    
71. |stmt {}
    
72. ;
    
73. 
    
74. stmt:
    
75. IF exp THEN stmt {
    
76.   if(!type_equal($2 , BOOLEAN))
    
77.     type_error("exp in if-statement is not boolean");
    
78.   free($2);
    
79. }
    
80. |ID ASSIGN exp{
    
81.   if(!type_equal(lookup($1) , $3))
    
82.     type_error("the type is not coincident in the assign-statement");
    
83.   free($3);
    
84. }
    
85. ;
    
86. 
    
87. exp:
    
88. exp '+' exp {
    
89.   if(!type_equal($1 , INTEGER) || !type_equal($3 , INTEGER))
    
90.     type_error("the two exp are not coincident in add-statement");
    
91.   else
    
92.     $$=new_type(INTEGER);
    
93.   free($1);
    
94.   free($3);
    
95. }
    
96. |exp OR exp {
    
97.   if(!type_equal($1 , BOOLEAN) || !type_equal($3 , BOOLEAN))
    
98.     type_error("the two exp are not coincident in or-statement");
    
99.   else
    
100.     $$=new_type(BOOLEAN);
     
101.   free($1);
     
102.   free($3);
     
103. }
     
104. |exp '[' exp ']' {
     
105.   if(!type_equal($1 , ARRAYTYPE) || !type_equal($3 , INTEGER))
     
106.     type_error("the two exp are not coincident in array-statement");
     
107.   else
     
108.     $$=new_type($1->;child_type);
     
109.   free($1);
     
110.   free($3);
     
111. }
     
112. |NUM {
     
113.   $$=new_type(INTEGER);
     
114. }
     
115. |TRUE {
     
116.   $$=new_type(BOOLEAN);
     
117. }
     
118. |FALSE {
     
119.   $$=new_type(BOOLEAN);
     
120. }
     
121. |ID {
     
122.   $$=new_type(lookup($1));
     
123. }
     
124. ;
     
125. 
     
126. %%
     
127. void yyerror(char *s)
     
128. {
     
129.   printf("%s\n" , s);
     
130.   exit(1);
     
131. }
     
132. /*the function will try to search whether the id has been inserted
     
133.   if id has been inserted, the program exit with an error
     
134.   and type will be free after the function,
     
135.   so here we must allocate a new space for it
     
136. */
     
137. void insert(char *id , nodetype *type)
     
138. {
     
139.   int i;
     
140.   //check the parameter
     
141.   if(type == NULL)
     
142.     yyerror("the parameter of insert()--type is NULL");
     
143.   //check whether id is used
     
144.   for(i=0 ; i < global_table.size ; i++){
     
145.     if(strcmp(global_table.node[i].id , id) == 0){
     
146.       printf("id:%s has been used\n" , id);
     
147.       exit(1);
     
148.     }
     
149.   }
     
150.   //check whether there is enough space
     
151.   if(global_table.size == global_table.capacity){
     
152.     global_table.capacity<<=2;
     
153.     global_table.node=(tablenode *)realloc(global_table.node , global_table.capacity);
     
154.     if(global_table.node == NULL)
     
155.       yyerror("there is no enough space");
     
156.   }
     
157. 
     
158.   /*append the new node*/
     
159.   global_table.node[global_table.size].id=id;
     
160.   global_table.node[global_table.size].type=(nodetype *)malloc(sizeof(nodetype));
     
161.   memcpy(global_table.node[global_table.size].type , type , sizeof(nodetype));
     
162.   global_table.size++;
     
163. }
     
164. 
     
165. nodetype*new_type(nodetype *node)
     
166. {
     
167.   if(node == NULL)
     
168.     yyerror("the parameter of new_type() -- node is NULL");
     
169.   nodetype *tmp=(nodetype *)malloc(sizeof(nodetype));
     
170.   memcpy(tmp , node , sizeof(nodetype));
     
171.   return tmp;
     
172. }
     
173. 
     
174. void type_error(const char *str)
     
175. {
     
176.   yyerror(str);
     
177. }
     
178. /*the nodetype is just a type expression
     
179.   so return nodetype pointer here
     
180. */
     
181. nodetype *lookup(const char *id)
     
182. {
     
183.   int i;
     
184. 
     
185.   if(id == NULL){
     
186.     printf("the parameter of lookup() -- id is NULL");
     
187.     return NULL;
     
188.   }
     
189.   for(i=0 ; i < global_table.size ; i++){
     
190.     if(strcmp(global_table.node[i].id , id))
     
191.       return (global_table.node+i)->;type;
     
192.   }
     
193.   return NULL;
     
194. }
     
195. /*
     
196.   if the length of one of arrays is zero, just compare their type
     
197. */
     
198. int type_equal(nodetype *node1 , nodetype *node2)
     
199. {
     
200.   if(node1 == NULL){
     
201.     printf("the parameter of type_equal() -- node1 is NULL\n");
     
202.     return 0;
     
203.   }
     
204.   if(node2 == NULL){
     
205.     printf("the parameter of type_equal() -- node2 is NULL\n");
     
206.     return 0;
     
207.   }
     
208. 
     
209.   if(node1->;type != node2->;type)
     
210.     return 0;
     
211.   if(node1->;type == ARRAY){
     
212.     if(node1->;child_type->;type != node2->;child_type->;type)/*need modify*/
     
213.       return 0;
     
214.     return node1->;len == 0 || node2->;len == 0 || node1->;len == node2->;len;
     
215.   }
     
216.   return 1;
     
217. }
     
218. 
     
219. int main(int argc , char *argv[])
     
220. {
     
221.   bzero(INTEGER , sizeof(nodetype));
     
222.   bzero(BOOLEAN , sizeof(nodetype));
     
223.   bzero(ARRAYTYPE , sizeof(nodetype));
     
224.   INTEGER->;type=INT;
     
225.   BOOLEAN->;type=BOOL;
     
226.   ARRAYTYPE->;type=ARRAY;
     
227.   
     
228.   global_table.capacity=ONE_BUF;
     
229.   global_table.size=0;
     
230.   global_table.node=(tablenode *)malloc(ONE_BUF);
     
231. 
     
232.   yyparse();
     
233.   exit(0);
     
234. }
     

复制代码

common.h

1. 
   
2. typedef struct nodeType
   
3. {
   
4.   int type;
   
5.   char *id;
   
6.   struct
   
7.   {
   
8.     int len;
   
9.     struct nodeType *child;
   
10.   }u;
    
11. #define len u.len
    
12. #define child_type u.child
    
13. }nodetype;
    
14. 
    
15. typedef struct
    
16. {
    
17.   char *id;
    
18.   nodetype *type;
    
19. }tablenode;
    
20. 
    
21. typedef struct
    
22. {
    
23.   int capacity;
    
24.   int size;
    
25.   tablenode *node;
    
26. }table;
    
27. 
    
28. #define ONE_BUF 32
    

复制代码

我用下面的方式编译flex产生的.c文件：
bison -d compile_6_30.y
flex compile_6_30.l
gcc -c lex.yy.c
结果出来下面的错误
-*- mode: compilation; default-directory: "/windows/E/homework/project/" -*-
gcc -c lex.yy.c
compile_6_30.l: In function `yylex':
compile_6_30.l:33: warning: return makes integer from pointer without a cast
lex.yy.c: In function `yy_scan_string':
lex.yy.c:1394: error: syntax error before '.' token
lex.yy.c:1395: error: `u' undeclared (first use in this function)
lex.yy.c:1395: error: (Each undeclared identifier is reported only once
lex.yy.c:1395: error: for each function it appears in.)
lex.yy.c:1398: warning: passing arg 1 of `yy_scan_bytes' discards qualifiers from pointer target type
lex.yy.c: At top level:
lex.yy.c:1412: error: parse error before '.' token
lex.yy.c: In function `yy_scan_bytes':
lex.yy.c:1413: error: number of arguments doesn't match prototype
lex.yy.c:241: error: prototype declaration
lex.yy.c:1420: error: `u' undeclared (first use in this function)
lex.yy.c:1426: error: `bytes' undeclared (first use in this function)

Compilation exited abnormally with code 1 at Fri Jun 10 00:29:30

编译结果怎么会说有些变量找不到呢？
请大家帮帮忙
谢谢

icoming

实在是不好意思
大家能不能帮我编译一下看看，怎么会出这种编译错误
实在是不应该这样发贴问大家的，只是我实在是没有办法，实在是调不出来