依赖的类
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 }
ini格式配置文件的读写
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 }
调用
1 static struct ini_file *gamedb = NULL; 2 BOOL CRobomoduleTestDlg::ResetConfig() 3 { 4 ini_put(gamedb, "System", "Half", "0"); 5 ini_put(gamedb, "InitialPose", "X", "0.0"); 6 ini_put(gamedb, "InitialPose", "Y", "0.0"); 7 ini_put(gamedb, "InitialPose", "theta", "0.0"); 8 9 ini_put(gamedb, "TilingUnit_Pose", "XTrans", "0.0"); 10 ini_put(gamedb, "TilingUnit_Pose", "YTrans", "0.0"); 11 ini_put(gamedb, "TilingUnit_Pose", "Height", "1.10"); 12 13 ini_put(gamedb, "Laser_TilingUnitO", "RotateX", "0.0"); 14 ini_put(gamedb, "Laser_TilingUnitO", "RotateY", "0.0"); 15 ini_put(gamedb, "Laser_TilingUnitO", "RotateZ", "0.785398163"); 16 17 ini_put(gamedb, "Laser_TilingUnitO", "TransformX", "0.165"); 18 ini_put(gamedb, "Laser_TilingUnitO", "TransformY", "0.0"); 19 ini_put(gamedb, "Laser_TilingUnitO", "TransformZ", "0.0"); 20 21 ini_put(gamedb, "LaserO", "CalibRotateX", "-0.023289177"); 22 ini_put(gamedb, "LaserO", "CalibRotateY", "0.0"); 23 ini_put(gamedb, "LaserO", "CalibRotateZ", "-0.01573419"); 24 25 ini_put(gamedb, "LaserO", "CalibTransformX", "0.0"); 26 ini_put(gamedb, "LaserO", "CalibTransformY", "0.0"); 27 ini_put(gamedb, "LaserO", "CalibTransformZ", "0.0"); 28 29 char buffer[256]; 30 _snprintf(buffer, sizeof buffer, "%s/%s", "D:", "config.ini"); 31 32 int result = ini_write(gamedb,"config.ini"); 33 ini_free(gamedb); 34 35 gamedb=NULL ; 36 return TRUE; 37 } 38 39 BOOL CRobomoduleTestDlg::OnInitDialog() 40 { 41 CDialog::OnInitDialog(); 42 ini_free(gamedb); 43 gamedb = ini_read(NULL, NULL, NULL); 44 int err, line; 45 ini_free(gamedb); 46 gamedb = ini_read("config.ini", &err, &line); 47 if(ini_get(gamedb,"InitialPose", "X", NULL) != NULL) 48 { 49 const char* a=ini_get(gamedb, "InitialPose", "X", NULL); 50 InitialPoseX= atof(a); 51 } 52 if(ini_get(gamedb,"InitialPose", "Y", NULL) != NULL) 53 { 54 const char* a=ini_get(gamedb, "InitialPose", "Y", NULL); 55 InitialPoseY= atof(a); 56 } 57 if(ini_get(gamedb,"InitialPose", "theta", NULL) != NULL) 58 { 59 const char* a=ini_get(gamedb, "InitialPose", "theta", NULL); 60 InitialPoseTheta= atof(a); 61 } 62 if(ini_get(gamedb,"TilingUnit_Pose", "XTrans", NULL) != NULL) 63 { 64 const char* a=ini_get(gamedb, "TilingUnit_Pose", "XTrans", NULL); 65 XTrans= atof(a); 66 } 67 if(ini_get(gamedb,"TilingUnit_Pose", "YTrans", NULL) != NULL) 68 { 69 const char* a=ini_get(gamedb, "TilingUnit_Pose", "YTrans", NULL); 70 YTrans= atof(a); 71 } 72 if(ini_get(gamedb,"TilingUnit_Pose", "Height", NULL) != NULL) 73 { 74 const char* a=ini_get(gamedb, "TilingUnit_Pose", "Height", NULL); 75 Height= atof(a); 76 } 77 if(ini_get(gamedb,"Laser_TilingUnitO", "RotateX", NULL) != NULL) 78 { 79 const char* b=ini_get(gamedb, "Laser_TilingUnitO", "RotateX", NULL); 80 RotateX= atof(b); 81 } 82 if(ini_get(gamedb,"Laser_TilingUnitO", "RotateY", NULL) != NULL) 83 { 84 const char* a=ini_get(gamedb, "Laser_TilingUnitO", "RotateY", NULL); 85 RotateY= atof(a); 86 } 87 if(ini_get(gamedb,"Laser_TilingUnitO", "RotateZ", NULL) != NULL) 88 { 89 const char* a=ini_get(gamedb, "Laser_TilingUnitO", "RotateZ", NULL); 90 RotateZ= atof(a); 91 } 92 if(ini_get(gamedb,"Laser_TilingUnitO", "TransformX", NULL) != NULL) 93 { 94 const char* a=ini_get(gamedb, "Laser_TilingUnitO", "TransformX", NULL); 95 TransformX= atof(a); 96 } 97 if(ini_get(gamedb,"Laser_TilingUnitO", "TransformY", NULL) != NULL) 98 { 99 const char* a=ini_get(gamedb, "Laser_TilingUnitO", "TransformY", NULL); 100 TransformY= atof(a); 101 } 102 if(ini_get(gamedb,"Laser_TilingUnitO", "TransformZ", NULL) != NULL) 103 { 104 const char* a=ini_get(gamedb, "Laser_TilingUnitO", "TransformZ", NULL); 105 TransformZ= atof(a); 106 } 107 if(ini_get(gamedb,"LaserO", "CalibRotateX", NULL) != NULL) 108 { 109 const char* a=ini_get(gamedb, "LaserO", "CalibRotateX", NULL); 110 CalibRotateX= atof(a); 111 } 112 if(ini_get(gamedb,"LaserO", "CalibRotateY", NULL) != NULL) 113 { 114 const char* a=ini_get(gamedb, "LaserO", "CalibRotateY", NULL); 115 CalibRotateY= atof(a); 116 } 117 if(ini_get(gamedb,"LaserO", "CalibRotateZ", NULL) != NULL) 118 { 119 const char* a=ini_get(gamedb, "LaserO", "CalibRotateZ", NULL); 120 CalibRotateZ= atof(a); 121 } 122 if(ini_get(gamedb,"LaserO", "CalibTransformX", NULL) != NULL) 123 { 124 const char* a=ini_get(gamedb, "LaserO", "CalibTransformX", NULL); 125 CalibTransformX= atof(a); 126 } 127 if(ini_get(gamedb,"LaserO", "CalibTransformY", NULL) != NULL) 128 { 129 const char* a=ini_get(gamedb, "LaserO", "CalibTransformY", NULL); 130 CalibTransformY= atof(a); 131 } 132 if(ini_get(gamedb,"LaserO", "CalibTransformZ", NULL) != NULL) 133 { 134 const char* a=ini_get(gamedb, "LaserO", "CalibTransformZ", NULL); 135 CalibTransformZ= atof(a); 136 } 137 if(ini_get(gamedb,"System", "Half", NULL) != NULL) 138 { 139 const char* a=ini_get(gamedb, "System", "Half", NULL); 140 useHalf= atof(a); 141 }
参考：https://github.com/wernsey/rengine/blob/master/src/ini.c
4050
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
