C语言ini格式配置文件的读写

 1 /*1 utils.h
 2  *# A variety of utility functions.
 3  *# 
 4  *# Some of the functions are duplicates of well known C functions that are not 
 5  *# standard.
 6  *2 License
 7  *[
 8  *# Author: Werner Stoop
 9  *# This software is provided under the terms of the unlicense.
10  *# See http://unlicense.org/ for more details.
11  *]
12  *2 API
13  */
14 #include "stdafx.h"
15 /*@ MY_MIN(a,b)
16  *# Macro that returns the smallest of its parameters.\n
17  *# As with all macros, {{a}} and {{b}} should not have side effects.
18  */
19 #define MY_MIN(a,b) (((a)<(b))?(a):(b))
20  
21 /*@ MY_MAX(a,b)
22  *# Macro that returns the largest of its parameters.\n
23  *# As with all macros, {{a}} and {{b}} should not have side effects.
24  */
25 #define MY_MAX(a,b) (((a)>(b))?(a):(b))
26 
27 /*@ int my_stricmp(const char *p, const char *q)
28  *# Compares two strings {{p}} and {{q}} case insensitively.
29  *#
30  *# It returns 0 if the strings are the same, a positive number if {{p}} comes after {{q}},
31  *# and negative if {{p}} comes before {{q}}.
32  */
33 int my_stricmp(const char *p, const char *q);
34 
35 /*@ char *my_strdup(const char *s)
36  *# Creates a duplicate of a string {{s}} in a dynamic memory buffer.\n
37  *# The returned buffer needs to be {{free()}}d after use. It may return
38  *# {{NULL}} if the memory allocation fails.
39  */
40 char *my_strdup(const char *s);
41 
42 /*@ char *my_strlower (char *p)
43  *# Converts a string {{p}} to lowercase in place.
44  *# It returns {{p}}.
45  */
46 char *my_strlower (char *p);
47 
48 /*@ char *my_strupper (char *p)
49  *# Converts a string {{p}} to uppercase in place.
50  *# It returns {{p}}.
51  */
52 char *my_strupper (char *p);
53 
54 /*@ char *my_strtok_r(char *str, const char *delim, char **saveptr)
55  *# Works the same as {{strtok_r(3)}} for platforms which lack it.
56  */
57 char *my_strtok_r(char *str, const char *delim, char **saveptr);
58 
59 /*@ char *my_readfile (const char *fn)
60  *# Reads an entire file identified by {{fn}} into a dynamically allocated memory buffer.\n
61  *# The returned buffer needs to be {{free()}}d afterwards.\n
62  *# It returns {{NULL}} if the file could not be read.
63  */
64 char *my_readfile (const char *fn);

 1 /*
 2  * A variety of utility functions.
 3  *
 4  * See utils.h for more info
 5  *
 6  * This is free and unencumbered software released into the public domain.
 7  * http://unlicense.org/
 8  */
 9 #include "stdafx.h"
10 #include <stdlib.h>
11 #include <string.h>
12 #include <stdio.h>
13 #include <ctype.h>
14 
15 /* Case insensitive strcmp()
16  */ 
17 int my_stricmp(const char *p, const char *q) { 
18     for(;*p && tolower(*p) == tolower(*q); p++, q++);
19     return tolower(*p) - tolower(*q);
20 } 
21 
22 /* strdup() is not ANSI C */
23 char *my_strdup(const char *s) {
24     char *a;
25     size_t len = strlen(s);
26     a = (char*)malloc(len + 1);
27     if(!a) return NULL;
28     memcpy(a, s, len + 1);    
29     return a;
30 }
31 
32 /* converts a string to lowercase */
33 char *my_strlower (char *p) {
34   char *s;
35   for (s = p; s[0]; s++)
36     s[0] = tolower (s[0]);
37 
38   return p;
39 }
40 
41 /* converts a string to lowercase */
42 char *my_strupper (char *p)
43 {
44   char *s;
45   for (s = p; s[0]; s++)
46     s[0] = toupper (s[0]);
47 
48   return p;
49 }
50 
51 char *my_strtok_r(char *str, const char *delim, char **saveptr) {
52     if(!str)
53         str = *saveptr;
54     if(!str[0]) {
55         *saveptr = str;
56         return NULL;    
57     }
58     char *s = strpbrk(str, delim);
59     if(s) {
60         s[0] = ‘\0‘;
61         *saveptr = s + 1;
62     } else 
63         for(*saveptr = str; (*saveptr)[0]; (*saveptr)++);
64     return str;
65 }
66 
67 /* Reads an entire file into a dynamically allocated memory buffer.
68  * The returned buffer needs to be free()d afterwards
69  */
70 char *my_readfile(const char *fname) {
71     FILE *f;
72     long len,r;
73     char *str;
74     
75     if(!(f = fopen(fname, "rb")))    
76         return NULL;
77     
78     fseek(f, 0, SEEK_END);
79     len = ftell(f);
80     rewind(f);
81     
82     if(!(str = (char*)malloc(len+2)))
83         return NULL;    
84     r = fread(str, 1, len, f);
85     
86     if(r != len) {
87         free(str);
88         return NULL;
89     }
90     
91     fclose(f);    
92     str[len] = ‘\0‘;
93     return str;
94 }

  1 /*1 ini.h
  2  *#    Header file for the {*INI*} parser.\n
  3  *# 
  4  *#    This is a simple parser for {*.INI*} files. 
  5  *#    It is based around the syntax described in the Wikipedia entry at
  6  *#    {_http://en.wikipedia.org/wiki/INI_file_}\n 
  7  *#
  8  *# The API has these features:
  9  *{
 10  ** Use {{~~ini_read()}} to read an INI file from the disc into an {{~~ini_file}} 
 11  *#   structure or create an empty {{~~ini_file}} structure.
 12  ** Use {{~~ini_get()}} to retrieve values from the {{~~ini_file}} structure.
 13  ** Use {{~~ini_put()}} and {{~~ini_putf()}} to set values in the {{~~ini_file}} structure.
 14  ** Use {{~~ini_write()}} to write the contents of the {{~~ini_file}} structure back to disc.
 15  ** Use {{~~ini_free()}} to deallocate the {{~~ini_file}} structure. 
 16  ** {{~~ini_errstr()}} is used for reporting errors.
 17  *}
 18  *2 License
 19  *[
 20  *# Author: Werner Stoop
 21  *# This software is provided under the terms of the unlicense.
 22  *# See http://unlicense.org/ for more details.
 23  *]
 24  *2 API
 25  */
 26 #ifndef INI_H
 27 #define INI_H
 28 
 29 #if defined(__cplusplus)
 30 extern "C" {
 31 #endif
 32 
 33 /*
 34  *    Encapsulates a parameter-value pair in an INI section.
 35  *    Parameters are stored in a binary search tree, which attempts (but does not
 36  *    guarantee) O(log(n)) behaviour.
 37  */
 38 typedef struct INI_PAIR
 39 {
 40     char *param;        /* The parameter */
 41     char *value;        /* Its value */
 42     
 43     /* Nodes in the tree */
 44     struct INI_PAIR *left, *right;        
 45 } ini_pair;
 46 
 47 /*
 48  *    Encapsulates a section within a INI file.
 49  *    Sections are stored in a binary search tree, which attempts (but does not
 50  *    guarantee) O(log(n)) behaviour.
 51  */
 52 typedef struct INI_SECTION
 53 {
 54     char *name;            /* Name of the section */
 55     ini_pair *fields;    /* Fields in the section */
 56     
 57     /* Nodes in the tree */
 58     struct INI_SECTION *left, *right;
 59 } ini_section;
 60 
 61 /*@ struct ##ini_file;
 62  *#    Structure to encapsulate an INI file.
 63  */
 64 struct ini_file
 65 {
 66     ini_pair     *globals;
 67     ini_section *sections;
 68 };
 69 
 70 /*@ ini_file *##ini_read(const char *filename, int *err, int *line);
 71  *#    Reads an INI file named by {{filename}} and returns it as a {{~~ini_file}} object.
 72  *#    If {{filename}} is {{NULL}}, an empty {{ini_file}} object is created and returned.
 73  *#    Comments are discarded, so a later call to {{~~ini_write()}} will be
 74  *#    commentless.\n
 75  *# It returns {{NULL}} if the INI file couldn‘t be read, in which case {{err}} will contain the error code
 76  *# (see {{~~ini_errstr()}}) and {{line}} will contain the line in the file where the error occured.
 77  *# ({{err}} and {{line}} may be {{NULL}}).
 78  */
 79 struct ini_file *ini_read(const char *filename, int *err, int *line);
 80 
 81 /*@ ini_file *##ini_parse(const char *text, int *err, int *line);
 82  *# Parses a null-terminated string {{text}} as an INI file.\n
 83  *# It returns {{NULL}} if the INI file couldn‘t be read, in which case {{err}} will contain the error code
 84  *# (see {{~~ini_errstr()}}) and {{line}} will contain the line in the file where the error occured.
 85  *# ({{err}} and {{line}} may be {{NULL}}).
 86  */
 87 struct ini_file *ini_parse(const char *text, int *err, int *line);
 88 
 89 /*@ int ##ini_write(ini_file *ini, const char *fname);
 90  *#    Saves all the sections and parameters in an {{ini_file}} to a file.\n
 91  *#    {{fname}} is the file to which to save. If {{fname}} is {{NULL}}, it is written to 
 92  *#    {{stdout}}.
 93  *# It returns 1 on success, an error code otherwise (see {{~~ini_errstr()}}).
 94  */
 95 int ini_write(struct ini_file *ini, const char *fname);
 96 
 97 /*@ void ##ini_free(ini_file *ini);
 98  *#    Free‘s all the memory allocated to a {{ini_file}} object created in {{~~ini_read()}}.\n
 99  *#    {{ini}} is the {{ini_file}} to free
100  */
101 void ini_free(struct ini_file *ini);
102 
103 /*@ int ini_has_section(struct ini_file *ini, const char *sec)
104  *# Returns true if the ini file has a specific section.
105  */
106 int ini_has_section(struct ini_file *ini, const char *sec);
107 
108 /*@ const char *##ini_get(struct ini_file *ini, const char *sec, const char *par, const char *def);
109  *#    Retrieves a parameter {{par}} from a section {{sec}} within the struct ini_file {{ini}}
110  *#    and returns its value.\n
111  *#    If {{sec}} is {{NULL}}, the global parameters in {{ini}} are searched.\n
112  *#    If the value is not found, the default {{def}}, which may be {{NULL}}, is 
113  *#    returned.
114  */
115 const char *ini_get(struct ini_file *ini, 
116                     const char *sec, 
117                     const char *par, 
118                     const char *def);
119 
120 /*@ int ##ini_put(struct ini_file *ini, const char *sec, const char *par, const char *val);
121  *#    Sets a parameter {{par}} in section {{sec}}‘s value to {{val}}, replacing the 
122  *#    current value if it already exists, or creates the section if it does not 
123  *#    exist.\n
124  *#    If {{sec}} is {{NULL}}, the parameter is added to {{ini}}‘s global parameters.\n
125  *# It returns 1 on success, 0 on failure (which only happens if {{malloc()}} fails).
126  */
127 int ini_put(struct ini_file *ini, const char *sec, const char *par, const char *val);
128 
129 /*@ int ##ini_putf(struct ini_file *ini, const char *sec, const char *par, const char *fmt, ...);
130  *#    {{~~ini_putf()}} takes a {{printf()}} style format string and uses vsnprintf() to
131  *#    pass a value to {{~~ini_put()}}. This function is intended for placing 
132  *#    data types that are not strings into the {{ini_file}}
133  *#    
134  *#    The other parameters are the same as those of {{ini_put()}}.
135  */
136 int ini_putf(struct ini_file *ini, 
137             const char *sec, 
138             const char *par, 
139             const char *fmt, 
140             ...);
141 
142 /*@ const char *##ini_errstr(int err)
143  *# Returns a textual description of an error code
144  */
145 const char *ini_errstr(int err);
146             
147 #if defined(__cplusplus)
148 } /* extern "C" */
149 #endif
150 
151 #endif /* INI_H */

  1 /*
  2  *    This is a simple parser for .INI files.
  3  *    It is based around the syntax described in the Wikipedia entry at
  4  *    "http://en.wikipedia.org/wiki/INI_file"
  5  *
  6  * See ini.h for more info
  7  *
  8  * This is free and unencumbered software released into the public domain.
  9  * http://unlicense.org/
 10  */
 11 #include "stdafx.h"
 12 #include <stdio.h>
 13 #include <stdlib.h>
 14 #include <string.h>
 15 #include <stdarg.h>
 16 #include <ctype.h>
 17 #include <setjmp.h>
 18 
 19 #include <assert.h> /* Remember to define NDEBUG for release */
 20 
 21 #include "ini.h"
 22 #include "utils.h"
 23 #include <crtdbg.h>
 24 
 25 /* Maximum number of characters expected on a line.
 26 It is only used by the ini_putf() function.
 27 */
 28 #define MAX_LINE        1024
 29 
 30 /* Various error codes */
 31 #define SUCCESS                          1
 32 #define FILE_CREATED                  0
 33 #define NO_SUCH_FILE                  -1
 34 #define OUT_OF_MEMORY                  -2
 35 #define MISSING_END_BRACE             -3
 36 #define EMPTY_SECTION                  -4
 37 #define EXPECTED_EQUALS             -5
 38 #define EXPECTED_END_OF_STRING         -6
 39 #define ER_FOPEN                     -7
 40 #define BAD_SYMBOL                     -8
 41 #define EXPECTED_PARAMETER            -9
 42 #define EXPECTED_VALUE                -10
 43 
 44 const char *ini_errstr(int err)
 45 {
 46     switch(err)
 47     {
 48         case SUCCESS : return "Success";
 49         case FILE_CREATED: return "New INI object created";
 50         case NO_SUCH_FILE: return "Unable to open file";
 51         case OUT_OF_MEMORY: return "Out of memory";
 52         case MISSING_END_BRACE: return "Missing ‘]‘ at end of section";
 53         case EMPTY_SECTION: return "Empty [] for section";
 54         case EXPECTED_EQUALS : return "Expected an ‘=‘/‘:‘";
 55         case EXPECTED_END_OF_STRING : return "Expected an end of string";
 56         case ER_FOPEN : return "Unable to open file";
 57         case BAD_SYMBOL : return "Bad symbol";
 58         case EXPECTED_PARAMETER : return "Expected a parameter (or section)";
 59         case EXPECTED_VALUE : return "Expected a value";
 60     }
 61     return "Unknown";
 62 }
 63 
 64 /** Configurable parameters *************************************************/
 65 
 66 /*
 67  *    Recursively adds sections to the tree of sections
 68  */
 69 static void insert_section(ini_section *r, ini_section *n) {
 70     assert(r);
 71     assert(n);
 72 
 73     if(my_stricmp(r->name, n->name) < 0) {
 74         if(!r->left)
 75             r->left = n;
 76         else
 77             insert_section(r->left, n);
 78     } else {
 79         if(!r->right)
 80             r->right = n;
 81         else
 82             insert_section(r->right, n);
 83     }
 84 }
 85 
 86 /*
 87  *    Searches a tree of pairs for a specific parameter
 88  */
 89 static ini_pair *find_pair(ini_pair *root, const char *name) {
 90     int c;
 91 
 92     if(!root) return NULL;
 93 
 94     c = my_stricmp(root->param, name);
 95     if(c == 0)
 96         return root;
 97     else if(c < 0)
 98         return find_pair(root->left, name);
 99     else
100         return find_pair(root->right, name);
101 }
102 
103 /*
104  *    Searches for a specific section
105  */
106 static ini_section *find_section(ini_section *root, const char *name) {
107     int c;
108 
109     if(!root) return NULL;
110 
111     c = my_stricmp(root->name, name);
112     if(c == 0)
113         return root;
114     else if(c < 0)
115         return find_section(root->left, name);
116     else
117         return find_section(root->right, name);
118 }
119 
120 /*
121  *    Creates a new section, and adds it to a tree of sections
122  */
123 static ini_section *add_section(ini_section **root, char *name) {
124     ini_section *n;
125 
126     assert(root);
127     assert(name);
128 
129     n = find_section(*root, name);
130     if(n) {
131         free(name);
132         return n;
133     }
134 
135     n = (ini_section*)malloc(sizeof *n);
136     if(!n) return NULL;
137 
138     n->name = name;
139 
140     n->fields = NULL;
141     n->left = n->right = NULL;
142 
143     if(*root)
144         insert_section(*root, n);
145     else
146         *root = n;
147 
148     return n;
149 }
150 
151 /*
152  *    Inserts a new pair n into a pair tree p
153  */
154 static void insert_pair(ini_pair *p, ini_pair *n) {
155     if(my_stricmp(p->param, n->param) < 0) {
156         if(!p->left)
157             p->left = n;
158         else
159             insert_pair(p->left, n);
160     } else {
161         if(!p->right)
162             p->right = n;
163         else
164             insert_pair(p->right, n);
165     }
166 }
167 
168 /*
169  *    Adds a parameter-value pair to section s
170  */
171 static ini_pair *add_pair(ini_section *s, char *p, char *v) {
172     ini_pair *n;
173 
174     assert(s);
175 
176     n = (ini_pair*)malloc(sizeof *n);
177     if(!n) return NULL;
178 
179     n->param = p;
180     n->value = v;
181 
182     n->left = n->right = NULL;
183 
184     if(!s->fields)
185         s->fields = n;
186     else
187         insert_pair(s->fields, n);
188 
189     return n;
190 }
191 
192 /** Functions for memory deallocation ***************************************/
193 
194 /*
195  *    Free‘s a tree of parameter-value pairs
196  */
197 static void free_pair(ini_pair *p) {
198     if(!p) return;
199 
200     free_pair(p->left);
201     free_pair(p->right);
202 
203     free(p->param);
204     free(p->value);
205     free(p);
206 }
207 
208 /*
209  *    Free‘s all the memory allocated to a ini_section s
210  */
211 static void free_section(ini_section *s) {
212     if(!s) return;
213 
214     free_section(s->left);
215     free_section(s->right);
216 
217     free(s->name);
218     free_pair(s->fields);
219     free(s);
220 }
221 
222 /*
223  *    Free‘s all the memory allocated to a ini_file object in ini_read()
224  */
225 void ini_free(struct ini_file *ini) {
226     if(!ini) return;
227     free_pair(ini->globals);
228     free_section(ini->sections);
229     free(ini);
230 }
231 
232 /** Parsing functions *******************************************************/
233 
234 static struct ini_file *make_ini() 
235 {
236     struct ini_file *ini = (ini_file*)malloc(sizeof *ini);
237     if(!ini) return NULL;
238     ini->globals = NULL;
239     ini->sections = NULL;
240     return ini;
241 }
242 
243 /*
244  *    Reads an INI file and returns it as a ini_file object.
245  *    If filename is NULL, an empty ini_file object is created and returned.
246  */
247 struct ini_file *ini_read(const char *filename, int *err, int *line) {
248     if(line) *line = 0;
249     if(!filename)
250     {
251         if(err) *err = FILE_CREATED;
252         return make_ini();
253     } 
254     else 
255     {
256         char *text = my_readfile(filename);
257         if(!text) {
258             if(err) *err = NO_SUCH_FILE;
259             return NULL;
260         }
261         struct ini_file * ini = ini_parse(text, err, line);
262         free(text);
263         return ini;
264     }
265 }
266 
267 #define T_END        0
268 #define T_VALUE        1
269 
270 static int get_token(const char **tp, const char **tstart, const char **tend, int *line, jmp_buf err) {
271     /* *tstart points to the start of the token, while *tend points one char past the end */
272 
273     const char *t = *tp;
274     int tok = T_END;
275 
276     assert(tp && tstart && tend);
277 
278 whitespace:
279     while(isspace(t[0])) {
280         if(t[0] == ‘\n‘ && line)
281             (*line)++;
282         t++;
283     }
284     if(t[0] == ‘;‘ || t[0] == ‘#‘) {
285         while(t[0] != ‘\n‘ && t[0] != ‘\0‘)
286             t++;
287         goto whitespace;
288     }
289 
290     *tstart = t;
291     *tend = t;
292     if(t[0]) {
293         if(strchr("[]:=", t[0])) {
294             tok = *t++;
295         } else if(isgraph(t[0]) && !strchr("\"‘[];#", t[0])) {
296             while(isgraph(t[0]) && !strchr("\"‘[];#", t[0])) {
297                 t++;
298             }
299             *tend = t;
300             tok = T_VALUE;
301         } else if(t[0] == ‘\"‘ || t[0] == ‘\‘‘) {
302             char delim = t[0];
303             if(t[1] == delim && t[2] == delim) {
304                 /* """Python style long strings""" */
305                 t += 3;
306                 *tstart = t;
307                 while(!(t[0] == delim && t[1] == delim && t[2] == delim)) {
308                     if(t[0] == ‘\0‘) {
309                         longjmp(err, EXPECTED_END_OF_STRING);
310                     } else if(t[0] == ‘\\‘)
311                         t++;
312                     t++;
313                 }
314                 *tend = t;
315                 t+=3;
316             } else {
317                 *tstart = ++t;
318                 while(t[0] != delim) {
319                     if(t[0] == ‘\0‘ || t[0] == ‘\n‘) {
320                         longjmp(err, EXPECTED_END_OF_STRING);
321                     } else if(t[0] == ‘\\‘)
322                         t++;
323                     t++;
324                 }
325                 *tend = t++;
326             }
327             tok = T_VALUE;
328         } else {
329             /* Unrecognized token */
330             longjmp(err, BAD_SYMBOL);
331         }
332     }
333 
334     *tp = t;
335     return tok;
336 }
337 
338 static char *get_string(const char *tstart, const char *tend, jmp_buf err) 
339 {
340     char *string, *s;
341     const char *i;
342 
343     assert(tend > tstart);
344     string = (char*)malloc(tend - tstart + 1);
345     if(!string)
346         longjmp(err, OUT_OF_MEMORY);
347 
348     for(i = tstart, s = string; i < tend; i++) {
349         if(i[0] == ‘\\‘) {
350             switch(*++i) {
351                 case ‘\\‘:
352                 case ‘\‘‘:
353                 case ‘\"‘: *s++ = i[0]; break;
354                 case ‘r‘: *s++ = ‘\r‘; break;
355                 case ‘n‘: *s++ = ‘\n‘; break;
356                 case ‘t‘: *s++ = ‘\t‘; break;
357                 case ‘0‘: *s++ = ‘\0‘; break;
358                 default: break;
359             }
360         } else {
361             *s++ = i[0];
362         }
363     }
364     assert(s - string <= tend - tstart);
365     s[0] = ‘\0‘;
366     return string;
367 }
368 
369 struct ini_file *ini_parse(const char *text, int *err, int *line) {
370     jmp_buf on_error;
371     int e_code;
372 
373     struct ini_file *ini = NULL;
374     ini_section *cur_sec = NULL;
375 
376     const char *tstart, *tend;
377 
378     int t;
379 
380     if(err) *err = SUCCESS;
381     if(line) *line = 1;
382 
383     ini = make_ini();
384 
385     if((e_code = setjmp(on_error)) != 0) {
386         if(err) *err = e_code;
387         ini_free(ini);
388         return NULL;
389     }
390 
391     while((t = get_token(&text, &tstart, &tend, line, on_error)) != T_END) {
392         if(t == ‘[‘) {
393             char *section_name;
394             if(get_token(&text, &tstart, &tend, line, on_error) != T_VALUE) {
395                 longjmp(on_error, EMPTY_SECTION);
396             }
397 
398             section_name = get_string(tstart, tend, on_error);
399 
400             cur_sec = add_section(&ini->sections, section_name);
401             if(!cur_sec)
402                 longjmp(on_error, OUT_OF_MEMORY);
403 
404             if(get_token(&text, &tstart, &tend, line, on_error) != ‘]‘) {
405                 longjmp(on_error, MISSING_END_BRACE);
406             }
407 
408         } else if (t == T_VALUE ) {
409             char *par, *val;
410             par = get_string(tstart, tend, on_error);
411             t = get_token(&text, &tstart, &tend, line, on_error);
412             if(t != ‘=‘ && t != ‘:‘) {
413                 longjmp(on_error, EXPECTED_EQUALS);
414             }
415             if(get_token(&text, &tstart, &tend, line, on_error) != T_VALUE) {
416                 longjmp(on_error, EXPECTED_VALUE);
417             }
418             val = get_string(tstart, tend, on_error);
419 
420             if(cur_sec)
421                 add_pair(cur_sec, par, val);
422             else {
423                 /* Add the parameter and value to the INI file‘s globals */
424                 ini_pair *pair;
425                 if(!(pair = (ini_pair*)malloc(sizeof *pair)))
426                     longjmp(on_error, OUT_OF_MEMORY);
427 
428                 pair->param = par;
429                 pair->value = val;
430 
431                 pair->left = pair->right = NULL;
432 
433                 if(!ini->globals)
434                     ini->globals = pair;
435                 else
436                     insert_pair(ini->globals, pair);
437             }
438 
439 
440         } else
441             longjmp(on_error, EXPECTED_PARAMETER);
442     }
443 
444     return ini;
445 }
446 
447 /** Printing functions ******************************************************/
448 
449 static void string_to_file(FILE *f, const char *s) {
450     fputc(‘\"‘, f);
451     for(; s[0]; s++) {
452         switch(s[0]) {
453             case ‘\n‘: fputs("\\n",f); break;
454             case ‘\r‘: fputs("\\r",f); break;
455             case ‘\t‘: fputs("\\t",f); break;
456             case ‘\"‘: fputs("\\\"",f); break;
457             case ‘\‘‘: fputs("\\\‘",f); break;
458             case ‘\\‘: fputs("\\\\",f); break;
459             default : fputc(s[0], f); break;
460         }
461     }
462     fputc(‘\"‘, f);
463 }
464 
465 /*
466  *    Recursively prints a tree of ini_pairs
467  */
468 static void write_pair(ini_pair *p, FILE *f) {
469     if(!p) return;
470 
471     string_to_file(f, p->param);
472     fputs(" = ", f);
473     string_to_file(f, p->value);
474     fputc(‘\n‘, f);
475 
476     write_pair(p->left, f);
477     write_pair(p->right, f);
478 }
479 
480 /*
481  *    Recursively prints a tree of INI sections
482  */
483 static void write_section(ini_section *s, FILE *f) {
484     if(!s) return;
485 
486     fputs("\n[", f);
487     string_to_file(f, s->name);
488     fputs("]\n", f);
489 
490     write_pair(s->fields, f);
491 
492     /* The akward sequence is to ensure that values are not written sorted */
493 
494     write_section(s->left, f);
495     write_section(s->right, f);
496 }
497 
498 /*
499  *    Saves all the sections and parameters in an ini_file to a file.
500  *    If fname is NULL, it is written to stdout.
501  */
502 int ini_write(struct ini_file *ini, const char *fname) {
503     FILE *f;
504 
505     if(fname) {
506         f = fopen(fname, "w");
507         if(!f)
508             return ER_FOPEN;
509     } else
510         f = stdout;
511 
512     write_pair(ini->globals, f);
513     write_section(ini->sections, f);
514 
515     if(fname)
516         fclose(f);
517 
518     return SUCCESS;
519 }
520 
521 /****************************************************************************/
522 
523 int ini_has_section(struct ini_file *ini, const char *sec) {
524     return find_section(ini->sections, sec) != NULL;
525 }
526 
527 /*
528  *    Finds a specific parameter-value pair in the configuration file
529  */
530 static ini_pair *find_param(const struct ini_file *ini,
531                             const char *sec,
532                             const char *par) {
533     ini_section *s;
534     ini_pair *p;
535 
536     if(!ini) return NULL;
537 
538     if(sec) {
539         s = find_section(ini->sections, sec);
540         if(!s) return NULL;
541         p = s->fields;
542     } else
543         p = ini->globals;
544 
545     if(!p) return NULL;
546 
547     return find_pair(p, par);
548 }
549 
550 /*
551  *    Retrieves a parameter ‘par‘ from a section ‘sec‘ within the ini_file ‘ini‘
552  *    and returns its value.
553  *    If ‘sec‘ is NULL, the global parameters ini ‘ini‘ are searched.
554  *    If the value is not found, ‘def‘ is returned.
555  *    It returns a string. Functions like atoi(), atof(), strtol() and even
556  *    sscanf() can be used to convert it to the relevant type.
557  */
558 const char *ini_get(struct ini_file *ini,
559                     const char *sec,
560                     const char *par,
561                     const char *def) {
562     ini_pair *p;
563 
564     p = find_param(ini, sec, par);
565     if(!p) {
566         if(def)
567             ini_put(ini, sec, par, def);
568         return def;
569     }
570 
571     return p->value;
572 }
573 
574 /*
575  *    Sets a parameter ‘par‘ in section ‘sec‘s value to ‘val‘, replacing the
576  *    current value if it already exists, or creates the section if it does not
577  *    exist
578  */
579 int ini_put(struct ini_file *ini, const char *sec, const char *par, const char *val) {
580     ini_section *s;
581     ini_pair *p, **pp;
582 
583     if(!ini || !val) return 0;
584 
585     p = find_param(ini, sec, par);
586     if(p) {
587         /* Replace the existing value */
588         char *t = p->value;
589         if(!(p->value = my_strdup(val))) {
590             p->value = t;
591             return 0;
592         }
593 
594         free(t);
595         return 1;
596     }
597 
598     if(sec) {
599         s = find_section(ini->sections, sec);
600         if(!s) {
601             /* Create a new section */
602             if(!(s = (ini_section*)malloc(sizeof *s))) return 0;
603             if(!(s->name = my_strdup(sec))) {
604                 free(s);
605                 return 0;
606             }
607 
608             s->fields = NULL;
609             s->left = s->right = NULL;
610 
611             if(ini->sections)
612                 insert_section(ini->sections, s);
613             else
614                 ini->sections = s;
615         }
616 
617         pp = &s->fields;
618     } else
619         pp = &ini->globals;
620 
621     if(!(p = (ini_pair*)malloc(sizeof *p)))
622         return 0;
623 
624     if(!(p->param = my_strdup(par)) || !(p->value = my_strdup(val))) {
625         free(p);
626         return 0;
627     }
628 
629     p->left = p->right = NULL;
630 
631     if(!*pp)
632         *pp = p;
633     else
634         insert_pair(*pp, p);
635 
636     return 1;
637 }
638 
639 /*
640  *    ini_putf() takes a printf() style format string and uses vsnprintf() to
641  *    pass a value to ini_put(). This function is intended for placing
642  *    data types that are not strings into the ini_file
643  *
644  *    The other parameters are the same as those of ini_put().
645  */
646 int ini_putf(struct ini_file *ini,
647             const char *sec,
648             const char *par,
649             const char *fmt,
650             ...) {
651     char buffer[MAX_LINE];
652     va_list arg;
653 
654     va_start(arg, fmt);
655 
656 #ifdef _MSC_VER /* Microsoft Visual C++? */
657     /* VC++ messes around with _‘s before vsnprintf(): */
658 #define    vsnprintf _vsnprintf
659 #endif
660 
661 #if 1
662     vsnprintf(buffer, MAX_LINE, fmt, arg);
663 #else
664     vsprintf(buffer, fmt, arg );
665     assert(strlen(buffer) < MAX_LINE);
666 #endif
667     va_end(arg);
668 
669     return ini_put(ini, sec, par, buffer);
670 }