C语言的词法与语法

Question

来自网络，回到网络
全新的，没看过

2. D                       [0-9]
3. L                       [a-zA-Z_]
4. H                       [a-fA-F0-9]
5. E                       [Ee][+-]?{D}+
6. FS                      (f|F|l|L)
7. IS                      (u|U|l|L)*
9. %{
10. #include <stdio.h>
11. #include "y.tab.h"
13. void count();
14. %}
16. %%
17. "/*"                    { comment(); }
19. "auto"                  { count(); return(AUTO); }
20. "break"                 { count(); return(BREAK); }
21. "case"                  { count(); return(CASE); }
22. "char"                  { count(); return(CHAR); }
23. "const"                 { count(); return(CONST); }
24. "continue"              { count(); return(CONTINUE); }
25. "default"               { count(); return(DEFAULT); }
26. "do"                    { count(); return(DO); }
27. "double"                { count(); return(DOUBLE); }
28. "else"                  { count(); return(ELSE); }
29. "enum"                  { count(); return(ENUM); }
30. "extern"                { count(); return(EXTERN); }
31. "float"                 { count(); return(FLOAT); }
32. "for"                   { count(); return(FOR); }
33. "goto"                  { count(); return(GOTO); }
34. "if"                    { count(); return(IF); }
35. "int"                   { count(); return(INT); }
36. "long"                  { count(); return(LONG); }
37. "register"              { count(); return(REGISTER); }
38. "return"                { count(); return(RETURN); }
39. "short"                 { count(); return(SHORT); }
40. "signed"                { count(); return(SIGNED); }
41. "sizeof"                { count(); return(SIZEOF); }
42. "static"                { count(); return(STATIC); }
43. "struct"                { count(); return(STRUCT); }
44. "switch"                { count(); return(SWITCH); }
45. "typedef"               { count(); return(TYPEDEF); }
46. "union"                 { count(); return(UNION); }
47. "unsigned"              { count(); return(UNSIGNED); }
48. "void"                  { count(); return(VOID); }
49. "volatile"              { count(); return(VOLATILE); }
50. "while"                 { count(); return(WHILE); }
52. {L}({L}|{D})*           { count(); return(check_type()); }
54. 0[xX]{H}+{IS}?          { count(); return(CONSTANT); }
55. 0{D}+{IS}?              { count(); return(CONSTANT); }
56. {D}+{IS}?               { count(); return(CONSTANT); }
57. L?'(\\.|[^\\'])+'       { count(); return(CONSTANT); }
59. {D}+{E}{FS}?            { count(); return(CONSTANT); }
60. {D}*"."{D}+({E})?{FS}?  { count(); return(CONSTANT); }
61. {D}+"."{D}*({E})?{FS}?  { count(); return(CONSTANT); }
63. L?\"(\\.|[^\\"])*\"     { count(); return(STRING_LITERAL); }
65. "..."                   { count(); return(ELLIPSIS); }
66. ">>="                   { count(); return(RIGHT_ASSIGN); }
67. "<<="                   { count(); return(LEFT_ASSIGN); }
68. "+="                    { count(); return(ADD_ASSIGN); }
69. "-="                    { count(); return(SUB_ASSIGN); }
70. "*="                    { count(); return(MUL_ASSIGN); }
71. "/="                    { count(); return(DIV_ASSIGN); }
72. "%="                    { count(); return(MOD_ASSIGN); }
73. "&="                    { count(); return(AND_ASSIGN); }
74. "^="                    { count(); return(XOR_ASSIGN); }
75. "|="                    { count(); return(OR_ASSIGN); }
76. ">>"                    { count(); return(RIGHT_OP); }
77. "<<"                    { count(); return(LEFT_OP); }
78. "++"                    { count(); return(INC_OP); }
79. "--"                    { count(); return(DEC_OP); }
80. "->"                    { count(); return(PTR_OP); }
81. "&&"                    { count(); return(AND_OP); }
82. "||"                    { count(); return(OR_OP); }
83. "<="                    { count(); return(LE_OP); }
84. ">="                    { count(); return(GE_OP); }
85. "=="                    { count(); return(EQ_OP); }
86. "!="                    { count(); return(NE_OP); }
87. ";"                     { count(); return(';'); }
88. ("{"|"<%")              { count(); return('{'); }
89. ("}"|"%>")              { count(); return('}'); }
90. ","                     { count(); return(','); }
91. ":"                     { count(); return(':'); }
92. "="                     { count(); return('='); }
93. "("                     { count(); return('('); }
94. ")"                     { count(); return(')'); }
95. ("["|"<:")              { count(); return('['); }
96. ("]"|":>")              { count(); return(']'); }
97. "."                     { count(); return('.'); }
98. "&"                     { count(); return('&'); }
99. "!"                     { count(); return('!'); }
100. "~"                     { count(); return('~'); }
101. "-"                     { count(); return('-'); }
102. "+"                     { count(); return('+'); }
103. "*"                     { count(); return('*'); }
104. "/"                     { count(); return('/'); }
105. "%"                     { count(); return('%'); }
106. "<"                     { count(); return('<'); }
107. ">"                     { count(); return('>'); }
108. "^"                     { count(); return('^'); }
109. "|"                     { count(); return('|'); }
110. "?"                     { count(); return('?'); }
112. [ \t\v\n\f]             { count(); }
113. .                       { /* ignore bad characters */ }
115. %%
117. yywrap()
118. {
119.         return(1);
120. }
123. comment()
124. {
125.         char c, c1;
127. loop:
128.         while ((c = input()) != '*' && c != 0)
129.                 putchar(c);
131.         if ((c1 = input()) != '/' && c != 0)
132.         {
133.                 unput(c1);
134.                 goto loop;
135.         }
137.         if (c != 0)
138.                 putchar(c1);
139. }
142. int column = 0;
144. void count()
145. {
146.         int i;
148.         for (i = 0; yytext[i] != '\0'; i++)
149.         if (yytext[i] == '\n')
150.                 column = 0;
151.         else if (yytext[i] == '\t')
152.                 column += 8 - (column % 8);
153.         else
154.                 column++;
156.         ECHO;
157. }
160. int check_type()
161. {
162.         /*
163.          * pseudo code --- this is what it should check
164.          *
165.          *       if (yytext == type_name)
166.          *               return(TYPE_NAME);
167.          *
168.          *       return(IDENTIFIER);
169.          */
171.         /*
172.          *       it actually will only return IDENTIFIER
173.          */
175.         return(IDENTIFIER);
176. }

复制代码

Answer 1

--

这个好

没办法，只能支持。

还可以对照 K&R，看看是哪个标准，挺有意思的。

--

Answer 2

hehe,看了都不懂,这个要用什么编译器呀?
编译原理吗? 没有学过,来凑个热闹!

Answer 3

2. %token IDENTIFIER CONSTANT STRING_LITERAL SIZEOF
3. %token PTR_OP INC_OP DEC_OP LEFT_OP RIGHT_OP LE_OP GE_OP EQ_OP NE_OP
4. %token AND_OP OR_OP MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN ADD_ASSIGN
5. %token SUB_ASSIGN LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN
6. %token XOR_ASSIGN OR_ASSIGN TYPE_NAME
8. %token TYPEDEF EXTERN STATIC AUTO REGISTER
9. %token CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE CONST VOLATILE VOID
10. %token STRUCT UNION ENUM ELLIPSIS
12. %token CASE DEFAULT IF ELSE SWITCH WHILE DO FOR GOTO CONTINUE BREAK RETURN
14. %start translation_unit
15. %%
17. primary_expression
18.         : IDENTIFIER
19.         | CONSTANT
20.         | STRING_LITERAL
21.         | '(' expression ')'
22.         ;
24. postfix_expression
25.         : primary_expression
26.         | postfix_expression '[' expression ']'
27.         | postfix_expression '(' ')'
28.         | postfix_expression '(' argument_expression_list ')'
29.         | postfix_expression '.' IDENTIFIER
30.         | postfix_expression PTR_OP IDENTIFIER
31.         | postfix_expression INC_OP
32.         | postfix_expression DEC_OP
33.         ;
35. argument_expression_list
36.         : assignment_expression
37.         | argument_expression_list ',' assignment_expression
38.         ;
40. unary_expression
41.         : postfix_expression
42.         | INC_OP unary_expression
43.         | DEC_OP unary_expression
44.         | unary_operator cast_expression
45.         | SIZEOF unary_expression
46.         | SIZEOF '(' type_name ')'
47.         ;
49. unary_operator
50.         : '&'
51.         | '*'
52.         | '+'
53.         | '-'
54.         | '~'
55.         | '!'
56.         ;
58. cast_expression
59.         : unary_expression
60.         | '(' type_name ')' cast_expression
61.         ;
63. multiplicative_expression
64.         : cast_expression
65.         | multiplicative_expression '*' cast_expression
66.         | multiplicative_expression '/' cast_expression
67.         | multiplicative_expression '%' cast_expression
68.         ;
70. additive_expression
71.         : multiplicative_expression
72.         | additive_expression '+' multiplicative_expression
73.         | additive_expression '-' multiplicative_expression
74.         ;
76. shift_expression
77.         : additive_expression
78.         | shift_expression LEFT_OP additive_expression
79.         | shift_expression RIGHT_OP additive_expression
80.         ;
82. relational_expression
83.         : shift_expression
84.         | relational_expression '<' shift_expression
85.         | relational_expression '>' shift_expression
86.         | relational_expression LE_OP shift_expression
87.         | relational_expression GE_OP shift_expression
88.         ;
90. equality_expression
91.         : relational_expression
92.         | equality_expression EQ_OP relational_expression
93.         | equality_expression NE_OP relational_expression
94.         ;
96. and_expression
97.         : equality_expression
98.         | and_expression '&' equality_expression
99.         ;
101. exclusive_or_expression
102.         : and_expression
103.         | exclusive_or_expression '^' and_expression
104.         ;
106. inclusive_or_expression
107.         : exclusive_or_expression
108.         | inclusive_or_expression '|' exclusive_or_expression
109.         ;
111. logical_and_expression
112.         : inclusive_or_expression
113.         | logical_and_expression AND_OP inclusive_or_expression
114.         ;
116. logical_or_expression
117.         : logical_and_expression
118.         | logical_or_expression OR_OP logical_and_expression
119.         ;
121. conditional_expression
122.         : logical_or_expression
123.         | logical_or_expression '?' expression ':' conditional_expression
124.         ;
126. assignment_expression
127.         : conditional_expression
128.         | unary_expression assignment_operator assignment_expression
129.         ;
131. assignment_operator
132.         : '='
133.         | MUL_ASSIGN
134.         | DIV_ASSIGN
135.         | MOD_ASSIGN
136.         | ADD_ASSIGN
137.         | SUB_ASSIGN
138.         | LEFT_ASSIGN
139.         | RIGHT_ASSIGN
140.         | AND_ASSIGN
141.         | XOR_ASSIGN
142.         | OR_ASSIGN
143.         ;
145. expression
146.         : assignment_expression
147.         | expression ',' assignment_expression
148.         ;
150. constant_expression
151.         : conditional_expression
152.         ;
154. declaration
155.         : declaration_specifiers ';'
156.         | declaration_specifiers init_declarator_list ';'
157.         ;
159. declaration_specifiers
160.         : storage_class_specifier
161.         | storage_class_specifier declaration_specifiers
162.         | type_specifier
163.         | type_specifier declaration_specifiers
164.         | type_qualifier
165.         | type_qualifier declaration_specifiers
166.         ;
168. init_declarator_list
169.         : init_declarator
170.         | init_declarator_list ',' init_declarator
171.         ;
173. init_declarator
174.         : declarator
175.         | declarator '=' initializer
176.         ;

复制代码
--------------------------------我是无敌分界线------------------------------------

Answer 4

字数有限制，接上文

2. storage_class_specifier
3.         : TYPEDEF
4.         | EXTERN
5.         | STATIC
6.         | AUTO
7.         | REGISTER
8.         ;
10. type_specifier
11.         : VOID
12.         | CHAR
13.         | SHORT
14.         | INT
15.         | LONG
16.         | FLOAT
17.         | DOUBLE
18.         | SIGNED
19.         | UNSIGNED
20.         | struct_or_union_specifier
21.         | enum_specifier
22.         | TYPE_NAME
23.         ;
25. struct_or_union_specifier
26.         : struct_or_union IDENTIFIER '{' struct_declaration_list '}'
27.         | struct_or_union '{' struct_declaration_list '}'
28.         | struct_or_union IDENTIFIER
29.         ;
31. struct_or_union
32.         : STRUCT
33.         | UNION
34.         ;
36. struct_declaration_list
37.         : struct_declaration
38.         | struct_declaration_list struct_declaration
39.         ;
41. struct_declaration
42.         : specifier_qualifier_list struct_declarator_list ';'
43.         ;
45. specifier_qualifier_list
46.         : type_specifier specifier_qualifier_list
47.         | type_specifier
48.         | type_qualifier specifier_qualifier_list
49.         | type_qualifier
50.         ;
52. struct_declarator_list
53.         : struct_declarator
54.         | struct_declarator_list ',' struct_declarator
55.         ;
57. struct_declarator
58.         : declarator
59.         | ':' constant_expression
60.         | declarator ':' constant_expression
61.         ;
63. enum_specifier
64.         : ENUM '{' enumerator_list '}'
65.         | ENUM IDENTIFIER '{' enumerator_list '}'
66.         | ENUM IDENTIFIER
67.         ;
69. enumerator_list
70.         : enumerator
71.         | enumerator_list ',' enumerator
72.         ;
74. enumerator
75.         : IDENTIFIER
76.         | IDENTIFIER '=' constant_expression
77.         ;
79. type_qualifier
80.         : CONST
81.         | VOLATILE
82.         ;
84. declarator
85.         : pointer direct_declarator
86.         | direct_declarator
87.         ;
89. direct_declarator
90.         : IDENTIFIER
91.         | '(' declarator ')'
92.         | direct_declarator '[' constant_expression ']'
93.         | direct_declarator '[' ']'
94.         | direct_declarator '(' parameter_type_list ')'
95.         | direct_declarator '(' identifier_list ')'
96.         | direct_declarator '(' ')'
97.         ;
99. pointer
100.         : '*'
101.         | '*' type_qualifier_list
102.         | '*' pointer
103.         | '*' type_qualifier_list pointer
104.         ;
106. type_qualifier_list
107.         : type_qualifier
108.         | type_qualifier_list type_qualifier
109.         ;
112. parameter_type_list
113.         : parameter_list
114.         | parameter_list ',' ELLIPSIS
115.         ;
117. parameter_list
118.         : parameter_declaration
119.         | parameter_list ',' parameter_declaration
120.         ;
122. parameter_declaration
123.         : declaration_specifiers declarator
124.         | declaration_specifiers abstract_declarator
125.         | declaration_specifiers
126.         ;
128. identifier_list
129.         : IDENTIFIER
130.         | identifier_list ',' IDENTIFIER
131.         ;
133. type_name
134.         : specifier_qualifier_list
135.         | specifier_qualifier_list abstract_declarator
136.         ;
138. abstract_declarator
139.         : pointer
140.         | direct_abstract_declarator
141.         | pointer direct_abstract_declarator
142.         ;
144. direct_abstract_declarator
145.         : '(' abstract_declarator ')'
146.         | '[' ']'
147.         | '[' constant_expression ']'
148.         | direct_abstract_declarator '[' ']'
149.         | direct_abstract_declarator '[' constant_expression ']'
150.         | '(' ')'
151.         | '(' parameter_type_list ')'
152.         | direct_abstract_declarator '(' ')'
153.         | direct_abstract_declarator '(' parameter_type_list ')'
154.         ;
156. initializer
157.         : assignment_expression
158.         | '{' initializer_list '}'
159.         | '{' initializer_list ',' '}'
160.         ;
162. initializer_list
163.         : initializer
164.         | initializer_list ',' initializer
165.         ;
167. statement
168.         : labeled_statement
169.         | compound_statement
170.         | expression_statement
171.         | selection_statement
172.         | iteration_statement
173.         | jump_statement
174.         ;
176. labeled_statement
177.         : IDENTIFIER ':' statement
178.         | CASE constant_expression ':' statement
179.         | DEFAULT ':' statement
180.         ;
182. compound_statement
183.         : '{' '}'
184.         | '{' statement_list '}'
185.         | '{' declaration_list '}'
186.         | '{' declaration_list statement_list '}'
187.         ;
189. declaration_list
190.         : declaration
191.         | declaration_list declaration
192.         ;
194. statement_list
195.         : statement
196.         | statement_list statement
197.         ;
199. expression_statement
200.         : ';'
201.         | expression ';'
202.         ;
204. selection_statement
205.         : IF '(' expression ')' statement
206.         | IF '(' expression ')' statement ELSE statement
207.         | SWITCH '(' expression ')' statement
208.         ;
210. iteration_statement
211.         : WHILE '(' expression ')' statement
212.         | DO statement WHILE '(' expression ')' ';'
213.         | FOR '(' expression_statement expression_statement ')' statement
214.         | FOR '(' expression_statement expression_statement expression ')' statement
215.         ;
217. jump_statement
218.         : GOTO IDENTIFIER ';'
219.         | CONTINUE ';'
220.         | BREAK ';'
221.         | RETURN ';'
222.         | RETURN expression ';'
223.         ;
225. translation_unit
226.         : external_declaration
227.         | translation_unit external_declaration
228.         ;
230. external_declaration
231.         : function_definition
232.         | declaration
233.         ;
235. function_definition
236.         : declaration_specifiers declarator declaration_list compound_statement
237.         | declaration_specifiers declarator compound_statement
238.         | declarator declaration_list compound_statement
239.         | declarator compound_statement
240.         ;
242. %%
243. #include <stdio.h>
245. extern char yytext[];
246. extern int column;
248. yyerror(s)
249. char *s;
250. {
251.         fflush(stdout);
252.         printf("\n%*s\n%*s\n", column, "^", column, s);
253. }

复制代码

Answer 5

适合使用lex/yacc快速构建C语言相关的工具.

Answer 6

编译原理除了优化都不懂......

Answer 7

收藏先，编译都忘完了

Answer 8

原帖由 朱熹之 于 2007-1-24 15:00 发表于 5楼  
编译原理除了优化都不懂......

编译原理现在基本上只剩下优化了……
其他部分基本上都成熟了。
所以懂优化就是牛人了 :--)

Answer 9

收藏先