ini文件解析器

SoforthHe

今天做了一个简单的ini文件解析器，代码如下：

1. /**
   
2. * Copyright(C) 2011 soforth <justhechuang@163.com>
   
3. *
   
4. * a ini file parser
   
5. *                          
   
6. * This program/include file is free software; you can redistribute it and/or
   
7. * modify it under the terms of the GNU General Public License as published
   
8. * by the Free Software Foundation; either version 2 of the License, or
   
9. * (at your option) any later version.
   
10. *
    
11. * This program/include file is distributed in the hope that it will be
    
12. * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
    
13. * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    
14. * GNU General Public License for more details.
    
15. */
    
16. 
    
17. #include <stdlib.h>
    
18. #include <unistd.h>
    
19. #include <string.h>
    
20. #include <stdio.h>
    
21. #include <fcntl.h>
    
22. #include <sys/mman.h>
    
23. 
    
24. #include "list.h"
    
25. 
    
26. #define MAX_BUCK_NUM        256  /* should be more than 0xff */
    
27. #define MAX_NAME_SIZE       80
    
28. 
    
29. #if !defined(__GNUC__) || (__GNUC__ == 2 && __GNUC_MINOR__ < 96)           
    
30. #define __builtin_expect(x, expected_value) (x)                           
    
31. #endif
    
32. #define likely(x)       __builtin_expect((x),1)                           
    
33. #define unlikely(x)     __builtin_expect((x),0)
    
34. 
    
35. typedef struct _SECTION {
    
36.         list_head_t list;      /* section list */
    
37.         list_head_t key_list;  /* key list */
    
38.         char name[MAX_NAME_SIZE];
    
39. }SECTION, *PSECTION;
    
40. 
    
41. typedef struct _KEY_VALUE {
    
42.         list_head_t list;        /* key-value list */
    
43.         int intval;
    
44.         char key[MAX_NAME_SIZE];
    
45.         char value[BUFSIZ];
    
46. }KEY_VALUE, *PKEY_VALUE;
    
47. 
    
48. static list_head_t   section_list[MAX_BUCK_NUM] = { 0 };
    
49. #define INIT_SECTION_LIST() do{ int i;for( i = 0; i < MAX_BUCK_NUM; ++i ) INIT_LIST_HEAD(&section_list[i]);}while(0)
    
50. 
    
51. static const char sep[256] = { [' ']=1, ['.']=1, ['-']=1, ['_']=1 };
    
52. #define SEP(x,y) sep[*((unsigned char *)(x) + (y))]
    
53. 
    
54. 
    
55. static __inline unsigned AtBuckIndex(const char *section) {
    
56.         unsigned h = 0;
    
57.         while(*section) {
    
58.                 h = h * 11 + (*section<<4) + (*section>>4);
    
59.                 section++;
    
60.         }
    
61.         return h&0xff;
    
62. }
    
63. 
    
64. static __inline PSECTION AtSection(const char* section) {
    
65.         list_head_t *l;
    
66.         PSECTION sec;
    
67.         unsigned idx;
    
68.         if(unlikely(NULL==section)){
    
69.                 return NULL;
    
70.         }
    
71.         idx = AtBuckIndex(section);
    
72.         list_for_each(l, &section_list[idx]) {
    
73.                 sec = list_entry(l, SECTION, list);
    
74.                 if(sec && !strcasecmp(section, sec->name)) {
    
75.                         return sec;
    
76.                 }
    
77.         }
    
78.         return NULL;
    
79. }
    
80. 
    
81. static __inline PKEY_VALUE AtKeyValue(const PSECTION section, const char*key) {
    
82.         list_head_t *l;
    
83.         PKEY_VALUE kv;
    
84.         if(unlikely(NULL==section||NULL==key)){
    
85.                 return NULL;
    
86.         }
    
87.         list_for_each(l, &section->key_list) {
    
88.                 kv = list_entry(l, KEY_VALUE, list);
    
89.                 if(kv && !strcasecmp(key, kv->key) ) {
    
90.                         return kv;
    
91.                 }
    
92.         }
    
93.         return NULL;
    
94. }
    
95. 
    
96. int parser_delete_key(const char* section, const char*key ) {
    
97.         PSECTION sec;
    
98.         PKEY_VALUE kv;
    
99. 
    
100.         if(unlikely(NULL==section||NULL==key)){
     
101.                 return -1;
     
102.         }
     
103. 
     
104.         if((sec=AtSection(section))&&(kv=AtKeyValue(sec, key))) {
     
105.                 list_del(&kv->list);
     
106.                 free(kv);
     
107.                 return 0;
     
108.         }       
     
109. 
     
110.         return -1;
     
111. }
     
112. 
     
113. int parser_delete_section(const char* section) {
     
114.         list_head_t *l;
     
115.         list_head_t *tmp;
     
116.         PSECTION sec;
     
117.         PKEY_VALUE kv;
     
118. 
     
119.         if(unlikely(NULL==section)){
     
120.                 return -1;
     
121.         }
     
122. 
     
123.         if((sec=AtSection(section))) {
     
124.                 list_for_each_entry_safe_l(kv, tmp, &sec->key_list, list) {
     
125.                         list_del(&kv->list);
     
126.                         free(kv);
     
127.                 }
     
128.                 list_del(&sec->list);
     
129.                 free(sec);
     
130.                 return 0;
     
131.         }
     
132. 
     
133.         return -1;
     
134. }
     
135. 
     
136. char *parser_get_string(const char* section, const char* key) {
     
137.         PSECTION sec;
     
138.         PKEY_VALUE kv;
     
139. 
     
140.         if(unlikely(NULL==section||NULL==key)){
     
141.                 return NULL;
     
142.         }
     
143. 
     
144.         if((sec=AtSection(section)) &&(kv=AtKeyValue(sec, key))) {
     
145.                 return kv->value;
     
146.         }       
     
147. 
     
148.         return NULL;
     
149. }
     
150. 
     
151. int parser_set_string(const char* section, const char* key, const char* value) {
     
152.         PSECTION sec;
     
153.         PKEY_VALUE kv;
     
154.         unsigned idx;
     
155. 
     
156.         if(unlikely(NULL==section||NULL==key)){
     
157.                 return -1;
     
158.         }
     
159. 
     
160.         if((sec=AtSection(section))&&(kv=AtKeyValue(sec, key))) {
     
161.                 strncpy(kv->value, value, BUFSIZ);
     
162.                 kv->intval = -1;
     
163.                 return 0;
     
164.         }       
     
165.         if( sec ) {
     
166.                 kv = (PKEY_VALUE)malloc(sizeof(KEY_VALUE));
     
167.                 strncpy(kv->key, key, MAX_NAME_SIZE);
     
168.                 strncpy(kv->value, value, BUFSIZ);
     
169.                 kv->intval = -1;
     
170.                 list_add(&kv->list, &sec->key_list);
     
171.                 return 0;
     
172.         }else {
     
173.                 sec = (PSECTION)malloc(sizeof(SECTION));
     
174.                 idx = AtBuckIndex(section);
     
175.                 strncpy(sec->name, section, MAX_NAME_SIZE);
     
176.                 INIT_LIST_HEAD(&sec->key_list);
     
177.                 list_add(&sec->list, &section_list[idx]);
     
178. 
     
179.                 kv = (PKEY_VALUE)malloc(sizeof(KEY_VALUE));
     
180.                 strncpy(kv->key, key, MAX_NAME_SIZE);
     
181.                 strncpy(kv->value, value, BUFSIZ);
     
182.                 kv->intval = -1;
     
183.                 list_add(&kv->list, &sec->key_list);
     
184.                 return 0;       
     
185.         }
     
186. 
     
187.         return -1;
     
188. }
     
189. 
     
190. static int map_file(const char* filename, char** buf, int *len) {
     
191.         int fd;
     
192. 
     
193.         if(unlikely(NULL==filename)) {
     
194.                 return -1;
     
195.         }
     
196. 
     
197.         fd = open(filename, O_RDONLY);
     
198.         if(fd < 0) return -1;
     
199. 
     
200.         *len = lseek(fd, 0L, SEEK_END);
     
201.         lseek(fd, 0L, SEEK_SET);
     
202. 
     
203.         *buf = mmap(0, *len+1, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
     
204.         if(*buf == MAP_FAILED) {
     
205.                 close(fd);
     
206.                 return -1;
     
207.         }
     
208.         if(read(fd, *buf, *len)<0) {
     
209.                 close(fd);
     
210.                 return -1;
     
211.         }
     
212.         close(fd);
     
213. 
     
214.         return 0;
     
215. }
     
216. 
     
217. static int parser_init(const char* filename){
     
218.         static int inited = 0;
     
219.         char *buf;
     
220.         int len;
     
221.         char *p, *pn, *k, *v;
     
222.         char *section = "";
     
223. 
     
224.         if( map_file(filename, &buf, &len) < 0 ) {
     
225.                 return -1;
     
226.         }
     
227. 
     
228.         if( !inited  ) {
     
229.                 INIT_SECTION_LIST();
     
230.                 inited = 1;
     
231.         }
     
232. 
     
233.         buf[len] = '\0';
     
234.         p = buf;
     
235. 
     
236.         while(p < buf+len) {
     
237.                 pn = strchr(p, '\n');
     
238.                 if(pn) {
     
239.                         *pn++ = '\0';
     
240.                 }
     
241.                 p += strspn(p, " \t\r"); /* skip leading blanks */
     
242.                 if(*p == '[') {
     
243.                         char *q = strchr(++p, ']');
     
244.                         if(q) {
     
245.                                 while(SEP(q, -1)){ q--; }
     
246.                                 *q = '\0';
     
247.                                 while(SEP(p, 0)) { p++; }
     
248.                                 if(p[0] == '\0') {
     
249.                                         section = "";
     
250.                                 } else {
     
251.                                         section = p;
     
252.                                 }
     
253.                         }
     
254.                 } else if(*p && *p != '#' && *p != ';'){
     
255.                         k = p;
     
256.                         p += strcspn(p, " \t\r=");
     
257.                         v = p;                   /* v is end of key */
     
258.                         p += strspn(p, " \t\r"); /* skip blanks between key and = */
     
259.                         if(*p == '=') {
     
260.                                 while(*++p == '=') { ; }  
     
261.                         }
     
262.                         *v = '\0';
     
263.                         v = p + strspn(p, " \t\r");
     
264.                         p = pn ? pn - 2 : p+strlen(p)-1;
     
265.                         while(*p == ' '|| *p == '\t' || *p == '\r') {*p-- = '\0';}        /* strip trailling blanks */
     
266. 
     
267.                         if(k && v) {
     
268.                                 parser_set_string(section, k, v);
     
269.                         }
     
270.                 }
     
271.                 p = pn;
     
272.         }
     
273. 
     
274.         munmap(buf, len+1);
     
275. 
     
276.         return 0;
     
277. }
     
278. 
     
279. int parser_get_intval(const char *section, const char *key, int def){
     
280.         PKEY_VALUE kv;
     
281. 
     
282.         kv = AtKeyValue(AtSection(section), key);
     
283. 
     
284.         if(unlikely(NULL==kv)) {
     
285.                 return def;
     
286.         }
     
287. 
     
288.         if(kv->intval != -1) {
     
289.                 return kv->intval;
     
290.         }
     
291. 
     
292.         if(isdigit(kv->value[0])||(kv->value[0]=='-'&&isdigit(kv->value[1]))) {
     
293.                 kv->intval = atol(kv->value);
     
294.         }else if(!strcasecmp(kv->value, "On")){
     
295.                 kv->intval = 1;
     
296.         }else if(!strcasecmp(kv->value, "Off")){
     
297.                 kv->intval = 0;
     
298.         }else if(!strcasecmp(kv->value, "Yes")){
     
299.                 kv->intval = 1;
     
300.         }else if(!strcasecmp(kv->value, "No")){
     
301.                 kv->intval = 0;
     
302.         }else if(!strcasecmp(kv->value, "True")){
     
303.                 kv->intval = 1;
     
304.         }else if(!strcasecmp(kv->value, "False")){
     
305.                 kv->intval = 0;
     
306.         }else if(!strcasecmp(kv->value, "enable")){
     
307.                 kv->intval = 1;
     
308.         }else if(!strcasecmp(kv->value, "disable")){
     
309.                 kv->intval = 0;
     
310.         }else if(!strcasecmp(kv->value, "enabled")){
     
311.                 kv->intval = 1;
     
312.         }else if(!strcasecmp(kv->value, "disabled")){
     
313.                 kv->intval = 0;
     
314.         }else {
     
315.                 return def;
     
316.         }
     
317. 
     
318.         return kv->intval;
     
319. }
     
320. 
     
321. unsigned long parser_get_size(const char *section, const char *key, unsigned long def) {
     
322.         PKEY_VALUE kv;
     
323.         char *pp;
     
324.         unsigned long v;
     
325. 
     
326.         kv = AtKeyValue(AtSection(section), key);
     
327. 
     
328.         if(unlikely(NULL==kv)) {
     
329.                 return def;
     
330.         }
     
331. 
     
332.         if(!isdigit(kv->value[0])) {
     
333.                 return def;
     
334.         }
     
335. 
     
336.         v = strtoul(kv->value, &pp, 0);
     
337.         if(pp[0] == 'K' || pp[0] == 'k') {
     
338.                 v *= 1024;
     
339.         }else if(pp[0] == 'M' || pp[0] == 'm') {
     
340.                 v *= 1024*1024;
     
341.         }else if(pp[0] == 'G' || pp[0] == 'g') {
     
342.                 v *= 1024*1024*1024;
     
343.         }
     
344. 
     
345.         return v;
     
346. }
     
347. 
     
348. int parser_dump(char* filename) {
     
349.         list_head_t *ls,*lk;
     
350.         PSECTION sec;
     
351.         PKEY_VALUE kv;
     
352.         int i;
     
353. 
     
354.         FILE *fp;
     
355. 
     
356.         if(!(fp=fopen(filename, "w"))){
     
357.                 fprintf(stderr, "parser_dump: open %s error [%d]\n", filename, __LINE__);
     
358.                 return -1;
     
359.         }
     
360. 
     
361.         for( i = 0; i < MAX_BUCK_NUM; ++i) {
     
362.                 list_for_each(ls, &section_list[i]) {
     
363.                         sec = list_entry(ls, SECTION, list );
     
364.                         if(!sec) continue;
     
365.                         fprintf(fp, "[ %s ]\n", sec->name);
     
366.                         list_for_each(lk, &sec->key_list){
     
367.                                 if(!lk) continue;
     
368.                                 kv = list_entry(lk, KEY_VALUE, list);
     
369.                                 fprintf(fp, "%s=%s\n", kv->key, kv->value);
     
370.                         }
     
371.                 }
     
372.         }
     
373. 
     
374.         fclose(fp);
     
375. 
     
376.         return 0;
     
377. }
     
378. 
     
379. int main(int argc, char** argv) {
     
380.         if( argc < 2 ) {
     
381.                 printf("Usage: %s <config.ini>\n", argv[0]);
     
382.                 return -1;
     
383.         }
     
384.         parser_init(argv[1]);
     
385. 
     
386.         int ch;
     
387.         char secbuf[255];
     
388.         char keybuf[255];
     
389.         char valbuf[255];
     
390.         char filebuf[255];
     
391.         while((ch=getchar())!='q') {
     
392.                 switch(ch){
     
393.                         case 'g':
     
394.                                 printf("input section name: ");
     
395.                                 scanf("%s", secbuf);
     
396.                                 printf("input key name: ");
     
397.                                 scanf("%s", keybuf);
     
398.                                 printf("[VALUE: %s]\n", parser_get_string(secbuf, keybuf));                               
     
399.                                 printf("[VALUE: %d]\n", parser_get_intval(secbuf, keybuf, -1));       
     
400.                                 printf("[VALUE: %lu]\n", parser_get_size(secbuf, keybuf, -1));       
     
401.                                 break;
     
402.                         case 's':
     
403.                                 printf("input section name: ");
     
404.                                 scanf("%s", secbuf);
     
405.                                 printf("input key name: ");
     
406.                                 scanf("%s", keybuf);
     
407.                                 printf("input value: ");
     
408.                                 scanf("%s", valbuf);
     
409.                                 parser_set_string(secbuf, keybuf, valbuf);
     
410.                                 break;
     
411.                         case 'D':
     
412.                                 printf("input section name: ");
     
413.                                 scanf("%s", secbuf);
     
414.                                 printf("input key name: ");
     
415.                                 scanf("%s", keybuf);
     
416.                                 parser_delete_key(secbuf,keybuf);
     
417.                                 break;
     
418.                         case 'r':
     
419.                                 printf("input section name: ");
     
420.                                 scanf("%s", secbuf);
     
421.                                 parser_delete_section(secbuf);
     
422.                                 break;
     
423.                         case 'd':
     
424.                                 printf("input filename to dump: ");
     
425.                                 scanf("%s", filebuf);
     
426.                                 parser_dump(filebuf);
     
427.                                 break;                               
     
428.                 }
     
429.         }
     
430. 
     
431.         return 0;
     
432. }
     

复制代码

gtv

最近正好需要这个 拜读下楼主大作

evaspring

楼主能写个CSV 文件读取的类吗?

SoforthHe

楼主能写个CSV 文件读取的类吗?
evaspring 发表于 2011-11-25 23:24

    最近在完成一个项目'贴出来的是涉及到的部分'所以抱歉啦11

SoforthHe

最近正好需要这个 拜读下楼主大作
gtv 发表于 2011-11-25 20:09

三月廿七

SoforthHe 发表于 2011-11-26 08:24

楼主能不能写个 xml 解析器， ini 没什么用途

SoforthHe

楼主能不能写个 xml 解析器， ini 没什么用途
三月廿七 发表于 2011-11-26 08:25

    网上开源的一堆啊'对我来说实用就够了

tempname2

这东西要我做就用Python了。

mirnshi

解析key/value，用sscanf很好用.

mirnshi

楼主能不能写个 xml 解析器， ini 没什么用途
三月廿七 发表于 2011-11-26 08:25

   libxml不能满足要求吗？