ANSI C grammar 最新的 Lex 和 Yacc 描述

soloforce

http://www.quut.com/c/ANSI-C-grammar-l-1998.html
http://www.quut.com/c/ANSI-C-grammar-y-1998.html

可以说这是比较权威和准确的词法及语法描述了，是比较可贵的材料。
原文引述如下
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
ANSI C Yacc grammar

1. 
   
2. ANSI C Yacc grammar
   
3. In 1985, Jeff Lee published his Yacc grammar (which is accompanied by a matching Lex specification) for the April 30, 1985 draft version of the ANSI C standard.  Tom Stockfisch reposted it to net.sources in 1987; that original, as mentioned in the answer to question 17.25 of the comp.lang.c FAQ, can be ftp'ed from ftp.uu.net, file usenet/net.sources/ansi.c.grammar.Z.
   
4. 
   
5. The version you see here has been updated based on an 1998 draft of the standards document. It allows for restricted pointers, variable arrays, "inline", and designated initializers. The previous version's lex and yacc files (ANSI C as of ca 1995) are still around as archived copies.
   
6. 
   
7. I intend to keep this version as close to the current C Standard grammar as possible; please let me know if you discover discrepancies.
   
8. (If you feel like it, read the FAQ first.)
   
9. 
   
10. Jutta Degener, April 2005
    
11. 
    
12. %token IDENTIFIER CONSTANT STRING_LITERAL SIZEOF
    
13. %token PTR_OP INC_OP DEC_OP LEFT_OP RIGHT_OP LE_OP GE_OP EQ_OP NE_OP
    
14. %token AND_OP OR_OP MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN ADD_ASSIGN
    
15. %token SUB_ASSIGN LEFT_ASSIGN RIGHT_ASSIGN AND_ASSIGN
    
16. %token XOR_ASSIGN OR_ASSIGN TYPE_NAME
    
17. 
    
18. %token TYPEDEF EXTERN STATIC AUTO REGISTER
    
19. %token CHAR SHORT INT LONG SIGNED UNSIGNED FLOAT DOUBLE CONST VOLATILE VOID
    
20. %token STRUCT UNION ENUM ELLIPSIS
    
21. 
    
22. %token CASE DEFAULT IF ELSE SWITCH WHILE DO FOR GOTO CONTINUE BREAK RETURN
    
23. 
    
24. %start translation_unit
    
25. %%
    
26. 
    
27. primary_expression
    
28.         : IDENTIFIER
    
29.         | CONSTANT
    
30.         | STRING_LITERAL
    
31.         | '(' expression ')'
    
32.         ;
    
33. 
    
34. postfix_expression
    
35.         : primary_expression
    
36.         | postfix_expression '[' expression ']'
    
37.         | postfix_expression '(' ')'
    
38.         | postfix_expression '(' argument_expression_list ')'
    
39.         | postfix_expression '.' IDENTIFIER
    
40.         | postfix_expression PTR_OP IDENTIFIER
    
41.         | postfix_expression INC_OP
    
42.         | postfix_expression DEC_OP
    
43.         | '(' type_name ')' '{' initializer_list '}'
    
44.         | '(' type_name ')' '{' initializer_list ',' '}'
    
45.         ;
    
46. 
    
47. argument_expression_list
    
48.         : assignment_expression
    
49.         | argument_expression_list ',' assignment_expression
    
50.         ;
    
51. 
    
52. unary_expression
    
53.         : postfix_expression
    
54.         | INC_OP unary_expression
    
55.         | DEC_OP unary_expression
    
56.         | unary_operator cast_expression
    
57.         | SIZEOF unary_expression
    
58.         | SIZEOF '(' type_name ')'
    
59.         ;
    
60. 
    
61. unary_operator
    
62.         : '&'
    
63.         | '*'
    
64.         | '+'
    
65.         | '-'
    
66.         | '~'
    
67.         | '!'
    
68.         ;
    
69. 
    
70. cast_expression
    
71.         : unary_expression
    
72.         | '(' type_name ')' cast_expression
    
73.         ;
    
74. 
    
75. multiplicative_expression
    
76.         : cast_expression
    
77.         | multiplicative_expression '*' cast_expression
    
78.         | multiplicative_expression '/' cast_expression
    
79.         | multiplicative_expression '%' cast_expression
    
80.         ;
    
81. 
    
82. additive_expression
    
83.         : multiplicative_expression
    
84.         | additive_expression '+' multiplicative_expression
    
85.         | additive_expression '-' multiplicative_expression
    
86.         ;
    
87. 
    
88. shift_expression
    
89.         : additive_expression
    
90.         | shift_expression LEFT_OP additive_expression
    
91.         | shift_expression RIGHT_OP additive_expression
    
92.         ;
    
93. 
    
94. relational_expression
    
95.         : shift_expression
    
96.         | relational_expression '<' shift_expression
    
97.         | relational_expression '>' shift_expression
    
98.         | relational_expression LE_OP shift_expression
    
99.         | relational_expression GE_OP shift_expression
    
100.         ;
     
101. 
     
102. equality_expression
     
103.         : relational_expression
     
104.         | equality_expression EQ_OP relational_expression
     
105.         | equality_expression NE_OP relational_expression
     
106.         ;
     
107. 
     
108. and_expression
     
109.         : equality_expression
     
110.         | and_expression '&' equality_expression
     
111.         ;
     
112. 
     
113. exclusive_or_expression
     
114.         : and_expression
     
115.         | exclusive_or_expression '^' and_expression
     
116.         ;
     
117. 
     
118. inclusive_or_expression
     
119.         : exclusive_or_expression
     
120.         | inclusive_or_expression '|' exclusive_or_expression
     
121.         ;
     
122. 
     
123. logical_and_expression
     
124.         : inclusive_or_expression
     
125.         | logical_and_expression AND_OP inclusive_or_expression
     
126.         ;
     
127. 
     
128. logical_or_expression
     
129.         : logical_and_expression
     
130.         | logical_or_expression OR_OP logical_and_expression
     
131.         ;
     
132. 
     
133. conditional_expression
     
134.         : logical_or_expression
     
135.         | logical_or_expression '?' expression ':' conditional_expression
     
136.         ;
     
137. 
     
138. assignment_expression
     
139.         : conditional_expression
     
140.         | unary_expression assignment_operator assignment_expression
     
141.         ;
     
142. 
     
143. assignment_operator
     
144.         : '='
     
145.         | MUL_ASSIGN
     
146.         | DIV_ASSIGN
     
147.         | MOD_ASSIGN
     
148.         | ADD_ASSIGN
     
149.         | SUB_ASSIGN
     
150.         | LEFT_ASSIGN
     
151.         | RIGHT_ASSIGN
     
152.         | AND_ASSIGN
     
153.         | XOR_ASSIGN
     
154.         | OR_ASSIGN
     
155.         ;
     
156. 
     
157. expression
     
158.         : assignment_expression
     
159.         | expression ',' assignment_expression
     
160.         ;
     
161. 
     
162. constant_expression
     
163.         : conditional_expression
     
164.         ;
     
165. 
     
166. declaration
     
167.         : declaration_specifiers ';'
     
168.         | declaration_specifiers init_declarator_list ';'
     
169.         ;
     
170. 
     
171. declaration_specifiers
     
172.         : storage_class_specifier
     
173.         | storage_class_specifier declaration_specifiers
     
174.         | type_specifier
     
175.         | type_specifier declaration_specifiers
     
176.         | type_qualifier
     
177.         | type_qualifier declaration_specifiers
     
178.         | function_specifier
     
179.         | function_specifier declaration_specifiers
     
180.         ;
     
181. 
     
182. init_declarator_list
     
183.         : init_declarator
     
184.         | init_declarator_list ',' init_declarator
     
185.         ;
     
186. 
     
187. init_declarator
     
188.         : declarator
     
189.         | declarator '=' initializer
     
190.         ;
     
191. 
     
192. storage_class_specifier
     
193.         : TYPEDEF
     
194.         | EXTERN
     
195.         | STATIC
     
196.         | AUTO
     
197.         | REGISTER
     
198.         ;
     
199. 
     
200. type_specifier
     
201.         : VOID
     
202.         | CHAR
     
203.         | SHORT
     
204.         | INT
     
205.         | LONG
     
206.         | FLOAT
     
207.         | DOUBLE
     
208.         | SIGNED
     
209.         | UNSIGNED
     
210.         | BOOL
     
211.         | COMPLEX
     
212.         | IMAGINARY
     
213.         | struct_or_union_specifier
     
214.         | enum_specifier
     
215.         | TYPE_NAME
     
216.         ;
     
217. 
     
218. struct_or_union_specifier
     
219.         : struct_or_union IDENTIFIER '{' struct_declaration_list '}'
     
220.         | struct_or_union '{' struct_declaration_list '}'
     
221.         | struct_or_union IDENTIFIER
     
222.         ;
     
223. 
     
224. struct_or_union
     
225.         : STRUCT
     
226.         | UNION
     
227.         ;
     
228. 
     
229. struct_declaration_list
     
230.         : struct_declaration
     
231.         | struct_declaration_list struct_declaration
     
232.         ;
     
233. 
     
234. struct_declaration
     
235.         : specifier_qualifier_list struct_declarator_list ';'
     
236.         ;
     
237. 
     
238. specifier_qualifier_list
     
239.         : type_specifier specifier_qualifier_list
     
240.         | type_specifier
     
241.         | type_qualifier specifier_qualifier_list
     
242.         | type_qualifier
     
243.         ;
     
244. 
     
245. struct_declarator_list
     
246.         : struct_declarator
     
247.         | struct_declarator_list ',' struct_declarator
     
248.         ;
     
249. 
     
250. struct_declarator
     
251.         : declarator
     
252.         | ':' constant_expression
     
253.         | declarator ':' constant_expression
     
254.         ;
     
255. 
     
256. enum_specifier
     
257.         : ENUM '{' enumerator_list '}'
     
258.         | ENUM IDENTIFIER '{' enumerator_list '}'
     
259.         | ENUM '{' enumerator_list ',' '}'
     
260.         | ENUM IDENTIFIER '{' enumerator_list ',' '}'
     
261.         | ENUM IDENTIFIER
     
262.         ;
     
263. 
     
264. enumerator_list
     
265.         : enumerator
     
266.         | enumerator_list ',' enumerator
     
267.         ;
     
268. 
     
269. enumerator
     
270.         : IDENTIFIER
     
271.         | IDENTIFIER '=' constant_expression
     
272.         ;
     
273. 
     
274. type_qualifier
     
275.         : CONST
     
276.         | RESTRICT
     
277.         | VOLATILE
     
278.         ;
     
279. 
     
280. function_specifier
     
281.         : INLINE
     
282.         ;
     
283. 
     
284. declarator
     
285.         : pointer direct_declarator
     
286.         | direct_declarator
     
287.         ;
     
288. 
     
289. 
     
290. direct_declarator
     
291.         : IDENTIFIER
     
292.         | '(' declarator ')'
     
293.         | direct_declarator '[' type_qualifier_list assignment_expression ']'
     
294.         | direct_declarator '[' type_qualifier_list ']'
     
295.         | direct_declarator '[' assignment_expression ']'
     
296.         | direct_declarator '[' STATIC type_qualifier_list assignment_expression ']'
     
297.         | direct_declarator '[' type_qualifier_list STATIC assignment_expression ']'
     
298.         | direct_declarator '[' type_qualifier_list '*' ']'
     
299.         | direct_declarator '[' '*' ']'
     
300.         | direct_declarator '[' ']'
     
301.         | direct_declarator '(' parameter_type_list ')'
     
302.         | direct_declarator '(' identifier_list ')'
     
303.         | direct_declarator '(' ')'
     
304.         ;
     
305. 
     
306. pointer
     
307.         : '*'
     
308.         | '*' type_qualifier_list
     
309.         | '*' pointer
     
310.         | '*' type_qualifier_list pointer
     
311.         ;
     
312. 
     
313. type_qualifier_list
     
314.         : type_qualifier
     
315.         | type_qualifier_list type_qualifier
     
316.         ;
     
317. 
     
318. 
     
319. parameter_type_list
     
320.         : parameter_list
     
321.         | parameter_list ',' ELLIPSIS
     
322.         ;
     
323. 
     
324. parameter_list
     
325.         : parameter_declaration
     
326.         | parameter_list ',' parameter_declaration
     
327.         ;
     
328. 
     
329. parameter_declaration
     
330.         : declaration_specifiers declarator
     
331.         | declaration_specifiers abstract_declarator
     
332.         | declaration_specifiers
     
333.         ;
     
334. 
     
335. identifier_list
     
336.         : IDENTIFIER
     
337.         | identifier_list ',' IDENTIFIER
     
338.         ;
     
339. 
     
340. type_name
     
341.         : specifier_qualifier_list
     
342.         | specifier_qualifier_list abstract_declarator
     
343.         ;
     
344. 
     
345. abstract_declarator
     
346.         : pointer
     
347.         | direct_abstract_declarator
     
348.         | pointer direct_abstract_declarator
     
349.         ;
     
350. 
     
351. direct_abstract_declarator
     
352.         : '(' abstract_declarator ')'
     
353.         | '[' ']'
     
354.         | '[' assignment_expression ']'
     
355.         | direct_abstract_declarator '[' ']'
     
356.         | direct_abstract_declarator '[' assignment_expression ']'
     
357.         | '[' '*' ']'
     
358.         | direct_abstract_declarator '[' '*' ']'
     
359.         | '(' ')'
     
360.         | '(' parameter_type_list ')'
     
361.         | direct_abstract_declarator '(' ')'
     
362.         | direct_abstract_declarator '(' parameter_type_list ')'
     
363.         ;
     
364. 
     
365. initializer
     
366.         : assignment_expression
     
367.         | '{' initializer_list '}'
     
368.         | '{' initializer_list ',' '}'
     
369.         ;
     
370. 
     
371. initializer_list
     
372.         : initializer
     
373.         | designation initializer
     
374.         | initializer_list ',' initializer
     
375.         | initializer_list ',' designation initializer
     
376.         ;
     
377. 
     
378. designation
     
379.         : designator_list '='
     
380.         ;
     
381. 
     
382. designator_list
     
383.         : designator
     
384.         | designator_list designator
     
385.         ;
     
386. 
     
387. designator
     
388.         : '[' constant_expression ']'
     
389.         | '.' IDENTIFIER
     
390.         ;
     
391. 
     
392. statement
     
393.         : labeled_statement
     
394.         | compound_statement
     
395.         | expression_statement
     
396.         | selection_statement
     
397.         | iteration_statement
     
398.         | jump_statement
     
399.         ;
     
400. 
     
401. labeled_statement
     
402.         : IDENTIFIER ':' statement
     
403.         | CASE constant_expression ':' statement
     
404.         | DEFAULT ':' statement
     
405.         ;
     
406. 
     
407. compound_statement
     
408.         : '{' '}'
     
409.         | '{' block_item_list '}'
     
410.         ;
     
411. 
     
412. block_item_list
     
413.         : block_item
     
414.         | block_item_list block_item
     
415.         ;
     
416. 
     
417. block_item
     
418.         : declaration
     
419.         | statement
     
420.         ;
     
421. 
     
422. expression_statement
     
423.         : ';'
     
424.         | expression ';'
     
425.         ;
     
426. 
     
427. selection_statement
     
428.         : IF '(' expression ')' statement
     
429.         | IF '(' expression ')' statement ELSE statement
     
430.         | SWITCH '(' expression ')' statement
     
431.         ;
     
432. 
     
433. iteration_statement
     
434.         : WHILE '(' expression ')' statement
     
435.         | DO statement WHILE '(' expression ')' ';'
     
436.         | FOR '(' expression_statement expression_statement ')' statement
     
437.         | FOR '(' expression_statement expression_statement expression ')' statement
     
438.         | FOR '(' declaration expression_statement ')' statement
     
439.         | FOR '(' declaration expression_statement expression ')' statement
     
440.         ;
     
441. 
     
442. jump_statement
     
443.         : GOTO IDENTIFIER ';'
     
444.         | CONTINUE ';'
     
445.         | BREAK ';'
     
446.         | RETURN ';'
     
447.         | RETURN expression ';'
     
448.         ;
     
449. 
     
450. translation_unit
     
451.         : external_declaration
     
452.         | translation_unit external_declaration
     
453.         ;
     
454. 
     
455. external_declaration
     
456.         : function_definition
     
457.         | declaration
     
458.         ;
     
459. 
     
460. function_definition
     
461.         : declaration_specifiers declarator declaration_list compound_statement
     
462.         | declaration_specifiers declarator compound_statement
     
463.         ;
     
464. 
     
465. declaration_list
     
466.         : declaration
     
467.         | declaration_list declaration
     
468.         ;
     
469. 
     
470. 
     
471. %%
     
472. #include <stdio.h>
     
473. 
     
474. extern char yytext[];
     
475. extern int column;
     
476. 
     
477. yyerror(s)
     
478. char *s;
     
479. {
     
480.         fflush(stdout);
     
481.         printf("\n%*s\n%*s\n", column, "^", column, s);
     
482. }
     

复制代码

ANSI C grammar, Lex specification

1. 
   
2. ANSI C grammar, Lex specification
   
3. In 1985, Jeff Lee published this Lex specification together with a Yacc grammar for the April 30, 1985 ANSI C draft.  Tom Stockfisch reposted both to net.sources in 1987; that original, as mentioned in the answer to question 17.25 of the comp.lang.c FAQ, can be ftp'ed from ftp.uu.net, file usenet/net.sources/ansi.c.grammar.Z.
   
4. 
   
5. The version you see here has been updated based on an 1998 draft of the standards document. It allows for restricted pointers, variable arrays, "inline", and designated initializers. The previous version's lex and yacc files (ANSI C as of ca 1995) are still around as archived copies.
   
6. 
   
7. I intend to keep this version as close to the current C Standard grammar as possible; please let me know if you discover discrepancies.
   
8. 
   
9. Jutta Degener, 2004
   
10. 
    
11. D                        [0-9]
    
12. L                        [a-zA-Z_]
    
13. H                        [a-fA-F0-9]
    
14. E                        [Ee][+-]?{D}+
    
15. FS                        (f|F|l|L)
    
16. IS                        (u|U|l|L)*
    
17. 
    
18. %{
    
19. #include <stdio.h>
    
20. #include "y.tab.h"
    
21. 
    
22. void count();
    
23. %}
    
24. 
    
25. %%
    
26. "/*"                        { comment(); }
    
27. 
    
28. "auto"                        { count(); return(AUTO); }
    
29. "_Bool"                        { count(); return(BOOL); }
    
30. "break"                        { count(); return(BREAK); }
    
31. "case"                        { count(); return(CASE); }
    
32. "char"                        { count(); return(CHAR); }
    
33. "_Complex"                { count(); return(COMPLEX); }
    
34. "const"                        { count(); return(CONST); }
    
35. "continue"                { count(); return(CONTINUE); }
    
36. "default"                { count(); return(DEFAULT); }
    
37. "do"                        { count(); return(DO); }
    
38. "double"                { count(); return(DOUBLE); }
    
39. "else"                        { count(); return(ELSE); }
    
40. "enum"                        { count(); return(ENUM); }
    
41. "extern"                { count(); return(EXTERN); }
    
42. "float"                        { count(); return(FLOAT); }
    
43. "for"                        { count(); return(FOR); }
    
44. "goto"                        { count(); return(GOTO); }
    
45. "if"                        { count(); return(IF); }
    
46. "_Imaginary"                { count(); return(IMAGINARY); }
    
47. "inline"                { count(); return(INLINE); }
    
48. "int"                        { count(); return(INT); }
    
49. "long"                        { count(); return(LONG); }
    
50. "register"                { count(); return(REGISTER); }
    
51. "restrict"                { count(); return(RESTRICT); }
    
52. "return"                { count(); return(RETURN); }
    
53. "short"                        { count(); return(SHORT); }
    
54. "signed"                { count(); return(SIGNED); }
    
55. "sizeof"                { count(); return(SIZEOF); }
    
56. "static"                { count(); return(STATIC); }
    
57. "struct"                { count(); return(STRUCT); }
    
58. "switch"                { count(); return(SWITCH); }
    
59. "typedef"                { count(); return(TYPEDEF); }
    
60. "union"                        { count(); return(UNION); }
    
61. "unsigned"                { count(); return(UNSIGNED); }
    
62. "void"                        { count(); return(VOID); }
    
63. "volatile"                { count(); return(VOLATILE); }
    
64. "while"                        { count(); return(WHILE); }
    
65. 
    
66. {L}({L}|{D})*                { count(); return(check_type()); }
    
67. 
    
68. 0[xX]{H}+{IS}?                { count(); return(CONSTANT); }
    
69. 0{D}+{IS}?                { count(); return(CONSTANT); }
    
70. {D}+{IS}?                { count(); return(CONSTANT); }
    
71. L?'(\\.|[^\\'])+'        { count(); return(CONSTANT); }
    
72. 
    
73. {D}+{E}{FS}?                { count(); return(CONSTANT); }
    
74. {D}*"."{D}+({E})?{FS}?        { count(); return(CONSTANT); }
    
75. {D}+"."{D}*({E})?{FS}?        { count(); return(CONSTANT); }
    
76. 
    
77. L?"(\\.|[^\"])*"        { count(); return(STRING_LITERAL); }
    
78. 
    
79. "..."                        { count(); return(ELLIPSIS); }
    
80. ">>="                        { count(); return(RIGHT_ASSIGN); }
    
81. "<<="                        { count(); return(LEFT_ASSIGN); }
    
82. "+="                        { count(); return(ADD_ASSIGN); }
    
83. "-="                        { count(); return(SUB_ASSIGN); }
    
84. "*="                        { count(); return(MUL_ASSIGN); }
    
85. "/="                        { count(); return(DIV_ASSIGN); }
    
86. "%="                        { count(); return(MOD_ASSIGN); }
    
87. "&="                        { count(); return(AND_ASSIGN); }
    
88. "^="                        { count(); return(XOR_ASSIGN); }
    
89. "|="                        { count(); return(OR_ASSIGN); }
    
90. ">>"                        { count(); return(RIGHT_OP); }
    
91. "<<"                        { count(); return(LEFT_OP); }
    
92. "++"                        { count(); return(INC_OP); }
    
93. "--"                        { count(); return(DEC_OP); }
    
94. "->"                        { count(); return(PTR_OP); }
    
95. "&&"                        { count(); return(AND_OP); }
    
96. "||"                        { count(); return(OR_OP); }
    
97. "<="                        { count(); return(LE_OP); }
    
98. ">="                        { count(); return(GE_OP); }
    
99. "=="                        { count(); return(EQ_OP); }
    
100. "!="                        { count(); return(NE_OP); }
     
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(']'); }
     
111. "."                        { count(); return('.'); }
     
112. "&"                        { count(); return('&'); }
     
113. "!"                        { count(); return('!'); }
     
114. "~"                        { count(); return('~'); }
     
115. "-"                        { count(); return('-'); }
     
116. "+"                        { count(); return('+'); }
     
117. "*"                        { count(); return('*'); }
     
118. "/"                        { count(); return('/'); }
     
119. "%"                        { count(); return('%'); }
     
120. "<"                        { count(); return('<'); }
     
121. ">"                        { count(); return('>'); }
     
122. "^"                        { count(); return('^'); }
     
123. "|"                        { count(); return('|'); }
     
124. "?"                        { count(); return('?'); }
     
125. 
     
126. [ \t\v\n\f]                { count(); }
     
127. .                        { /* ignore bad characters */ }
     
128. 
     
129. %%
     
130. 
     
131. yywrap()
     
132. {
     
133.         return(1);
     
134. }
     
135. 
     
136. 
     
137. comment()
     
138. {
     
139.         char c, c1;
     
140. 
     
141. loop:
     
142.         while ((c = input()) != '*' && c != 0)
     
143.                 putchar(c);
     
144. 
     
145.         if ((c1 = input()) != '/' && c != 0)
     
146.         {
     
147.                 unput(c1);
     
148.                 goto loop;
     
149.         }
     
150. 
     
151.         if (c != 0)
     
152.                 putchar(c1);
     
153. }
     
154. 
     
155. 
     
156. int column = 0;
     
157. 
     
158. void count()
     
159. {
     
160.         int i;
     
161. 
     
162.         for (i = 0; yytext[i] != '\0'; i++)
     
163.                 if (yytext[i] == '\n')
     
164.                         column = 0;
     
165.                 else if (yytext[i] == '\t')
     
166.                         column += 8 - (column % 8);
     
167.                 else
     
168.                         column++;
     
169. 
     
170.         ECHO;
     
171. }
     
172. 
     
173. 
     
174. int check_type()
     
175. {
     
176. /*
     
177. * pseudo code --- this is what it should check
     
178. *
     
179. *        if (yytext == type_name)
     
180. *                return(TYPE_NAME);
     
181. *
     
182. *        return(IDENTIFIER);
     
183. */
     
184. 
     
185. /*
     
186. *        it actually will only return IDENTIFIER
     
187. */
     
188. 
     
189.         return(IDENTIFIER);
     
190. }
     
191. 
     

复制代码

Tetris

好东西，收藏。
不过我还不懂yacc，很不好意思的说：）

rickxbx

Post by Tetris
好东西，收藏。
不过我还不懂yacc，很不好意思的说：）

yacc 俺也不熟, lex 倒是熟点,用过

nait

我都不懂
汗

gamedragon

不错不错，收起来了。

iamxia

大侠们介绍一下Lex 和 Yacc 吧

rickxbx

http://www-128.ibm.com/developerworks/library/l-lex.html 这里有Ashish Bansal写的一个入门教程

Heefan

oh ,very cool
除了那个<lex和yacc>外,我在也没有看到这么cool的东西了!

ywchen2000

收藏            

chayedan

我要看看，呵呵