[code review了]一个函数，看了眼，吓坏了。

sonicling

词法分析本来就很麻烦，所有要用lex/flex这些工具自动生成啊。

next_token功能没有写得好看的，不管是手写还是自动生成。

image_z

回复 11# sonicling


    嗯。

pix77

比比这个：

1. int        _get_tok(token_type        *t){
   
2.         int        n=0,next_char,l;
   
3.         int        dot=0,num=0;
   
4.         char        *s;
   
5.        
   
6.         t->blank=blank();
   
7.         if(blank_request){
   
8.                 blank_request=0;
   
9.         t->blank=1;
   
10. }
    
11.         t->line_no=n_line;
    
12.        
    
13.         if(cur_char==LEX_EOF){
    
14.                 t->type=LEX_EOF;
    
15.                 return t->type;
    
16.         }
    
17.         if(cur_char==LEX_EOS){
    
18.                 t->type=LEX_EOS;
    
19.                 return t->type;
    
20.         }
    
21.         if(cur_char=='#' && get_char==_get_char){
    
22.                 t->text[n++]=cur_char;
    
23.                 for(cur_char=get_char();cur_char!=LEX_EOF;){
    
24.                         if(cur_char=='\\'){
    
25.                                 next_char=get_char();
    
26.                         //if(n<BUFFER_SIZE-1)t->text[n++]=cur_char;
    
27.                                 for(;next_char==' ' ||next_char=='\t';next_char=get_char());
    
28.                                 while(next_char=='\r'||next_char=='\n')
    
29.                                         next_char=get_char();
    
30.                                 cur_char=next_char;
    
31.                                 for(;n>0 && (t->text[n-1]=='\t'||t->text[n-1]==' ');n--);
    
32.                                 if(n<BUFFER_SIZE-1)t->text[n++]='\n';
    
33.                         }else{
    
34.                                 if(cur_char=='\r' ||cur_char=='\n')
    
35.                                         break;
    
36.                                 if(cur_char=='\t')
    
37.                                         cur_char=' ';
    
38.                                 if(n<BUFFER_SIZE-1)t->text[n++]=cur_char;
    
39.                                 cur_char=get_char();
    
40.                         }
    
41.                 }
    
42.                 t->text[n++]=0;
    
43.                 t->type=LEX_PREPROCESS;
    
44.                 cur_char=get_char();
    
45.                 return        t->type;
    
46.         }
    
47.         if(cur_char=='/' && get_char==_get_char){
    
48.                 next_char=get_char();
    
49.                 if(next_char=='/'){
    
50.                         for(cur_char=get_char();cur_char!=LEX_EOF;cur_char=get_char()){
    
51.                                 if(n<BUFFER_SIZE-1)t->text[n++]=cur_char;
    
52.                                 if(cur_char=='\r' ||cur_char=='\n')
    
53.                                         break;
    
54.                         }
    
55.                         t->text[n++]=0;
    
56.                         t->type=LEX_COMMENT;
    
57.                         cur_char=get_char();
    
58.                 }else if(next_char=='*'){
    
59.                         cur_char=get_char();
    
60.                         next_char=get_char();
    
61.                         for(;next_char!=LEX_EOF;cur_char=next_char,next_char=get_char()){
    
62.                                 if(cur_char=='*' && next_char=='/'){
    
63.                                         next_char=get_char();
    
64.                                         break;
    
65.                                 }
    
66.                                 if(n<BUFFER_SIZE-1)t->text[n++]=cur_char;
    
67.                         }
    
68.                         t->text[n++]=0;
    
69.                         t->type=LEX_COMMENT;
    
70.                         cur_char=next_char;
    
71.                 }else{
    
72.                         t->type=t->text[n++]=cur_char;
    
73.                         t->text[n++]=0;
    
74.                         cur_char=next_char;
    
75.                 }
    
76.                 return        t->type;
    
77.         }
    
78.         if(cur_char=='_'||isalpha(cur_char)){
    
79.                 do{
    
80.                         if(n<BUFFER_SIZE-1)
    
81.                                 t->text[n++]=cur_char;
    
82.                         cur_char=get_char();
    
83.                 }while(cur_char=='_'||isalpha(cur_char)||isdigit(cur_char));
    
84.                 t->text[n++]=0;
    
85.                 t->type=LEX_NAME;
    
86.                 s=t->text;
    
87.                  if(!strcmp(t->text,"namespace")){
    
88.                         t->type  =LEX_NAMESPACE;
    
89.                         return 0;
    
90.                 }else if(!strcmp(t->text,"class")){
    
91.                         t->type  =LEX_CLASS;
    
92.                         return 0;
    
93.                 }else if( !strcmp(t->text,"union") ||!strcmp(t->text,"struct")){
    
94.                         t->type  =LEX_STRUCT;
    
95.                 }else if(!strcmp(t->text,"extern")){
    
96.                         blank();
    
97.                         if(cur_char=='\"'){
    
98.                                 do{
    
99.                                         t->text[n++]=get_char();
    
100.                                 }while(cur_char!='\"' && cur_char!= LEX_EOF );
     
101.                         t->type  =LEX_EXTERN_C;
     
102. //                        t->text[n++]=' ';
     
103.                         t->text[n++]=0;
     
104.                         }else{
     
105.                                 blank_request=1;
     
106.                         }
     
107.                 }
     
108.                 return        t->type;
     
109.         }
     
110.         if(cur_char=='.'||isdigit(cur_char)){
     
111.                         next_char=get_char();
     
112.                         if(cur_char=='0' && (next_char=='X' || next_char=='x')){
     
113.                                 t->text[n++]=cur_char;
     
114.                                 t->text[n++]=next_char;
     
115.                                 cur_char=get_char();
     
116.                                 while(is_hex(cur_char)){
     
117.                                         if(n<BUFFER_SIZE-1)        t->text[n++]=cur_char;
     
118.                                         cur_char=get_char();
     
119.                                 }
     
120.                                 t->text[n++]=0;
     
121.                                 t->val=t->uval=hex_atou(t->text);
     
122.                                 return        t->type=LEX_INT;
     
123.                                
     
124.                         }else{
     
125.                                 if(cur_char=='.')
     
126.                                         dot=1;
     
127.                                 else
     
128.                                         num=1;
     
129.                                 if(n<BUFFER_SIZE-1)        t->text[n++]=cur_char;
     
130.                                 cur_char=next_char;
     
131.                                 do{
     
132.                                         if(dot && cur_char=='.'){
     
133.                                                 strcpy(t->text,"error");
     
134.                                                 return        t->type=LEX_ERROR;
     
135.                                         }
     
136.                                         if(!(cur_char=='.'||isdigit(cur_char)))
     
137.                                                 break;
     
138.                                         if(cur_char=='.')
     
139.                                                 dot=1;
     
140.                                         else
     
141.                                                 num=1;
     
142.                                         t->text[n++]=cur_char;
     
143.                                         cur_char=get_char();
     
144.                                 }while(1);
     
145.                                 if((cur_char=='e'||cur_char=='E') && num){
     
146.                                         dot=1;
     
147.                                         if(n<BUFFER_SIZE-1)        t->text[n++]=cur_char;
     
148.                                         cur_char=get_char();
     
149.                                         if(cur_char=='+'||cur_char=='-'){
     
150.                                                 if(n<BUFFER_SIZE-1)        t->text[n++]=cur_char;
     
151.                                                 cur_char=get_char();
     
152.                                         }
     
153.                                         if(isdigit(cur_char)){
     
154.                                                 do{
     
155.                                                         if(n<BUFFER_SIZE-1)        t->text[n++]=cur_char;
     
156.                                                         cur_char=get_char();
     
157.                                                 }while(isdigit(cur_char))        ;
     
158.                                         }else{
     
159.                                                 strcpy(t->text,"error");
     
160.                                                 return        t->type=LEX_ERROR;
     
161.                                         }
     
162.                                 }
     
163.                                 if(dot){
     
164.                                         t->type=LEX_FLOAT;
     
165.                                         if(cur_char=='d' || cur_char=='D' || cur_char=='f' || cur_char=='F'){
     
166.                                                 if(n<BUFFER_SIZE-1)        t->text[n++]=cur_char;
     
167.                                                 cur_char=get_char();
     
168.                                         }
     
169.                                 }else{
     
170.                                         t->type=LEX_INT;
     
171.                                         if(cur_char=='L' || cur_char=='l'){
     
172.                                                 if(n<BUFFER_SIZE-1)        t->text[n++]=cur_char;
     
173.                                                 cur_char=get_char();
     
174.                                         }else        if(cur_char=='d' || cur_char=='D' || cur_char=='f' || cur_char=='F'){
     
175.                                                 t->type=LEX_FLOAT;
     
176.                                                 if(n<BUFFER_SIZE-1)        t->text[n++]=cur_char;
     
177.                                                 cur_char=get_char();
     
178.                                         }
     
179.                                 }
     
180.                         }
     
181.                         if(t->type==LEX_FLOAT){
     
182.                                 t->dval=atof(t->text);
     
183.                         }else{
     
184.                                 t->val=t->uval=atol(t->text);
     
185.                         }
     
186.                         t->text[n++]=0;
     
187.                         return        t->type;
     
188.         }
     
189.         if(cur_char=='"'){
     
190.                 cur_char=get_char();
     
191.                 for(;cur_char!='"' && cur_char!=EOF;){
     
192.                         if(cur_char=='\\'){
     
193.                                 if(n<BUFFER_SIZE-1)        t->text[n++]=cur_char;
     
194.                                 cur_char=get_char();
     
195.                         }
     
196.                        
     
197.                         if(cur_char=='\r' || cur_char=='\n')
     
198.                                 while(cur_char=='\r' || cur_char=='\n')
     
199.                                         cur_char=get_char();
     
200.                         else if(cur_char!=EOF){
     
201.                                 if(n<BUFFER_SIZE-1){
     
202.                                         t->text[n++]=cur_char;
     
203.                                         cur_char=get_char();
     
204.                                 }
     
205.                          }
     
206.                 }
     
207.                 t->text[n++]=0;
     
208.                 if(cur_char!='"'){
     
209.                         t->type=LEX_ERROR;
     
210.                         sprintf(t->text,"\" missing.");
     
211.                         cur_char=get_char();
     
212.                         return        t->type;
     
213.                 }
     
214.                 cur_char=get_char();
     
215.                 t->type=LEX_STRING;
     
216.                 return        t->type;
     
217.         }
     
218. 
     
219.         if(cur_char=='\''){
     
220.                 cur_char=get_char();
     
221.                 if(cur_char=='\\'){
     
222.                         t->text[n++]=cur_char;
     
223.                         cur_char=get_char();
     
224.                         t->text[n++]=cur_char;
     
225.                         cur_char=get_char();
     
226.                 }
     
227.                 while(cur_char!='\'' && cur_char!=LEX_EOF){
     
228.                         if(n<BUFFER_SIZE-1)t->text[n++]=cur_char;
     
229.                         cur_char=get_char();
     
230.                 }
     
231.                 if(cur_char!='\''){
     
232.                         strcpy(t->text,"missing        \'");
     
233.                         t->type=LEX_ERROR;
     
234.                 }
     
235.                 t->text[n++]=0;
     
236.                 cur_char=get_char();
     
237.                 t->type=LEX_QUOTE;
     
238.                
     
239.                 return        t->type;
     
240.         }else if(cur_char==':'){
     
241.                 next_char=get_char();
     
242.                 if(next_char==':'){
     
243.                         t->text[n++]=cur_char;
     
244.                         cur_char=next_char;
     
245.                         next_char=get_char();
     
246.                         t->type=LEX_DOUBLEKOLON;
     
247.                 }else{
     
248.                         t->type=cur_char;
     
249.                 }
     
250.                 t->text[n++]=cur_char;
     
251.                 t->text[n++]=0;
     
252.                 cur_char=next_char;
     
253.         }else{
     
254.                 t->text[n++]=cur_char;
     
255.                 t->text[n++]=0;
     
256.                 t->type=cur_char;
     
257.                 cur_char=get_char();
     
258.         }
     
259.         return        t->type;
     
260. }

复制代码

flw

这段代码写的还算好吧。
可读性不错。

linux_c_py_php

解析文本的用状态机大段代码很常见的。

captivated

这是 Android init 程序的代码。

叔叔认为：

写，得，很，好，很，清，晰。

Kevin_zqw

我赶脚写得还不错，至少我基本看懂了。。

虽然我不喜欢这种典型的C简洁风格

lttltgr

代码很好，虽然没有注释，但很容易看懂。