1: /*
2: * Copyright (c) 2002,2003,2007 Martin Hedenfalk <martin@bzero.se>
3: *
4: * Permission to use, copy, modify, and distribute this software for any
5: * purpose with or without fee is hereby granted, provided that the above
6: * copyright notice and this permission notice appear in all copies.
7: *
8: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15: */
16:
17: /** A configuration file parser library.
18: * @file confuse.h
19: *
20: */
21:
22: /**
23: * \mainpage libConfuse Documentation
24: *
25: * \section intro
26: *
27: * Copyright © 2002-2003 Martin Hedenfalk <martin@bzero.se>
28: *
29: * The latest versions of this manual and the libConfuse software are
30: * available at http://www.nongnu.org/confuse/
31: *
32: *
33: * <em>If you can't convince, confuse.</em>
34: */
35:
36: #ifndef _cfg_h_
37: #define _cfg_h_
38:
39: #ifdef __cplusplus
40: extern "C" {
41: #endif
42:
43: #include <stdio.h>
44: #include <stdarg.h>
45:
46: #if defined(_WIN32) && !defined(__GNUC__)
47: # ifdef HAVE__FILENO
48: # define fileno _fileno
49: # endif
50: # include <io.h>
51: # ifdef HAVE__ISATTY
52: # define isatty _isatty
53: # endif
54: # ifdef BUILDING_DLL
55: # define DLLIMPORT __declspec (dllexport)
56: # else /* ! BUILDING_DLL */
57: # define DLLIMPORT __declspec (dllimport)
58: # endif /* BUILDING_DLL */
59: #else /* ! _WIN32 || __GNUC__ */
60: # define DLLIMPORT
61: #endif /* _WIN32 */
62:
63: #ifndef __BORLANDC__
64: # define __export
65: #endif
66:
67: /** Fundamental option types */
68: enum cfg_type_t {
69: CFGT_NONE,
70: CFGT_INT, /**< integer */
71: CFGT_FLOAT, /**< floating point number */
72: CFGT_STR, /**< string */
73: CFGT_BOOL, /**< boolean value */
74: CFGT_SEC, /**< section */
75: CFGT_FUNC, /**< function */
76: CFGT_PTR /**< pointer to user-defined value */
77: };
78: typedef enum cfg_type_t cfg_type_t;
79:
80: /** Flags. */
81: #define CFGF_NONE 0
82: #define CFGF_MULTI 1 /**< option may be specified multiple times (only applies to sections) */
83: #define CFGF_LIST 2 /**< option is a list */
84: #define CFGF_NOCASE 4 /**< configuration file is case insensitive */
85: #define CFGF_TITLE 8 /**< option has a title (only applies to sections) */
86: #define CFGF_NODEFAULT 16 /**< option has no default value */
87: #define CFGF_NO_TITLE_DUPES 32 /**< multiple section titles must be unique
88: (duplicates raises an error, only applies to
89: sections) */
90:
91: #define CFGF_RESET 64
92: #define CFGF_DEFINIT 128
93:
94: /** Return codes from cfg_parse(). */
95: #define CFG_SUCCESS 0
96: #define CFG_FILE_ERROR -1
97: #define CFG_PARSE_ERROR 1
98:
99: typedef union cfg_value_t cfg_value_t;
100: typedef struct cfg_opt_t cfg_opt_t;
101: typedef struct cfg_t cfg_t;
102: typedef struct cfg_defvalue_t cfg_defvalue_t;
103: typedef int cfg_flag_t;
104:
105: /** Function prototype used by CFGT_FUNC options.
106: *
107: * This is a callback function, registered with the CFG_FUNC
108: * initializer. Each time libConfuse finds a function, the registered
109: * callback function is called (parameters are passed as strings, any
110: * conversion to other types should be made in the callback
111: * function). libConfuse does not support any storage of the data
112: * found; these are passed as parameters to the callback, and it's the
113: * responsibility of the callback function to do whatever it should do
114: * with the data.
115: *
116: * @param cfg The configuration file context.
117: * @param opt The option.
118: * @param argc Number of arguments passed. The callback function is
119: * responsible for checking that the correct number of arguments are
120: * passed.
121: * @param argv Arguments as an array of character strings.
122: *
123: * @return On success, 0 should be returned. All other values
124: * indicates an error, and the parsing is aborted. The callback
125: * function should notify the error itself, for example by calling
126: * cfg_error().
127: *
128: * @see CFG_FUNC
129: */
130: typedef int (*cfg_func_t)(cfg_t *cfg, cfg_opt_t *opt,
131: int argc, const char **argv);
132:
133: /** Function prototype used by the cfg_print_ functions.
134: *
135: * This callback function is used to print option values. For options
136: * with a value parsing callback, this is often required, especially
137: * if a string is mapped to an integer by the callback. This print
138: * callback must then map the integer back to the appropriate string.
139: *
140: * Except for functions, the print callback function should only print
141: * the value of the option, not the name and the equal sign (that is
142: * handled by the cfg_opt_print function). For function options
143: * however, the name and the parenthesis must be printed by this
144: * function. The value to print can be accessed with the cfg_opt_get
145: * functions.
146: *
147: * @param opt The option structure (eg, as returned from cfg_getopt())
148: * @param index Index of the value to get. Zero based.
149: * @param fp File stream to print to, use stdout to print to the screen.
150: *
151: * @see cfg_print, cfg_set_print_func
152: */
153: typedef void (*cfg_print_func_t)(cfg_opt_t *opt, unsigned int index, FILE *fp);
154:
155: /** Value parsing callback prototype
156: *
157: * This is a callback function (different from the one registered with the
158: * CFG_FUNC initializer) used to parse a value. This can be used to override
159: * the internal parsing of a value.
160: *
161: * Suppose you want an integer option that only can have certain values, for
162: * example 1, 2 and 3, and these should be written in the configuration file as
163: * "yes", "no" and "maybe". The callback function would be called with the
164: * found value ("yes", "no" or "maybe") as a string, and the result should be
165: * stored in the result parameter.
166: *
167: * @param cfg The configuration file context.
168: * @param opt The option.
169: * @param value The value found in the configuration file.
170: * @param result Pointer to storage for the result, cast to a void pointer.
171: *
172: * @return On success, 0 should be returned. All other values indicates an
173: * error, and the parsing is aborted. The callback function should notify the
174: * error itself, for example by calling cfg_error().
175: */
176: typedef int (*cfg_callback_t)(cfg_t *cfg, cfg_opt_t *opt,
177: const char *value, void *result);
178:
179: /** Validating callback prototype
180: *
181: * This callback function is called after an option has been parsed and set.
182: * The function is called for both fundamental values (strings, integers etc)
183: * as well as lists and sections. This can for example be used to validate that
184: * all required options in a section has been set to sane values.
185: *
186: * @return On success, 0 should be returned. All other values indicates an
187: * error, and the parsing is aborted. The callback function should notify the
188: * error itself, for example by calling cfg_error().
189: *
190: * @see cfg_set_validate_func
191: */
192: typedef int (*cfg_validate_callback_t)(cfg_t *cfg, cfg_opt_t *opt);
193:
194: /** User-defined memory release function for CFG_PTR values
195: *
196: * This callback is used to free memory allocated in a value parsing callback
197: * function. Especially useful for CFG_PTR options, since libConfuse will not
198: * itself release such values. If the values are simply allocated with a
199: * malloc(3), one can use the standard free(3) function here.
200: *
201: */
202: typedef void (*cfg_free_func_t)(void *value);
203:
204: /** Boolean values. */
205: typedef enum {cfg_false, cfg_true} cfg_bool_t;
206:
207: /** Error reporting function. */
208: typedef void (*cfg_errfunc_t)(cfg_t *cfg, const char *fmt, va_list ap);
209:
210: /** Data structure holding information about a "section". Sections can
211: * be nested. A section has a list of options (strings, numbers,
212: * booleans or other sections) grouped together.
213: */
214: struct cfg_t {
215: cfg_flag_t flags; /**< Any flags passed to cfg_init() */
216: char *name; /**< The name of this section, the root
217: * section returned from cfg_init() is
218: * always named "root" */
219: cfg_opt_t *opts; /**< Array of options */
220: char *title; /**< Optional title for this section, only
221: * set if CFGF_TITLE flag is set */
222: char *filename; /**< Name of the file being parsed */
223: int line; /**< Line number in the config file */
224: cfg_errfunc_t errfunc; /**< This function (if set with
225: * cfg_set_error_function) is called for
226: * any error message. */
227: };
228:
229: /** Data structure holding the value of a fundamental option value.
230: */
231: union cfg_value_t {
232: long int number; /**< integer value */
233: double fpnumber; /**< floating point value */
234: cfg_bool_t boolean; /**< boolean value */
235: char *string; /**< string value */
236: cfg_t *section; /**< section value */
237: void *ptr; /**< user-defined value */
238: };
239:
240: /** Data structure holding the default value given by the
241: * initialization macros.
242: */
243: struct cfg_defvalue_t {
244: long int number; /**< default integer value */
245: double fpnumber; /**< default floating point value */
246: cfg_bool_t boolean; /**< default boolean value */
247: char *string; /**< default string value */
248: char *parsed; /**< default value that is parsed by
249: * libConfuse, used for lists and
250: * functions */
251: };
252:
253: /** Data structure holding information about an option. The value(s)
254: * are stored as an array of fundamental values (strings, numbers,
255: * etc).
256: */
257: struct cfg_opt_t {
258: char *name; /**< The name of the option */
259: cfg_type_t type; /**< Type of option */
260: unsigned int nvalues; /**< Number of values parsed */
261: cfg_value_t **values; /**< Array of found values */
262: cfg_flag_t flags; /**< Flags */
263: cfg_opt_t *subopts; /**< Suboptions (only applies to sections) */
264: cfg_defvalue_t def; /**< Default value */
265: cfg_func_t func; /**< Function callback for CFGT_FUNC options */
266: void *simple_value; /**< Pointer to user-specified variable to
267: * store simple values (created with the
268: * CFG_SIMPLE_* initializers) */
269: cfg_callback_t parsecb; /**< Value parsing callback function */
270: cfg_validate_callback_t validcb; /**< Value validating callback function */
271: cfg_print_func_t pf; /**< print callback function */
272: cfg_free_func_t freecb; /***< user-defined memory release function */
273: };
274:
275: extern const char __export confuse_copyright[];
276: extern const char __export confuse_version[];
277: extern const char __export confuse_author[];
278:
279: #define __CFG_STR(name, def, flags, svalue, cb) \
280: {name,CFGT_STR,0,0,flags,0,{0,0,cfg_false,def,0},0,svalue,cb,0,0,0}
281: #define __CFG_STR_LIST(name, def, flags, svalue, cb) \
282: {name,CFGT_STR,0,0,flags | CFGF_LIST,0,{0,0,cfg_false,0,def},0,svalue,cb,0,0,0}
283:
284: /** Initialize a string option
285: */
286: #define CFG_STR(name, def, flags) \
287: __CFG_STR(name, def, flags, 0, 0)
288:
289: /** Initialize a string list option
290: */
291: #define CFG_STR_LIST(name, def, flags) \
292: __CFG_STR_LIST(name, def, flags, 0, 0)
293:
294: /** Initialize a string option with a value parsing callback
295: */
296: #define CFG_STR_CB(name, def, flags, cb) \
297: __CFG_STR(name, def, flags, 0, cb)
298:
299: /** Initialize a string list option with a value parsing callback
300: */
301: #define CFG_STR_LIST_CB(name, def, flags, cb) \
302: __CFG_STR_LIST(name, def, flags, 0, cb)
303:
304: /** Initialize a "simple" string option.
305: *
306: * "Simple" options (in lack of a better expression) does not support
307: * lists of values or multiple sections. LibConfuse will store the
308: * value of a simple option in the user-defined location specified by
309: * the value parameter in the initializer. Simple options are not
310: * stored in the cfg_t context, only a pointer. Sections can not be
311: * initialized as a "simple" option.
312: *
313: * As of version 2.2, libConfuse can now return the values of simple
314: * options with the cfg_get functions. This allows using the new
315: * cfg_print function with simple options.
316: *
317: * libConfuse doesn't support handling default values for "simple"
318: * options. They are assumed to be set by the calling application
319: * before cfg_parse is called.
320: *
321: * @param name name of the option
322: * @param svalue pointer to a character pointer (a char **). This value
323: * must be initalized either to NULL or to a malloc()'ed string. You
324: * can't use
325: * <pre>
326: * char *user = "joe";
327: * ...
328: * cfg_opt_t opts[] = {
329: * CFG_SIMPLE_STR("user", &user),
330: * ...
331: * </pre>
332: * since libConfuse will try to free the static string "joe" (which is
333: * an error) when a "user" option is found. Rather, use the following
334: * code snippet:
335: * <pre>
336: * char *user = strdup("joe");
337: * ...
338: * cfg_opt_t opts[] = {
339: * CFG_SIMPLE_STR("user", &user),
340: * ...
341: * </pre>
342: * Alternatively, the default value can be set after the opts struct
343: * is defined, as in:
344: * <pre>
345: * char *user = 0;
346: * ...
347: * cfg_opt_t opts[] = {
348: * CFG_SIMPLE_STR("user", &user),
349: * ...
350: * user = strdup("joe");
351: * cfg = cfg_init(opts, 0);
352: * cfg_parse(cfg, filename);
353: * </pre>
354: *
355: */
356: #define CFG_SIMPLE_STR(name, svalue) \
357: __CFG_STR(name, 0, CFGF_NONE, svalue, 0)
358:
359:
360: #define __CFG_INT(name, def, flags, svalue, cb) \
361: {name,CFGT_INT,0,0,flags,0,{def,0,cfg_false,0,0},0,svalue,cb,0,0,0}
362: #define __CFG_INT_LIST(name, def, flags, svalue, cb) \
363: {name,CFGT_INT,0,0,flags | CFGF_LIST,0,{0,0,cfg_false,0,def},0,svalue,cb,0,0,0}
364:
365: /** Initialize an integer option
366: */
367: #define CFG_INT(name, def, flags) \
368: __CFG_INT(name, def, flags, 0, 0)
369:
370: /** Initialize an integer list option
371: */
372: #define CFG_INT_LIST(name, def, flags) \
373: __CFG_INT_LIST(name, def, flags, 0, 0)
374:
375: /** Initialize an integer option with a value parsing callback
376: */
377: #define CFG_INT_CB(name, def, flags, cb) \
378: __CFG_INT(name, def, flags, 0, cb)
379:
380: /** Initialize an integer list option with a value parsing callback
381: */
382: #define CFG_INT_LIST_CB(name, def, flags, cb) \
383: __CFG_INT_LIST(name, def, flags, 0, cb)
384:
385: /** Initialize a "simple" integer option (see documentation for
386: * CFG_SIMPLE_STR for more information).
387: */
388: #define CFG_SIMPLE_INT(name, svalue) \
389: __CFG_INT(name, 0, CFGF_NONE, svalue, 0)
390:
391:
392:
393: #define __CFG_FLOAT(name, def, flags, svalue, cb) \
394: {name,CFGT_FLOAT,0,0,flags,0,{0,def,cfg_false,0,0},0,svalue,cb,0,0,0}
395: #define __CFG_FLOAT_LIST(name, def, flags, svalue, cb) \
396: {name,CFGT_FLOAT,0,0,flags | CFGF_LIST,0,{0,0,cfg_false,0,def},0,svalue,cb,0,0,0}
397:
398: /** Initialize a floating point option
399: */
400: #define CFG_FLOAT(name, def, flags) \
401: __CFG_FLOAT(name, def, flags, 0, 0)
402:
403: /** Initialize a floating point list option
404: */
405: #define CFG_FLOAT_LIST(name, def, flags) \
406: __CFG_FLOAT_LIST(name, def, flags, 0, 0)
407:
408: /** Initialize a floating point option with a value parsing callback
409: */
410: #define CFG_FLOAT_CB(name, def, flags, cb) \
411: __CFG_FLOAT(name, def, flags, 0, cb)
412:
413: /** Initialize a floating point list option with a value parsing callback
414: */
415: #define CFG_FLOAT_LIST_CB(name, def, flags, cb) \
416: __CFG_FLOAT_LIST(name, def, flags, 0, cb)
417:
418: /** Initialize a "simple" floating point option (see documentation for
419: * CFG_SIMPLE_STR for more information).
420: */
421: #define CFG_SIMPLE_FLOAT(name, svalue) \
422: __CFG_FLOAT(name, 0, CFGF_NONE, svalue, 0)
423:
424:
425:
426: #define __CFG_BOOL(name, def, flags, svalue, cb) \
427: {name,CFGT_BOOL,0,0,flags,0,{0,0,def,0,0},0,svalue,cb,0,0,0}
428: #define __CFG_BOOL_LIST(name, def, flags, svalue, cb) \
429: {name,CFGT_BOOL,0,0,flags | CFGF_LIST,0,{0,0,cfg_false,0,def},0,svalue,cb,0,0,0}
430:
431: /** Initialize a boolean option
432: */
433: #define CFG_BOOL(name, def, flags) \
434: __CFG_BOOL(name, def, flags, 0, 0)
435:
436: /** Initialize a boolean list option
437: */
438: #define CFG_BOOL_LIST(name, def, flags) \
439: __CFG_BOOL_LIST(name, def, flags, 0, 0)
440:
441: /** Initialize a boolean option with a value parsing callback
442: */
443: #define CFG_BOOL_CB(name, def, flags, cb) \
444: __CFG_BOOL(name, def, flags, 0, cb)
445:
446: /** Initialize a boolean list option with a value parsing callback
447: */
448: #define CFG_BOOL_LIST_CB(name, def, flags, cb) \
449: __CFG_BOOL_LIST(name, def, flags, 0, cb)
450:
451: /** Initialize a "simple" boolean option (see documentation for
452: * CFG_SIMPLE_STR for more information).
453: */
454: #define CFG_SIMPLE_BOOL(name, svalue) \
455: __CFG_BOOL(name, cfg_false, CFGF_NONE, svalue, 0)
456:
457:
458:
459: /** Initialize a section
460: *
461: * @param name The name of the option
462: * @param opts Array of options that are valid within this section
463:
464: * @param flags Flags, specify CFGF_MULTI if it should be possible to
465: * have multiples of the same section, and CFGF_TITLE if the
466: * section(s) must have a title (which can be used in the
467: * cfg_gettsec() function)
468: *
469: */
470: #define CFG_SEC(name, opts, flags) \
471: {name,CFGT_SEC,0,0,flags,opts,{0,0,cfg_false,0,0},0,0,0,0,0,0}
472:
473:
474:
475: /** Initialize a function
476: * @param name The name of the option
477: * @param func The callback function.
478: *
479: * @see cfg_func_t
480: */
481: #define CFG_FUNC(name, func) \
482: {name,CFGT_FUNC,0,0,CFGF_NONE,0,{0,0,cfg_false,0,0},func,0,0,0,0,0}
483:
484:
485: #define __CFG_PTR(name, def, flags, svalue, parsecb, freecb) \
486: {name,CFGT_PTR,0,0,flags,0,{0,0,cfg_false,0,def},0,svalue,parsecb,0,0,freecb}
487: #define __CFG_PTR_LIST(name, def, flags, svalue, parsecb, freecb) \
488: {name,CFGT_PTR,0,0,flags | CFGF_LIST,0,{0,0,cfg_false,0,def},0,svalue,parsecb,0,0,freecb}
489:
490: /** Initialize a user-defined option
491: *
492: * CFG_PTR options can only be used together with a value parsing callback.
493: *
494: * @param name The name of the option
495: * @param def Default value
496: * @param flags Flags
497: * @param parsecb Value parsing callback
498: * @param freecb Memory release function
499: *
500: * @see cfg_callback_t, cfg_free_func_t
501: */
502: #define CFG_PTR_CB(name, def, flags, parsecb, freecb) \
503: __CFG_PTR(name, def, flags, 0, parsecb, freecb)
504:
505: /** Initialize a list of user-defined options
506: */
507: #define CFG_PTR_LIST_CB(name, def, flags, parsecb, freecb) \
508: __CFG_PTR(name, def, flags | CFGF_LIST, 0, parsecb, freecb)
509:
510: /*#define CFG_SIMPLE_PTR(name, svalue, cb) \
511: __CFG_PTR(name, 0, 0, svalue, cb)*/
512:
513:
514: /** Terminate list of options. This must be the last initializer in
515: * the option list.
516: */
517: #define CFG_END() \
518: {0,CFGT_NONE,0,0,CFGF_NONE,0,{0,0,cfg_false,0,0},0,0,0,0,0,0}
519:
520:
521:
522: /** Create and initialize a cfg_t structure. This should be the first function
523: * called when setting up the parsing of a configuration file. The options
524: * passed in the first parameter is initialized using the CFG_* initializers.
525: * The last option in the option array must be CFG_END(), unless you like
526: * segmentation faults.
527: *
528: * The options must no longer be defined in the same scope as where the cfg_xxx
529: * functions are used (since version 2.3).
530: *
531: * @param opts An arrary of options
532: * @param flags One or more flags (bitwise or'ed together). Currently only
533: * CFGF_NOCASE is available. Use 0 if no flags are needed.
534: *
535: * @return A configuration context structure. This pointer is passed
536: * to almost all other functions as the first parameter.
537: */
538: DLLIMPORT cfg_t * __export cfg_init(cfg_opt_t *opts, cfg_flag_t flags);
539:
540: /** Parse a configuration file. Tilde expansion is performed on the
541: * filename before it is opened. After a configuration file has been
542: * initialized (with cfg_init()) and parsed (with cfg_parse()), the
543: * values can be read with the cfg_getXXX functions.
544: *
545: * @param cfg The configuration file context as returned from cfg_init().
546: * @param filename The name of the file to parse.
547: *
548: * @return On success, CFG_SUCCESS is returned. If the file couldn't
549: * be opened for reading, CFG_FILE_ERROR is returned. On all other
550: * errors, CFG_PARSE_ERROR is returned and cfg_error() was called with
551: * a descriptive error message.
552: */
553: DLLIMPORT int __export cfg_parse(cfg_t *cfg, const char *filename);
554:
555: /** Same as cfg_parse() above, but takes an already opened file as
556: * argument. Reading begins at the current position. After parsing,
557: * the position is not reset. The caller is responsible for closing
558: * the file.
559: *
560: * @param cfg The configuration file context as returned from cfg_init().
561: * @param fp An open file stream.
562: *
563: * @see cfg_parse()
564: */
565: DLLIMPORT int __export cfg_parse_fp(cfg_t *cfg, FILE *fp);
566:
567: /** Same as cfg_parse() above, but takes a character buffer as
568: * argument.
569: *
570: * @param cfg The configuration file context as returned from cfg_init().
571: * @param buf A zero-terminated string with configuration directives.
572: *
573: * @see cfg_parse()
574: */
575: DLLIMPORT int __export cfg_parse_buf(cfg_t *cfg, const char *buf);
576:
577: /** Free the memory allocated for the values of a given option. Only
578: * the values are freed, not the option itself (it is freed by cfg_free()).
579: *
580: * @see cfg_free()
581: */
582: DLLIMPORT void __export cfg_free_value(cfg_opt_t *opt);
583:
584: /** Free a cfg_t context. All memory allocated by the cfg_t context
585: * structure are freed, and can't be used in any further cfg_* calls.
586: */
587: DLLIMPORT void __export cfg_free(cfg_t *cfg);
588:
589: /** Install a user-defined error reporting function.
590: * @return The old error reporting function is returned.
591: */
592: DLLIMPORT cfg_errfunc_t __export cfg_set_error_function(cfg_t *cfg,
593: cfg_errfunc_t errfunc);
594:
595: /** Show a parser error. Any user-defined error reporting function is called.
596: * @see cfg_set_error_function
597: */
598: DLLIMPORT void __export cfg_error(cfg_t *cfg, const char *fmt, ...);
599:
600: /** Returns the value of an integer option, given a cfg_opt_t pointer.
601: * @param opt The option structure (eg, as returned from cfg_getopt())
602: * @param index Index of the value to get. Zero based.
603: * @see cfg_getnint
604: */
605: DLLIMPORT signed long __export cfg_opt_getnint(cfg_opt_t *opt, unsigned int index);
606:
607: /** Indexed version of cfg_getint(), used for lists.
608: * @param cfg The configuration file context.
609: * @param name The name of the option.
610: * @param index Index of the value to get. Zero based.
611: * @see cfg_getint
612: */
613: DLLIMPORT long int __export cfg_getnint(cfg_t *cfg, const char *name,
614: unsigned int index);
615:
616: /** Returns the value of an integer option. This is the same as
617: * calling cfg_getnint with index 0.
618: * @param cfg The configuration file context.
619: * @param name The name of the option.
620: * @return The requested value is returned. If the option was not set
621: * in the configuration file, the default value given in the
622: * corresponding cfg_opt_t structure is returned. It is an error to
623: * try to get an option that isn't declared.
624: */
625: DLLIMPORT long int __export cfg_getint(cfg_t *cfg, const char *name);
626:
627: /** Returns the value of a floating point option, given a cfg_opt_t pointer.
628: * @param opt The option structure (eg, as returned from cfg_getopt())
629: * @param index Index of the value to get. Zero based.
630: * @see cfg_getnfloat
631: */
632: DLLIMPORT double __export cfg_opt_getnfloat(cfg_opt_t *opt, unsigned int index);
633:
634: /** Indexed version of cfg_getfloat(), used for lists.
635: * @param cfg The configuration file context.
636: * @param name The name of the option.
637: * @param index Index of the value to get. Zero based.
638: * @see cfg_getfloat
639: */
640: DLLIMPORT double __export cfg_getnfloat(cfg_t *cfg, const char *name,
641: unsigned int index);
642:
643: /** Returns the value of a floating point option.
644: * @param cfg The configuration file context.
645: * @param name The name of the option.
646: * @return The requested value is returned. If the option was not set
647: * in the configuration file, the default value given in the
648: * corresponding cfg_opt_t structure is returned. It is an error to
649: * try to get an option that isn't declared.
650: */
651: DLLIMPORT double __export cfg_getfloat(cfg_t *cfg, const char *name);
652:
653: /** Returns the value of a string option, given a cfg_opt_t pointer.
654: * @param opt The option structure (eg, as returned from cfg_getopt())
655: * @param index Index of the value to get. Zero based.
656: * @see cfg_getnstr
657: */
658: DLLIMPORT char * __export cfg_opt_getnstr(cfg_opt_t *opt, unsigned int index);
659:
660: /** Indexed version of cfg_getstr(), used for lists.
661: * @param cfg The configuration file context.
662: * @param name The name of the option.
663: * @param index Index of the value to get. Zero based.
664: * @see cfg_getstr
665: */
666: DLLIMPORT char * __export cfg_getnstr(cfg_t *cfg, const char *name,
667: unsigned int index);
668:
669: /** Returns the value of a string option.
670: * @param cfg The configuration file context.
671: * @param name The name of the option.
672: * @return The requested value is returned. If the option was not set
673: * in the configuration file, the default value given in the
674: * corresponding cfg_opt_t structure is returned. It is an error to
675: * try to get an option that isn't declared.
676: */
677: DLLIMPORT char * __export cfg_getstr(cfg_t *cfg, const char *name);
678:
679: /** Returns the value of a boolean option, given a cfg_opt_t pointer.
680: * @param opt The option structure (eg, as returned from cfg_getopt())
681: * @param index Index of the value to get. Zero based.
682: * @see cfg_getnbool
683: */
684: DLLIMPORT cfg_bool_t __export cfg_opt_getnbool(cfg_opt_t *opt, unsigned int index);
685:
686: /** Indexed version of cfg_getbool(), used for lists.
687: *
688: * @param cfg The configuration file context.
689: * @param name The name of the option.
690: * @param index Index of the value to get. Zero based.
691: * @see cfg_getbool
692: */
693: DLLIMPORT cfg_bool_t __export cfg_getnbool(cfg_t *cfg, const char *name,
694: unsigned int index);
695:
696: /** Returns the value of a boolean option.
697: * @param cfg The configuration file context.
698: * @param name The name of the option.
699: * @return The requested value is returned. If the option was not set
700: * in the configuration file, the default value given in the
701: * corresponding cfg_opt_t structure is returned. It is an error to
702: * try to get an option that isn't declared.
703: */
704: DLLIMPORT cfg_bool_t __export cfg_getbool(cfg_t *cfg, const char *name);
705:
706:
707: DLLIMPORT void * __export cfg_opt_getnptr(cfg_opt_t *opt, unsigned int index);
708: DLLIMPORT void * __export cfg_getnptr(cfg_t *cfg, const char *name, unsigned int indx);
709:
710: /** Returns the value of a user-defined option (void pointer).
711: * @param cfg The configuration file context.
712: * @param name The name of the option.
713: * @return The requested value is returned. If the option was not set
714: * in the configuration file, the default value given in the
715: * corresponding cfg_opt_t structure is returned. It is an error to
716: * try to get an option that isn't declared.
717: */
718: DLLIMPORT void * __export cfg_getptr(cfg_t *cfg, const char *name);
719:
720:
721: /** Returns the value of a section option, given a cfg_opt_t pointer.
722: * @param opt The option structure (eg, as returned from cfg_getopt())
723: * @param index Index of the value to get. Zero based.
724: * @see cfg_getnsec
725: */
726: DLLIMPORT cfg_t * __export cfg_opt_getnsec(cfg_opt_t *opt, unsigned int index);
727:
728: /** Indexed version of cfg_getsec(), used for sections with the
729: * CFGF_MULTI flag set.
730: *
731: * @param cfg The configuration file context.
732: * @param name The name of the option.
733: * @param index Index of the section to get. Zero based.
734: * @see cfg_getsec
735: */
736: DLLIMPORT cfg_t * __export cfg_getnsec(cfg_t *cfg, const char *name,
737: unsigned int index);
738:
739: /** Returns the value of a section option, given a cfg_opt_t pointer
740: * and the title.
741: * @param opt The option structure (eg, as returned from cfg_getopt())
742: * @param title The title of this section. The CFGF_TITLE flag must
743: * have been set for this option.
744: * @see cfg_gettsec
745: */
746: DLLIMPORT cfg_t * __export cfg_opt_gettsec(cfg_opt_t *opt, const char *title);
747:
748: /** Return a section given the title, used for section with the
749: * CFGF_TITLE flag set.
750: *
751: * @param cfg The configuration file context.
752: * @param name The name of the option.
753: * @param title The title of this section. The CFGF_TITLE flag must
754: * have been set for this option.
755: * @see cfg_getsec
756: */
757: DLLIMPORT cfg_t * __export cfg_gettsec(cfg_t *cfg, const char *name,
758: const char *title);
759:
760: /** Returns the value of a section option. The returned value is
761: * another cfg_t structure that can be used in following calls to
762: * cfg_getint, cfg_getstr or other get-functions.
763: * @param cfg The configuration file context.
764: * @param name The name of the option.
765: * @return The requested section is returned. If no section is found
766: * with that name, 0 is returned. There can only be default values for
767: * section without the CFGF_MULTI flag set. It is an error to try to
768: * get a section that isn't declared.
769: */
770: DLLIMPORT cfg_t * __export cfg_getsec(cfg_t *cfg, const char *name);
771:
772: /** Return the number of values this option has. If no default value
773: * is given for the option and no value was found in the config file,
774: * 0 will be returned (ie, the option value is not set at all).
775: * @param opt The option structure (eg, as returned from cfg_getopt())
776: */
777: DLLIMPORT unsigned int __export cfg_opt_size(cfg_opt_t *opt);
778:
779: /** Return the number of values this option has. If no default value
780: * is given for the option and no value was found in the config file,
781: * 0 will be returned (ie, the option value is not set at all).
782: *
783: * Note that there is no way to *not* specify a default value for integers,
784: * floats and booleans. Ie, they always have default values (since 0 or NULL is
785: * a valid integer/float/boolean value). Only strings and lists may have no
786: * default value.
787: *
788: * @param cfg The configuration file context.
789: * @param name The name of the option.
790: */
791: DLLIMPORT unsigned int __export cfg_size(cfg_t *cfg, const char *name);
792:
793: /** Return the title of a section.
794: *
795: * @param cfg The configuration file context.
796: * @return Returns the title, or 0 if there is no title. This string
797: * should not be modified.
798: */
799: DLLIMPORT const char * __export cfg_title(cfg_t *cfg);
800:
801: /** Return the name of a section.
802: *
803: * @param cfg The configuration file context.
804: * @return Returns the title, or 0 if there is no title. This string
805: * should not be modified.
806: */
807: DLLIMPORT const char * __export cfg_name(cfg_t *cfg);
808:
809: /** Return the name of an option.
810: *
811: * @param opt The option structure (eg, as returned from cfg_getopt())
812: * @return Returns the title, or 0 if there is no title. This string
813: * should not be modified.
814: */
815: DLLIMPORT const char * __export cfg_opt_name(cfg_opt_t *opt);
816:
817: /** Predefined include-function. This function can be used in the
818: * options passed to cfg_init() to specify a function for including
819: * other configuration files in the parsing. For example:
820: * CFG_FUNC("include", &cfg_include)
821: */
822: DLLIMPORT int __export cfg_include(cfg_t *cfg, cfg_opt_t *opt, int argc,
823: const char **argv);
824:
825: /** Does tilde expansion (~ -> $HOME) on the filename.
826: * @return The expanded filename is returned. If a ~user was not
827: * found, the original filename is returned. In any case, a
828: * dynamically allocated string is returned, which should be free()'d
829: * by the caller.
830: */
831: DLLIMPORT char * __export cfg_tilde_expand(const char *filename);
832:
833: /** Parse a boolean option string. Accepted "true" values are "true",
834: * "on" and "yes", and accepted "false" values are "false", "off" and
835: * "no".
836: *
837: * @return Returns 1 or 0 (true/false) if the string was parsed
838: * correctly, or -1 if an error occurred.
839: */
840: DLLIMPORT int __export cfg_parse_boolean(const char *s);
841:
842: /** Return an option given it's name.
843: *
844: * @param cfg The configuration file context.
845: * @param name The name of the option.
846: *
847: * @return Returns a pointer to the option. If the option isn't declared,
848: * libConfuse will print an error message and return 0.
849: */
850: DLLIMPORT cfg_opt_t * __export cfg_getopt(cfg_t *cfg, const char *name);
851:
852: /** Set an option (create an instance of an option).
853: *
854: * @param cfg The configuration file context.
855: * @param opt The option definition.
856: * @param value The initial value for the option.
857: *
858: * @return Returns a pointer to the value object.
859: */
860: DLLIMPORT cfg_value_t *cfg_setopt(cfg_t *cfg, cfg_opt_t *opt, char *value);
861:
862: /** Set a value of an integer option.
863: *
864: * @param opt The option structure (eg, as returned from cfg_getopt())
865: * @param value The value to set.
866: * @param index The index in the option value array that should be
867: * modified. It is an error to set values with indices larger than 0
868: * for options without the CFGF_LIST flag set.
869: */
870: DLLIMPORT void __export cfg_opt_setnint(cfg_opt_t *opt,
871: long int value, unsigned int index);
872:
873: /** Set the value of an integer option given its name.
874: *
875: * @param cfg The configuration file context.
876: * @param name The name of the option.
877: * @param value The value to set. If the option is a list (the CFGF_LIST flag
878: * is set), only the first value (with index 0) is set.
879: */
880: DLLIMPORT void __export cfg_setint(cfg_t *cfg, const char *name,
881: long int value);
882:
883: /** Set a value of an integer option given its name and index.
884: *
885: * @param cfg The configuration file context.
886: * @param name The name of the option.
887: * @param value The value to set.
888: * @param index The index in the option value array that should be
889: * modified. It is an error to set values with indices larger than 0
890: * for options without the CFGF_LIST flag set.
891: */
892: DLLIMPORT void __export cfg_setnint(cfg_t *cfg, const char *name,
893: long int value, unsigned int index);
894:
895: /** Set a value of a floating point option.
896: *
897: * @param opt The option structure (eg, as returned from cfg_getopt())
898: * @param value The value to set.
899: * @param index The index in the option value array that should be
900: * modified. It is an error to set values with indices larger than 0
901: * for options without the CFGF_LIST flag set.
902: */
903: DLLIMPORT void __export cfg_opt_setnfloat(cfg_opt_t *opt,
904: double value, unsigned int index);
905:
906: /** Set the value of a floating point option given its name.
907: *
908: * @param cfg The configuration file context.
909: * @param name The name of the option.
910: * @param value The value to set. If the option is a list (the CFGF_LIST flag
911: * is set), only the first value (with index 0) is set.
912: */
913: DLLIMPORT void __export cfg_setfloat(cfg_t *cfg, const char *name,
914: double value);
915:
916: /** Set a value of a floating point option given its name and index.
917: *
918: * @param cfg The configuration file context.
919: * @param name The name of the option.
920: * @param value The value to set.
921: * @param index The index in the option value array that should be
922: * modified. It is an error to set values with indices larger than 0
923: * for options without the CFGF_LIST flag set.
924: */
925: DLLIMPORT void __export cfg_setnfloat(cfg_t *cfg, const char *name,
926: double value, unsigned int index);
927:
928: /** Set a value of a boolean option.
929: *
930: * @param opt The option structure (eg, as returned from cfg_getopt())
931: * @param value The value to set.
932: * @param index The index in the option value array that should be
933: * modified. It is an error to set values with indices larger than 0
934: * for options without the CFGF_LIST flag set.
935: */
936: DLLIMPORT void __export cfg_opt_setnbool(cfg_opt_t *opt,
937: cfg_bool_t value, unsigned int index);
938:
939: /** Set the value of a boolean option given its name.
940: *
941: * @param cfg The configuration file context.
942: * @param name The name of the option.
943: * @param value The value to set. If the option is a list (the CFGF_LIST flag
944: * is set), only the first value (with index 0) is set.
945: */
946: DLLIMPORT void __export cfg_setbool(cfg_t *cfg, const char *name,
947: cfg_bool_t value);
948:
949: /** Set a value of a boolean option given its name and index.
950: *
951: * @param cfg The configuration file context.
952: * @param name The name of the option.
953: * @param value The value to set.
954: * @param index The index in the option value array that should be
955: * modified. It is an error to set values with indices larger than 0
956: * for options without the CFGF_LIST flag set.
957: */
958: DLLIMPORT void __export cfg_setnbool(cfg_t *cfg, const char *name,
959: cfg_bool_t value, unsigned int index);
960:
961: /** Set a value of a string option.
962: *
963: * @param opt The option structure (eg, as returned from cfg_getopt())
964: * @param value The value to set. Memory for the string is allocated
965: * and the value is copied. Any previous string value is freed.
966: * @param index The index in the option value array that should be
967: * modified. It is an error to set values with indices larger than 0
968: * for options without the CFGF_LIST flag set.
969: */
970: DLLIMPORT void __export cfg_opt_setnstr(cfg_opt_t *opt,
971: const char *value, unsigned int index);
972:
973: /** Set the value of a string option given its name.
974: *
975: * @param cfg The configuration file context.
976: * @param name The name of the option.
977: * @param value The value to set. Memory for the string is allocated and the
978: * value is copied. Any previous string value is freed. If the option is a list
979: * (the CFGF_LIST flag is set), only the first value (with index 0) is set.
980: */
981: DLLIMPORT void __export cfg_setstr(cfg_t *cfg, const char *name,
982: const char *value);
983:
984: /** Set a value of a boolean option given its name and index.
985: *
986: * @param cfg The configuration file context.
987: * @param name The name of the option.
988: * @param value The value to set. Memory for the string is allocated
989: * and the value is copied. Any privious string value is freed.
990: * @param index The index in the option value array that should be
991: * modified. It is an error to set values with indices larger than 0
992: * for options without the CFGF_LIST flag set.
993: */
994: DLLIMPORT void __export cfg_setnstr(cfg_t *cfg, const char *name,
995: const char *value, unsigned int index);
996:
997: /** Set values for a list option. All existing values are replaced
998: * with the new ones.
999: *
1000: * @param cfg The configuration file context.
1001: * @param name The name of the option.
1002: * @param nvalues Number of values to set.
1003: * @param ... The values to set, the type must match the type of the
1004: * option and the number of values must be equal to the nvalues
1005: * parameter.
1006: */
1007: DLLIMPORT void __export cfg_setlist(cfg_t *cfg, const char *name,
1008: unsigned int nvalues, ...);
1009:
1010: DLLIMPORT int __export cfg_numopts(cfg_opt_t *opts);
1011:
1012: /** Add values for a list option. The new values are appended to any
1013: * current values in the list.
1014: *
1015: * @param cfg The configuration file context.
1016: * @param name The name of the option.
1017: * @param nvalues Number of values to add.
1018: * @param ... The values to add, the type must match the type of the
1019: * option and the number of values must be equal to the nvalues
1020: * parameter.
1021: */
1022: DLLIMPORT void __export cfg_addlist(cfg_t *cfg, const char *name,
1023: unsigned int nvalues, ...);
1024:
1025: /** Default value print function.
1026: *
1027: * Print only the value of a given option. Does not handle sections or
1028: * functions. Use cfg_opt_print to print the whole assignment ("option
1029: * = value"), or cfg_print to print the whole config file.
1030: *
1031: * @param opt The option structure (eg, as returned from cfg_getopt())
1032: * @param index The index in the option value array that should be printed
1033: * @param fp File stream to print to.
1034: *
1035: * @see cfg_print, cfg_opt_print
1036: */
1037: DLLIMPORT void __export cfg_opt_nprint_var(cfg_opt_t *opt, unsigned int index,
1038: FILE *fp);
1039:
1040: /** Print an option and its value to a file.
1041: * Same as cfg_opt_print, but with the indentation level specified.
1042: * @see cfg_opt_print
1043: */
1044: DLLIMPORT void __export cfg_opt_print_indent(cfg_opt_t *opt, FILE *fp, int indent);
1045:
1046: /** Print an option and its value to a file.
1047: *
1048: * If a print callback function is specified for the option, it is
1049: * used instead of cfg_opt_nprint_var.
1050: *
1051: * @param opt The option structure (eg, as returned from cfg_getopt())
1052: * @param fp File stream to print to.
1053: *
1054: * @see cfg_print_func_t
1055: */
1056: DLLIMPORT void __export cfg_opt_print(cfg_opt_t *opt, FILE *fp);
1057:
1058: /** Print the options and values to a file.
1059: * Same as cfg_print, but with the indentation level specified.
1060: * @see cfg_print
1061: */
1062: DLLIMPORT void __export cfg_print_indent(cfg_t *cfg, FILE *fp, int indent);
1063:
1064: /** Print the options and values to a file.
1065: *
1066: * Note that options in any included file are expanded and printed
1067: * directly to the file. Option values given with environment
1068: * variables in the parsed input are also printed expanded. This means
1069: * that if you parse a configuration file you can't expect that the
1070: * output from this function is identical to the initial file.
1071: *
1072: * @param cfg The configuration file context.
1073: * @param fp File stream to print to, use stdout to print to the screen.
1074: *
1075: * @see cfg_print_func_t, cfg_set_print_func
1076: */
1077: DLLIMPORT void __export cfg_print(cfg_t *cfg, FILE *fp);
1078:
1079: /** Set a print callback function for an option.
1080: *
1081: * @param opt The option structure (eg, as returned from cfg_getopt())
1082: * @param pf The print function callback.
1083: *
1084: * @see cfg_print_func_t
1085: */
1086: DLLIMPORT cfg_print_func_t __export cfg_opt_set_print_func(cfg_opt_t *opt,
1087: cfg_print_func_t pf);
1088:
1089: /** Set a print callback function for an option given its name.
1090: *
1091: * @param cfg The configuration file context.
1092: * @param name The name of the option.
1093: * @param pf The print callback function.
1094: *
1095: * @see cfg_print_func_t
1096: */
1097: DLLIMPORT cfg_print_func_t __export cfg_set_print_func(cfg_t *cfg, const char *name,
1098: cfg_print_func_t pf);
1099:
1100: /** Register a validating callback function for an option.
1101: *
1102: * @param cfg The configuration file context.
1103: * @param name The name of the option.
1104: * @param vf The validating callback function.
1105: *
1106: * @see cfg_validate_callback_t
1107: */
1108: DLLIMPORT cfg_validate_callback_t __export cfg_set_validate_func(cfg_t *cfg,
1109: const char *name,
1110: cfg_validate_callback_t vf);
1111:
1112: #ifdef __cplusplus
1113: }
1114: #endif
1115:
1116: #endif
1117:
1118: /** @example ftpconf.c
1119: */
1120:
1121: /** @example simple.c
1122: */
1123:
1124: /** @example reread.c
1125: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to confuse.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / confuse / src