C语言面向对象编程之六：配置文件解析

  在实际项目中，经常会把软件的某些选项写入配置文件。 Windows 平台上的 INI 文件格式简单易用，本篇文章利用《C语言面向对象编程之五：单链表实现》中实现的单链表，设计了一个“类” ini_parser 来读写 INI 格式的配置文件。

    struct ini_parser 可以解析 INI 格式的字符串、文件，也可以将内存中的符合 INI 格式的数据写入文件，能够支持 Windows 、 Linux 、 Android 等多平台。目前暂不支持选项分组功能。

    功能相对简单，直接看源码吧。

    下面是头文件：

[cpp]  view plain  copy

1. struct single_list;  
2.   
3. struct ini_parser {  
4.     struct single_list * keyvalues;  
5.     int (*parse_file)(struct ini_parser *, const char * file);  
6.     int (*parse_string)(struct ini_parser *, const char *text);  
7.     char * (*value)(struct ini_parser *, const char * key);  
8.     void (*set_value)(struct ini_parser *, const char * key, const char * value);  
9.     void (*remove)(struct ini_parser *, const char *key);  
10.     int (*save_to_file)(struct ini_parser *, const char * file);  
11.     void (*deletor)(struct ini_parser *ini);  
12. };  
13.   
14. struct ini_parser * new_ini_parser();  

    struct init_parser 的声明符合我们在本系列文章中提到的面向对象框架，需要说明的是，一旦 deletor 方法被调用， ini_parser 的实例将不再允许访问。

    下面是源文件：

[cpp]  view plain  copy

1. #include "ini_parser.h"  
2. #include <stdio.h>  
3. #include <string.h>  
4.   
5. struct tag_value_pair{  
6.     struct slist_node node;  
7.     char * szTag;  
8.     char * szValue;  
9. };  
10. typedef struct tag_value_pair tag_value;  
11.   
12. static void _tag_value_free(struct slist_node *node)  
13. {  
14.     if(node) delete_tag_value_pair(node);  
15. }  
16.   
17. static int _tag_value_hittest(struct slist_node * node, void *key)  
18. {  
19.     return strcmp((char*)tag, ((struct tag_value_pair*)node)->szTag);  
20. }  
21.   
22. static struct single_list * new_tag_value_list()  
23. {  
24.     return new_single_list(_tag_value_free, _tag_value_hittest);  
25. }  
26.   
27. static struct tag_value_pair *new_tag_value_pair()  
28. {  
29.     struct tag_value_pair * pair = (struct tag_value_pair *)malloc(sizeof(struct tag_value_pair));  
30.     pair->node.next = 0;  
31.     pair->szTag = 0;  
32.     pair->szValue = 0;  
33.     return pair;  
34. }  
35.   
36. static struct tag_value_pair * make_tag_value_pair(char * tag, char * value)  
37. {  
38.     struct tag_value_pair *pair = 0;  
39.     if(!tag || !value)return 0;  
40.   
41.     pair = (struct tag_value_pair*)malloc(sizeof(struct tag_value_pair));  
42.     pair->szTag = strdup(tag);  
43.     pair->szValue = strdup(value);  
44.     pair->node.next = 0;  
45.     return pair;  
46. }  
47.   
48.   
49. static struct tag_value_pair * parse_line(char *line, int len)  
50. {  
51.     struct tag_value_pair * pair = 0;  
52.     int count = 0;  
53.     char * p = line;  
54.     char * end = 0;m  
55.     char * start = line;  
56.     if(!p) return 0;  
57.     while(*p == ' ') ++p;  
58.   
59.   
60.     /*blank line*/  
61.     if(p - line == len ||  
62.             *p == '\r' ||  
63.             *p == '\n' ||  
64.             *p == '\0') return 0;  
65.   
66.     /*do not support group*/  
67.     if(*p == '[') return 0;  
68.     /*comments*/  
69.     if(*p == '#') return 0;  
70.   
71.     /* extract key */  
72.     start = p;  
73.     end = line + len;  
74.     while(*p != '=' && p!= end) ++p;  
75.     if(p == end)  
76.     {  
77.         /* none '=' , invalid line */  
78.         return 0;  
79.     }  
80.     end = p - 1;  
81.     while(*end == ' ') --end; /* skip blank at the end */  
82.     count = end - start + 1;  
83.   
84.     pair = new_tag_value_pair();  
85.     pair->szTag = malloc(count + 1);  
86.     strncpy(pair->szTag, start, count);  
87.     pair->szTag[count] = 0;  
88.   
89.     /* extract value */  
90.     ++p;  
91.     end = line + len; /* next pos of the last char */  
92.     while( *p == ' ' && p != end) ++p;  
93.     if(p == end)  
94.     {  
95.         delete_tag_value_pair(pair);  
96.         return 0;  
97.     }  
98.     start = p;  
99.     --end; /* to the last char */  
100.     if(*end == '\n') { *end = 0; --end; }  
101.     if(*end == '\r') { *end = 0; --end; }  
102.     count = end - start + 1;  
103.     if(count > 0)  
104.     {  
105.         pair->szValue = malloc(count + 1);  
106.         strncpy(pair->szValue, start, count);  
107.         pair->szValue[count] = 0;  
108.     }  
109.   
110.     /* release empty key-value pair */  
111.     if(!pair->szValue)  
112.     {  
113.         delete_tag_value_pair(pair);  
114.         return 0;  
115.     }  
116.   
117.     return pair;  
118. }  
119.   
120. static int _parse_file(struct ini_parser * ini, const char *file){  
121.     FILE * fp = fopen(file, "r");  
122.     if(fp)  
123.     {  
124.         struct tag_value_pair * pair = 0;  
125.         char buf[1024] = {0};  
126.         while(fgets(buf, 1024, fp))  
127.         {  
128.             pair = parse_line(buf, strlen(buf));  
129.             if(pair)  
130.             {  
131.                 ini->keyvalues->add(ini->keyvalues, pair);  
132.             }  
133.         }  
134.         fclose(fp);  
135.         return ini->keyvalues->size;  
136.     }  
137.     return -1;  
138. }  
139.   
140. static int _parse_text(struct ini_parser * ini, const char * text){  
141.     char *p = text;  
142.     char * start = 0;  
143.     struct tag_value_pair * pair = 0;  
144.     if(!text) return -1;  
145.   
146.     while(1)  
147.     {  
148.         start = p;  
149.         while(*p != '\n' && *p != '\0' )++p;  
150.         if(*p == '\0') break;  
151.   
152.         pair = parse_line(start, p - start);  
153.         if(pair) ini->keyvalues->add(ini->keyvalues, pair);  
154.   
155.         ++p;  
156.     }  
157.   
158.     return ini->keyvalues->size;  
159. }  
160.   
161. static char * _value(struct ini_parser * ini, const char * key){  
162.     struct tag_value_pair * pair = NODE_T(ini->keyvalues->find_by_key(ini->keyvalues, key), struct tag_value_pair);  
163.     if(pair) return pair->szValue;  
164.     return 0;  
165. }  
166.   
167. static void _set_value(struct ini_parser * ini, const char * key, const char *value){  
168.     struct tag_value_pair * pair = NODE_T(ini->keyvalues->find_by_key(ini->keyvalues, key), struct tag_value_pair);  
169.     if(pair)  
170.     {  
171.         if(pair->szValue) free(pair->szValue);  
172.         pair->szValue = strdup(value);  
173.     }  
174.     else  
175.     {  
176.         ini->keyvalues->add(ini->keyvalues, make_tag_value_pair(key, value));  
177.     }  
178. }  
179.   
180. static void _remove(struct ini_parser * ini, const char * key){  
181.     struct tag_value_pair * pair = NODE_T(ini->keyvalues->find_by_key(ini->keyvalues, key), struct tag_value_pair);  
182.     if(pair)ini->keyvalues->remove(ini->keyvalues, pair);  
183. }  
184.   
185. static void write_keyvalue(struct tag_value_pair * pair, FILE *fp)  
186. {  
187.     fputs(pair->szTag, fp);  
188.     fputc('=', fp);  
189.     fputs(pair->szValue, fp);  
190.     fputc('\n', fp);  
191. }  
192.   
193. static int _save_to_file(struct ini_parser * ini, const char * file){  
194.     if(ini->keyvalues->size > 0)  
195.     {  
196.         FILE * fp = fopen(file, "w");  
197.         if(fp)  
198.         {  
199.             struct tag_value_pair * pair = NODE_T(ini->keyvalues->head,struct tag_value_pair);  
200.             while(pair != 0)  
201.             {  
202.                 write_keyvalue(pair, fp);  
203.                 pair = NODE_T(pair->node.next, struct tag_value_pair);  
204.             }  
205.   
206.             fclose(fp);  
207.             return 0;  
208.         }  
209.     }  
210.     return -1;  
211. }  
212.   
213. static void _delete_ini_parser(struct ini_parser *ini){  
214.     if(ini)  
215.     {  
216.         ini->keyvalues->deletor(ini->keyvalues);  
217.         free(ini);  
218.     }  
219. }  
220.   
221. struct ini_parser * new_ini_parser(){  
222.     struct ini_parser * ini = (struct ini_parser*)malloc(sizeof(struct ini_parser));  
223.     ini->keyvalues = new_tag_value_list();  
224.     ini->parse_file = _parse_file;  
225.     ini->parse_string = _parse_text;  
226.     ini->value = _value;  
227.     ini->set_value = _set_value;  
228.     ini->remove = _remove;  
229.     ini->save_to_file = _save_to_file;  
230.     ini->deletor = _delete_ini_parser;  
231.     return ini;  
232. }  

    下面是简单的测试代码：

[cpp]  view plain  copy

1. static char * g_szIniString = "#abc\nfirst=2\nsecond\nname=charli  zhang \n";  
2.   
3. static void ini_parser_test_string()  
4. {  
5.     struct ini_parser * ini = new_ini_parser();  
6.     int size = ini->parse_string(ini, g_szIniString);  
7.   
8.     assert( size > 0);  
9.     assert( ini->value(ini, "second") == 0 );  
10.     assert( ini->value(ini, "abc") == 0);  
11.     assert( ini->value(ini, "name") != NULL );  
12.     assert( ini->value(ini, "first") != NULL);  
13.   
14.     printf("ini string: %s\n", g_szIniString);  
15.     printf("key-value pairs count = %d\n", size);  
16.     printf("key \'name\'', value = %s\n", ini->value(ini, "name"));  
17.     printf("key \'first\'', value = %s\n", ini->value(ini, "first"));  
18.   
19.     ini->set_value(ini, "baidu", "hahaha");  
20.     ini->save_to_file(ini, "write.conf");  
21.   
22.     ini->remove(ini, "first");  
23.     ini->save_to_file(ini, "write2.conf");  
24.   
25.     ini->deletor(ini);  
26. }  
27.   
28. static void ini_parser_test_file()  
29. {  
30.     struct ini_parser * ini = new_ini_parser();  
31.     int size = ini->parse_file(ini, "test.conf");  
32.   
33.     assert( size > 0);  
34.     assert( ini->value(ini, "second") == 0 );  
35.     assert( ini->value(ini, "abc") == 0);  
36.     assert( ini->value(ini, "name") != NULL );  
37.     assert( ini->value(ini, "first") != NULL);  
38.   
39.     printf("ini string: %s\n", g_szIniString);  
40.     printf("key-value pairs count = %d\n", size);  
41.     printf("key \'name\'', value = %s\n", ini->value(ini, "name"));  
42.     printf("key \'first\'', value = %s\n", ini->value(ini, "first"));  
43.     printf("key \'baidu\'', value = %s\n", ini->value(ini, "baidu"));  
44.   
45.     ini->deletor(ini);  
46. }  
47.   
48. void ini_parser_test()  
49. {  
50.     ini_parser_test_string();  
51.     ini_parser_test_file();  
52. }  

    struct ini_parser 已经运用在实际的项目中，目前为止没发现什么问题。