一趟解析处理http

winston

来自：http://topic.csdn.net/u/20111128/14/d701ae5b-b6a3-45ff-a199-d068d77ecb5d.html
问题：
[{"iconNo":"1","seq":"1","devStatus":"1","devdescribe":"asd"}]

[{"iconNo":"2","seq":"2","devStatus":"2","devdescribe":"asasdsasdas师大d"}]

解析出各个字段，得到key-value。

我看Lighttpd解析http那一块代码大约1000行，不过它里边包括了http协议的处理，这里特意为了模仿它，写了一个基本类似的函数。

说说我为什么要写这么长吧， 因为我假设用户的输入是任意风格的， 也就是会有很多地方敲一些空格或者TAB， 格式也比较乱， 这里我还没有处理折叠格式，写时候忘了搞了，无非就是特殊对待一下\n。  

http里的"\r\n" 对应这里的','。
另外，这里由于这里的key,value都被""包裹，我假定""内不允许存在空白字符，对于http，需要特殊判断key中间是否有空白字符。

这个办法靓点在哪里呢？ 就是一趟扫描，不需要回溯再去检查合法性，那么复杂的情况为何可以做到呢？ 就是用了state这个变量， 将解析过程划分成了不同的阶段， 0阶段是解析一行第一次进入的状态，以后都不会再进入了， 1是解析key,2是解析:并且过度到3阶段，3阶段是解析val,4阶段是解析,或者行结尾。 通过state，保证每一个case里我们完全把精力集中在一部分，简化了逻辑复杂性，希望大家有所体会。

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <string.h>
5. static const char* parse_test[] =
6. {
7.     "[{"iconNo":"1","seq":"1","devStatus":"1","devdescribe":"asd"}]",
8.     "[{"iconNo":"2","seq":"2","devStatus":"2","devdescribe":"asasdsasdas师大d"}]"
9. };
11. int parse_key_value(const char *line)
12. {
13.     // 主要检查以下不合法性：
14.     //1, key或者value没有被'"'包裹
15.     //2, ""内没有空白字符
16.     //3, key : value 形式不合法
18.     int key_start, dot, key_end, val_start, val_end;
19.     int line_len;
20.     int state = 0;    //0:初始化,1:解析key,2:解析',',3:解析val,4:解析',' or '\0'
21.                     //or }]序列
22.     int left_over = 0;
23.     char key[20], value[30];
25.     key_start = dot = key_end = val_start = val_end = -1;
26.     line_len = strlen(line);
27.    
28.     for (int i = 0; i <= line_len; /*<=line_len目的: 对','和'\0'同等对待*/)
29.     {
30.         switch (state)
31.         {
32.             case 0:
33.             {
34.                 switch (line[i])
35.                 {
36.                     case ' ':
37.                     case '\t':
38.                     {
39.                         ++i;
40.                     }break;
41.                     case '[':
42.                     {
43.                         // 多余的[
44.                         if (left_over != 0)
45.                         {
46.                             return -1;
47.                         }
49.                         if (line[i+1] != '{')
50.                         {
51.                             return -1;
52.                         }
54.                         left_over++; //左侧"[{"序列合法
55.                         i+=2;
56.                     }break;
57.                     case '{':    //不应该单独出现,此分支可以不写,被default处理
58.                     {
59.                         return -1;
60.                     }break;
61.                     case '"':
62.                     {
63.                         if (left_over == 0)
64.                         {
65.                             //还没遇到[{序列
66.                             return -1;
67.                         }
68.                         // key的左'"',记录key_start
69.                         key_start = ++ i;
70.                         ++ state; //进入解析key状态
71.                     }break;
72.                     default:
73.                     {   
74.                         // 非空白字符 or 非[{序列 or 非'"' or '\0'
75.                         return -1;
76.                     };
77.                 }
78.             }break;
79.             case 1:
80.             {
81.                 switch (line[i])
82.                 {
83.                     case ' ':
84.                     case '\t':
85.                     case '{':
86.                     case '[':
87.                     case ',':
88.                     case ':':
89.                     case '\0':
90.                     {
91.                         // key不应该包含非字母，这里只列举一些
92.                         return -1;
93.                     }break;
94.                     case '"':
95.                     {
96.                         //key结束,记录key_end
97.                         key_end = i-1;
99.                         if (key_end < key_start)    //key为空
100.                         {
101.                             return -1;
102.                         }
104.                         ++ i;
105.                         state ++; // 进入解析':'状态
106.                     }break;
107.                     default:
108.                     {
109.                         // 任意合法字母
110.                         ++ i;
111.                     }break;
112.                 }
113.             }break;
114.             case 2:
115.             {
116.                 switch (line[i])
117.                 {
118.                     case '\t':
119.                     case ' ':
120.                     {
121.                         // 空白字符掠过
122.                         ++ i;
123.                     }break;
124.                     case ':':
125.                     {
126.                         //找到':'
127.                         dot = i++;
128.                         state++;
130.                         //向后掠过所有的空白,检测"val的'"'
132.                         while (line[i] != '\0')
133.                         {
134.                             if (line[i] != ' ' && line[i] != '\t')
135.                             {
136.                                 if (line[i] != '"')
137.                                 {
138.                                     return -1;    //遇到非空白非"字符
139.                                 }
141.                                 val_start = ++ i;
142.                                 break;
143.                             }
144.                            
145.                             ++ i;
146.                         }
148.                         if (val_start == -1)
149.                         {
150.                             return -1;
151.                         }
152.                     }break;
153.                     default:
154.                     {
155.                         //非合法,出错
156.                         return -1;
157.                     }break;
158.                 }
159.             }break;
160.             case 3:    //开始解析value
161.             {
162.                 switch (line[i])
163.                 {
164.                     //val内不应该有非字母字符
165.                     case '\t':
166.                     case ' ':
167.                     case ',':
168.                     case '\0':
169.                     case '[':
170.                     case '}':
171.                     case ']':
172.                     case '{':
173.                     {
174.                         return -1;
175.                     }break;
176.                     case '"':
177.                     {
178.                         val_end = i - 1;
179.                         
180.                         if (val_end < val_start)
181.                         {
182.                             return -1;
183.                         }
185.                         ++ i;
186.                         state++;
187.                     }break;
188.                     default:
189.                     {
190.                         ++ i;    //正常字母
191.                     }break;
192.                 }
193.             }break;
194.             case 4:    //最后阶段:如果是line末尾需要检测}]
195.                     //不是line末尾需要检测',',并且重新进入state = 1
196.             {
197.                 // 直接快速的处理过去
199.                 while (line[i] == ' ' || line[i] == '\t')
200.                 {
201.                     ++ i;
202.                 }
204.                 if (line[i] == '\0')
205.                 {
206.                     return -1; // line末尾，却没有}]
207.                 }
209.                 if (line[i] == ',')
210.                 {
211.                     // 一个字段结束,打印key,value
212.                     strncpy(key, line + key_start, key_end - key_start + 1);
213.                     key[key_end - key_start + 1] = '\0';
214.                     strncpy(value, line + val_start, val_end - val_start + 1);
215.                     value[val_end - val_start + 1] = '\0';
216.                     printf("%s:%s\n", key, value);
217.                     key_start = key_end = val_start = val_end = -1;
218.                     
219.                     // 向后找到value的"
220.                     while (line[++i] != '\0' && (line[i] == ' ' || line[i] == '\t'));
221.                     
222.                     if (line[i] != '"')
223.                     {
224.                         return -1;     // , 之后非"，错误
225.                     }
227.                     key_start = ++ i;
228.                     state = 1;    //直接进入解析value状态
229.                 }
230.                 else if (line[i] == '}')
231.                 {
232.                     if (line[i+1] != ']')
233.                     {
234.                         return -1;    //}]不完整
235.                     }
236.                     
237.                     strncpy(key, line + key_start, key_end - key_start + 1);
238.                     key[key_end - key_start + 1] = '\0';
239.                     strncpy(value, line + val_start, val_end - val_start + 1);
240.                     value[val_end - val_start + 1] = '\0';
241.                     printf("%s:%s\n", key, value);
243.                     return 0;    //解析完毕,}]之后再有字符也不理会了
244.                 }
245.                 else
246.                 {
247.                     // 意外的字符
248.                     return -1;
249.                 }
250.             }break;
251.             default:
252.             {
253.                 fprintf(stderr, "unknown state %d \n", state);
254.                 return -1;
255.             }break;
256.         }
257.     }
258. }
260. int main()
261. {
262.     char test_buffer[1000];
264.     while (scanf("%s", test_buffer) == 1)
265.     {
266.         parse_key_value(test_buffer);
267.     }
269.     for (int i = 0; i < 2; ++ i)
270.     {
271.         parse_key_value(parse_test[i]);
272.     }
273.     return 0;
274. }
276. owenliang@linux-7lsl:~/csdn/src> ./main
277. iconNo:1
278. seq:1
279. devStatus:1
280. devdescribe:asd
281. iconNo:2
282. seq:2
283. devStatus:2
284. devdescribe:asasdsasdas师大d

复制代码