一个yacc的问题，求助！

susesuse

我想写一个解释简单sql语言的解释器，用lex和yacc做。 我先试着写了很简单的sql.l sql.y如下，想先实现最简单的CREATE TABLE功能。

sql.l

1. %{
   
2.         #include "y.tab.h" //<>
   
3.         #include <stdlib.h>
   
4.         #include <string.h>
   
5.         void yyerror(char *);
   
6. %}
   
7. 
   
8. %%
   
9. CREATE                                { return CREATE;}
   
10. 
    
11. TABLE                                { return TABLE;}
    
12. 
    
13. 
    
14. [0-9]+                                {
    
15.                                                 yylval.intval = atoi(yytext);
    
16.                                                 return INTEGER;
    
17.                                         }       
    
18. 
    
19. [a-z][a-z0-9]*                {
    
20.                                                 strcpy(yylval.nameval, yytext);
    
21.                                            //        fprintf(stderr, "-----%s\n", *yytext);
    
22.                                                 return NAME;
    
23.                                         }
    
24. 
    
25. [<>=]                                {
    
26.                                                 yylval.compval = yytext[0];
    
27.                                                 return COMPARE;
    
28.                                         }
    
29. 
    
30. [\n]                {        return *yytext;
    
31.                                         }
    
32. 
    
33. [ \t]                                ;
    
34. 
    
35. .                                        {
    
36.                                                 yyerror("Unknown Character!");
    
37.                                         }
    
38. %%
    
39. 
    
40. int yywrap(void)
    
41. {
    
42.         return 1;
    
43. }

复制代码

sql.y如下：

1. %{
   
2.         #include <stdio.h>
   
3.         void yyerror(char *s);
   
4.         int yylex(void);
   
5. 
   
6. %}
   
7. 
   
8. %union {
   
9.                         int intval;
   
10.                         char nameval[50];
    
11.                         char compval;
    
12.                 };
    
13. 
    
14. %token <intval> INTEGER
    
15. %token <nameval> NAME
    
16. %token <compval> COMPARE
    
17. %token CREATE TABLE
    
18. 
    
19. %%
    
20. createtablestatement:
    
21.                 | createtablestatement '\n'
    
22.                 | CREATE TABLE NAME '\n' {printf("%s\n", $3);}
    
23.                 ;
    
24. 
    
25. %%
    
26. void yyerror(char *s)
    
27. {
    
28.         fprintf(stderr," %s\n", s);
    
29. }
    
30. 
    
31. int main(void)
    
32. {
    
33.         yyparse();
    
34. }
    

复制代码

编译运行如下:

lex sql.l
yacc -d sql.y
gcc -o create lex.yy.c y.tab.c -ll

$./create
CREATE TABLE aaaa
aaaa
CREATE TABLE bbbb
parse error
$

我想问一下为啥我第一次语法分析能成功，第二次就有问题呢？该怎么改呢？请知道的大虾指教，谢谢！

susesuse

顶一下，大虾帮忙阿！

cjaizss

因为你的起始符号为
createtablestatement,
于是你所有的输入在语法不出错的时候要被规约为createtablestatement
CREATE TABLE aaaa
CREATE TABLE bbbb
这样的输入当然不符合你的语法
你要干的是造一个新的符号作为起始符号(当然,依然用createtablestatement也可),把原来的一组createtablestatement串进去

susesuse

小弟驽钝，没有理解你的意思。
您能说得更具体点吗？帮着改一下可以吗？

cjaizss

在yacc语言里,两个%%之后紧接着的符号是start symbol,也就是你的所有输入都会被规约为这个符号.
你可以在前面加上这句试下
start:createtablestatement |start createtablestatement;

susesuse

多谢版主的指点，我今天完善了下这个程序，又碰到些问题，烦请您再指点一下。

sql.l

1. 
   
2. %{
   
3.         #include "sql.h"
   
4.         #include "y.tab.h"
   
5.         #include <stdlib.h>
   
6.         #include <string.h>
   
7.         void yyerror(char *);
   
8. %}
   
9. 
   
10. %%
    
11. CREATE                                {  return CREATE;}
    
12. 
    
13. TABLE                                {  return TABLE;}
    
14. 
    
15. INT                 {
    
16.                                                 strcpy(yylval.attr_type, yytext);
    
17.                                                 return TYPE;
    
18.                                         }
    
19. 
    
20. STR20                                {
    
21.                                                 strcpy(yylval.attr_type, yytext);
    
22.                                                 return TYPE;
    
23.                                         }
    
24. 
    
25. [0-9]+                                {
    
26.                                                 yylval.intval = atoi(yytext);
    
27.                                                 return INTEGER;
    
28.                                         }       
    
29. 
    
30. [a-z][a-z0-9]*                {
    
31.                                                 strcpy(yylval.attr_name, yytext);
    
32.                                            //        fprintf(stderr, "-----%s\n", *yytext);
    
33.                                                 return NAME;
    
34.                                         }
    
35. [()\n]                                {
    
36.                                                 return *yytext;
    
37.                                         }
    
38. [ \t]                                ;
    
39. 
    
40. .                                        {
    
41.                                                 yyerror("Unknown Character!");
    
42.                                         }
    
43. %%
    
44. 
    
45. int yywrap(void)
    
46. {
    
47.         return 1;
    
48. }
    

复制代码

sql.y:

1. 
   
2. %{
   
3.         #include <stdio.h>
   
4.         #include <string.h>
   
5.         #include "sql.h"
   
6.         int i  = 0;
   
7.         struct attr_name_type array[20];
   
8.         void yyerror(char *s);
   
9.         int yylex(void);
   
10.     struct attr_name_type copy(char *b, char *c);
    
11.         struct attr_name_type * copy_to_list(struct attr_name_type a);
    
12. %}
    
13. 
    
14. %union {
    
15.                         int intval;
    
16.                         char attr_type[10];
    
17.                         char attr_name[20];
    
18.                         struct attr_name_type nametype;
    
19.                         struct attr_name_type *list;
    
20.                 };
    
21. 
    
22. %token <intval> INTEGER
    
23. %token <attr_name> NAME
    
24. %token <attr_type> TYPE
    
25. %token CREATE TABLE
    
26. 
    
27. %type <attr_type> type
    
28. %type <attr_name> name
    
29. %type <nametype> attrnametype
    
30. %type <list> attributelist
    
31. %%
    
32. start:
    
33. createtablestatement |start createtablestatement;
    
34. 
    
35. createtablestatement:
    
36.                 CREATE TABLE name left_bracket attributelist ')' '\n'        {
    
37.                                                                                                 printf("table name: %s\n", $3);
    
38.                                                                                                 printf("NAME        TYPE\n");
    
39.                                                                                                 int j;
    
40.                                                                                                 for(j = 0; j < i; j++)
    
41.                                                                                                 {
    
42.                                                                                                         printf("%s        %s\n", ($5[j]).name, ($5[j]).type);
    
43.                                                                                                 }
    
44. 
    
45.                                                                                                 i = 0;
    
46.                                                                                          }
    
47.                 ;
    
48. 
    
49. attributelist:
    
50.                         attrnametype { //zhi zhixing yici.
    
51.                                                         $$ = copy_to_list($1);
    
52.                                                 //        printf("First added: %s        %s\n", $$[i - 1].name, $$[i - 1].type);
    
53.                                                  }
    
54. 
    
55. 
    
56.                         | attributelist attrnametype {  //wang zhebianzou
    
57.                                                                                         copy_to_list($2);
    
58.                                                                                         $$ = $1;
    
59.                                                                                  }
    
60.                         ;
    
61. 
    
62. attrnametype:
    
63.                         name type        {
    
64.                                             $$ = copy($1, $2);
    
65.                         }
    
66.                         | attrnametype '\n'                               
    
67.             ;
    
68. left_bracket:
    
69.      '('
    
70.          | left_bracket '\n'
    
71.          ;
    
72. name: NAME
    
73.       | name '\n'
    
74.           ;
    
75. type: TYPE
    
76.                 ;
    
77. 
    
78. 
    
79. %%
    
80. void yyerror(char *s)
    
81. {
    
82.         fprintf(stderr," %s\n", s);
    
83. }
    
84. 
    
85. struct attr_name_type * copy_to_list(struct attr_name_type a)
    
86. {
    
87. //        memmove(&(a[i]), &b, sizeof(struct attr_name_type));
    
88.     strcpy(array[i].name, a.name);
    
89.         strcpy(array[i].type, a.type);
    
90.         i++;
    
91. 
    
92.         return array;
    
93. }
    
94. 
    
95. struct attr_name_type copy(char *b, char *c)
    
96. {
    
97.         struct attr_name_type a;
    
98.         strcpy(a.name, b);
    
99.         strcpy(a.type, c);
    
100. 
     
101.         return a;
     
102. }
     
103.                                                
     
104. 
     
105. int main(void)
     
106. {
     
107.         yyparse();
     
108. }

复制代码

sql.h:

1. 
   
2. struct attr_name_type
   
3. {
   
4.                     char type[10];
   
5.                           char name[20];
   
6. };

复制代码

编译运行如下：
/2$ lex sql.l
/2$ yacc -d sql.y
/2$ gcc -o create lex.yy.c y.tab.c -ll
/2$ ./create
CREATE TABLE aaa
(
bbb INT
ccc INT)
table name: aaa
NAME        TYPE
bbb        INT
ccc        INT


这其中，
CREATE TABLE aaa
(
bbb INT
ccc INT)输入，下面是输出。

它建立了一个名字为aaa的表，有两个类型为int的参数bbb ccc.

不过我的程序如果这样输出时会有错误：

先输入一个或多个回车以后在输入
CREATE TABLE aaa
(
bbb INT
ccc INT)
就不能很好地分析了。
该怎么改才能让他支持可以先输入回车呢？请指点迷津，多谢了！

[ 本帖最后由 susesuse 于 2008-10-5 14:34 编辑 ]