confuse.h

Go to the documentation of this file.

/*
 * Copyright (c) 2002-2017  Martin Hedenfalk <martin@bzero.se>
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#ifndef CONFUSE_H_
#define CONFUSE_H_
 
#ifdef __cplusplus
extern "C" {
#endif
 
#include <stdio.h>
#include <stdarg.h>
 
#if defined(_WIN32) && !defined(__GNUC__)
# ifdef HAVE__FILENO
#  define fileno _fileno
# endif
# include <io.h>
# ifdef HAVE__ISATTY
#  define isatty _isatty
# endif
# ifdef BUILDING_STATIC
#  define DLLIMPORT
# else /* ! BUILDING_STATIC */
#  ifdef BUILDING_DLL
#   define DLLIMPORT __declspec (dllexport)
#  else /* ! BUILDING_DLL */
#   define DLLIMPORT __declspec (dllimport)
#  endif /* BUILDING_DLL */
# endif /* BUILDING_STATIC */
#else /* ! _WIN32 || __GNUC__ */
# define DLLIMPORT
#endif /* _WIN32 */
 
#ifndef __BORLANDC__
# define __export
#endif
 
enum cfg_type_t {
    CFGT_NONE,
    CFGT_INT,    
    CFGT_FLOAT,  
    CFGT_STR,    
    CFGT_BOOL,   
    CFGT_SEC,    
    CFGT_FUNC,   
    CFGT_PTR,    
    CFGT_COMMENT 
};
typedef enum cfg_type_t cfg_type_t;
 
#define CFGF_NONE           (0)
#define CFGF_MULTI          (1 <<  0) 
#define CFGF_LIST           (1 <<  1) 
#define CFGF_NOCASE         (1 <<  2) 
#define CFGF_TITLE          (1 <<  3) 
#define CFGF_NODEFAULT      (1 <<  4) 
#define CFGF_NO_TITLE_DUPES (1 <<  5) 
#define CFGF_RESET          (1 <<  6)
#define CFGF_DEFINIT        (1 <<  7)
#define CFGF_IGNORE_UNKNOWN (1 <<  8) 
#define CFGF_DEPRECATED     (1 <<  9) 
#define CFGF_DROP           (1 << 10) 
#define CFGF_COMMENTS       (1 << 11) 
#define CFGF_MODIFIED       (1 << 12) 
#define CFGF_KEYSTRVAL      (1 << 13) 
#define CFG_SUCCESS     0
#define CFG_FAIL       -1
#define CFG_FILE_ERROR -1
#define CFG_PARSE_ERROR 1
 
typedef union cfg_value_t cfg_value_t;
typedef union cfg_simple_t cfg_simple_t;
typedef struct cfg_opt_t cfg_opt_t;
typedef struct cfg_t cfg_t;
typedef struct cfg_defvalue_t cfg_defvalue_t;
typedef int cfg_flag_t;
typedef struct cfg_searchpath_t cfg_searchpath_t;
 
typedef int (*cfg_func_t)(cfg_t *cfg, cfg_opt_t *opt, int argc, const char **argv);
 
typedef void (*cfg_print_func_t)(cfg_opt_t *opt, unsigned int index, FILE *fp);
 
typedef int (*cfg_callback_t)(cfg_t *cfg, cfg_opt_t *opt, const char *value, void *result);
 
typedef int (*cfg_validate_callback_t)(cfg_t *cfg, cfg_opt_t *opt);
 
typedef int (*cfg_validate_callback2_t)(cfg_t *cfg, cfg_opt_t *opt, void *value);
 
typedef void (*cfg_free_func_t)(void *value);
 
typedef enum { cfg_false, cfg_true } cfg_bool_t;
 
typedef void (*cfg_errfunc_t)(cfg_t *cfg, const char *fmt, va_list ap);
 
typedef int (*cfg_print_filter_func_t)(cfg_t *cfg, cfg_opt_t *opt);
 
struct cfg_t {
    cfg_flag_t flags;   
    char *name;     
    char *comment;          
    cfg_opt_t *opts;        
    char *title;            
    char *filename;     
    int line;       
    cfg_errfunc_t errfunc;  
    cfg_searchpath_t *path; 
    cfg_print_filter_func_t pff; 
};
 
union cfg_value_t {
    long int number;    
    double fpnumber;    
    cfg_bool_t boolean; 
    char *string;       
    cfg_t *section;     
    void *ptr;      
};
 
union cfg_simple_t {
    long int *number;
    double *fpnumber;
    cfg_bool_t *boolean;
    char **string;
    void **ptr;
};
 
struct cfg_defvalue_t {
    long int number;    
    double fpnumber;    
    cfg_bool_t boolean; 
    const char *string; 
    char *parsed;       
};
 
struct cfg_opt_t {
    const char *name;   
    char *comment;          
    cfg_type_t type;    
    unsigned int nvalues;   
    cfg_value_t **values;   
    cfg_flag_t flags;   
    cfg_opt_t *subopts; 
    cfg_defvalue_t def; 
    cfg_func_t func;    
    cfg_simple_t simple_value;  
    cfg_callback_t parsecb; 
    cfg_validate_callback_t  validcb;  
    cfg_validate_callback2_t validcb2; 
    cfg_print_func_t pf;    
    cfg_free_func_t freecb; /***< user-defined memory release function */
};
 
extern const char __export confuse_copyright[];
extern const char __export confuse_version[];
extern const char __export confuse_author[];
 
#define __CFG_STR(name, def, flags, svalue, cb) \
  {name,0,CFGT_STR,0,0,flags,0,{0,0,cfg_false,def,0},0,{.string=svalue},cb,0,0,0,0}
#define __CFG_STR_LIST(name, def, flags, svalue, cb) \
  {name,0,CFGT_STR,0,0,flags | CFGF_LIST,0,{0,0,cfg_false,0,def},0,{.string=svalue},cb,0,0,0,0}
 
#define CFG_STR(name, def, flags) \
  __CFG_STR(name, def, flags, 0, 0)
 
#define CFG_STR_LIST(name, def, flags) \
  __CFG_STR_LIST(name, def, flags, 0, 0)
 
#define CFG_STR_CB(name, def, flags, cb) \
  __CFG_STR(name, def, flags, 0, cb)
 
#define CFG_STR_LIST_CB(name, def, flags, cb) \
  __CFG_STR_LIST(name, def, flags, 0, cb)
 
#define CFG_SIMPLE_STR(name, svalue) \
  __CFG_STR(name, 0, CFGF_NONE, svalue, 0)
 
 
#define __CFG_INT(name, def, flags, svalue, cb) \
  {name,0,CFGT_INT,0,0,flags,0,{def,0,cfg_false,0,0},0,{.number=svalue},cb,0,0,0,0}
#define __CFG_INT_LIST(name, def, flags, svalue, cb) \
  {name,0,CFGT_INT,0,0,flags | CFGF_LIST,0,{0,0,cfg_false,0,def},0,{.number=svalue},cb,0,0,0,0}
 
#define CFG_INT(name, def, flags) \
  __CFG_INT(name, def, flags, 0, 0)
 
#define CFG_INT_LIST(name, def, flags) \
  __CFG_INT_LIST(name, def, flags, 0, 0)
 
#define CFG_INT_CB(name, def, flags, cb) \
  __CFG_INT(name, def, flags, 0, cb)
 
#define CFG_INT_LIST_CB(name, def, flags, cb) \
  __CFG_INT_LIST(name, def, flags, 0, cb)
 
#define CFG_SIMPLE_INT(name, svalue) \
  __CFG_INT(name, 0, CFGF_NONE, svalue, 0)
 
 
 
#define __CFG_FLOAT(name, def, flags, svalue, cb) \
  {name,0,CFGT_FLOAT,0,0,flags,0,{0,def,cfg_false,0,0},0,{.fpnumber=svalue},cb,0,0,0,0}
#define __CFG_FLOAT_LIST(name, def, flags, svalue, cb) \
  {name,0,CFGT_FLOAT,0,0,flags | CFGF_LIST,0,{0,0,cfg_false,0,def},0,{.fpnumber=svalue},cb,0,0,0,0}
 
#define CFG_FLOAT(name, def, flags) \
  __CFG_FLOAT(name, def, flags, 0, 0)
 
#define CFG_FLOAT_LIST(name, def, flags) \
  __CFG_FLOAT_LIST(name, def, flags, 0, 0)
 
#define CFG_FLOAT_CB(name, def, flags, cb) \
  __CFG_FLOAT(name, def, flags, 0, cb)
 
#define CFG_FLOAT_LIST_CB(name, def, flags, cb) \
  __CFG_FLOAT_LIST(name, def, flags, 0, cb)
 
#define CFG_SIMPLE_FLOAT(name, svalue) \
  __CFG_FLOAT(name, 0, CFGF_NONE, svalue, 0)
 
 
 
#define __CFG_BOOL(name, def, flags, svalue, cb) \
  {name,0,CFGT_BOOL,0,0,flags,0,{0,0,def,0,0},0,{.boolean=svalue},cb,0,0,0,0}
#define __CFG_BOOL_LIST(name, def, flags, svalue, cb) \
  {name,0,CFGT_BOOL,0,0,flags | CFGF_LIST,0,{0,0,cfg_false,0,def},0,{.boolean=svalue},cb,0,0,0,0}
 
#define CFG_BOOL(name, def, flags) \
  __CFG_BOOL(name, def, flags, 0, 0)
 
#define CFG_BOOL_LIST(name, def, flags) \
  __CFG_BOOL_LIST(name, def, flags, 0, 0)
 
#define CFG_BOOL_CB(name, def, flags, cb) \
  __CFG_BOOL(name, def, flags, 0, cb)
 
#define CFG_BOOL_LIST_CB(name, def, flags, cb) \
  __CFG_BOOL_LIST(name, def, flags, 0, cb)
 
#define CFG_SIMPLE_BOOL(name, svalue) \
  __CFG_BOOL(name, cfg_false, CFGF_NONE, svalue, 0)
 
 
 
#define CFG_SEC(name, opts, flags) \
  {name,0,CFGT_SEC,0,0,flags,opts,{0,0,cfg_false,0,0},0,{0},0,0,0,0,0}
 
 
 
#define CFG_FUNC(name, func) \
  {name,0,CFGT_FUNC,0,0,CFGF_NONE,0,{0,0,cfg_false,0,0},func,{0},0,0,0,0,0}
 
 
#define __CFG_PTR(name, def, flags, svalue, parsecb, freecb) \
  {name,0,CFGT_PTR,0,0,flags,0,{0,0,cfg_false,0,def},0,{.ptr=svalue},parsecb,0,0,0,freecb}
#define __CFG_PTR_LIST(name, def, flags, svalue, parsecb, freecb) \
  {name,0,CFGT_PTR,0,0,flags | CFGF_LIST,0,{0,0,cfg_false,0,def},0,{.ptr=svalue},parsecb,0,0,0,freecb}
 
#define CFG_PTR_CB(name, def, flags, parsecb, freecb) \
  __CFG_PTR(name, def, flags, 0, parsecb, freecb)
 
#define CFG_PTR_LIST_CB(name, def, flags, parsecb, freecb) \
  __CFG_PTR(name, def, flags | CFGF_LIST, 0, parsecb, freecb)
 
/*#define CFG_SIMPLE_PTR(name, svalue, cb) \
  __CFG_PTR(name, 0, 0, svalue, cb)*/
 
 
#define CFG_END() \
  {0,0,CFGT_NONE,0,0,CFGF_NONE,0,{0,0,cfg_false,0,0},0,{0},0,0,0,0,0}
 
 
 
DLLIMPORT cfg_t *__export cfg_init(cfg_opt_t *opts, cfg_flag_t flags);
 
DLLIMPORT int __export cfg_add_searchpath(cfg_t *cfg, const char *dir);
 
DLLIMPORT char *__export cfg_searchpath(cfg_searchpath_t *path, const char *file);
 
DLLIMPORT int __export cfg_parse(cfg_t *cfg, const char *filename);
 
DLLIMPORT int __export cfg_parse_fp(cfg_t *cfg, FILE *fp);
 
DLLIMPORT int __export cfg_parse_buf(cfg_t *cfg, const char *buf);
 
DLLIMPORT int __export cfg_free_value(cfg_opt_t *opt);
 
DLLIMPORT int __export cfg_free(cfg_t *cfg);
 
DLLIMPORT cfg_errfunc_t __export cfg_set_error_function(cfg_t *cfg, cfg_errfunc_t errfunc);
 
DLLIMPORT void __export cfg_error(cfg_t *cfg, const char *fmt, ...);
 
DLLIMPORT char * __export cfg_opt_getcomment(cfg_opt_t *opt);
 
DLLIMPORT char * __export cfg_getcomment(cfg_t *cfg, const char *name);
 
DLLIMPORT signed long __export cfg_opt_getnint(cfg_opt_t *opt, unsigned int index);
 
DLLIMPORT long int __export cfg_getnint(cfg_t *cfg, const char *name, unsigned int index);
 
DLLIMPORT long int __export cfg_getint(cfg_t *cfg, const char *name);
 
DLLIMPORT double __export cfg_opt_getnfloat(cfg_opt_t *opt, unsigned int index);
 
DLLIMPORT double __export cfg_getnfloat(cfg_t *cfg, const char *name, unsigned int index);
 
DLLIMPORT double __export cfg_getfloat(cfg_t *cfg, const char *name);
 
DLLIMPORT char *__export cfg_opt_getnstr(cfg_opt_t *opt, unsigned int index);
 
DLLIMPORT char *__export cfg_getnstr(cfg_t *cfg, const char *name, unsigned int index);
 
DLLIMPORT char *__export cfg_getstr(cfg_t *cfg, const char *name);
 
DLLIMPORT cfg_bool_t __export cfg_opt_getnbool(cfg_opt_t *opt, unsigned int index);
 
DLLIMPORT cfg_bool_t __export cfg_getnbool(cfg_t *cfg, const char *name, unsigned int index);
 
DLLIMPORT cfg_bool_t __export cfg_getbool(cfg_t *cfg, const char *name);
 
 
DLLIMPORT void *__export cfg_opt_getnptr(cfg_opt_t *opt, unsigned int index);
DLLIMPORT void *__export cfg_getnptr(cfg_t *cfg, const char *name, unsigned int indx);
 
DLLIMPORT void *__export cfg_getptr(cfg_t *cfg, const char *name);
 
 
DLLIMPORT cfg_t *__export cfg_opt_getnsec(cfg_opt_t *opt, unsigned int index);
 
DLLIMPORT cfg_t *__export cfg_getnsec(cfg_t *cfg, const char *name, unsigned int index);
 
DLLIMPORT cfg_t *__export cfg_opt_gettsec(cfg_opt_t *opt, const char *title);
 
DLLIMPORT cfg_t *__export cfg_gettsec(cfg_t *cfg, const char *name, const char *title);
 
DLLIMPORT cfg_t *__export cfg_getsec(cfg_t *cfg, const char *name);
 
DLLIMPORT unsigned int __export cfg_opt_size(cfg_opt_t *opt);
 
DLLIMPORT unsigned int __export cfg_size(cfg_t *cfg, const char *name);
 
DLLIMPORT const char *__export cfg_title(cfg_t *cfg);
 
DLLIMPORT const char *__export cfg_name(cfg_t *cfg);
 
DLLIMPORT const char *__export cfg_opt_name(cfg_opt_t *opt);
 
DLLIMPORT const char *cfg_opt_getstr(cfg_opt_t *opt);
 
DLLIMPORT int __export cfg_include(cfg_t *cfg, cfg_opt_t *opt, int argc, const char **argv);
 
DLLIMPORT char *__export cfg_tilde_expand(const char *filename);
 
DLLIMPORT int __export cfg_parse_boolean(const char *s);
 
DLLIMPORT cfg_opt_t *cfg_getnopt(cfg_t *cfg, unsigned int index);
 
DLLIMPORT cfg_opt_t *__export cfg_getopt(cfg_t *cfg, const char *name);
 
DLLIMPORT cfg_value_t *cfg_setopt(cfg_t *cfg, cfg_opt_t *opt, const char *value);
 
DLLIMPORT int __export cfg_opt_setcomment(cfg_opt_t *opt, char *comment);
 
DLLIMPORT int __export cfg_setcomment(cfg_t *cfg, const char *name, char *comment);
 
DLLIMPORT int __export cfg_opt_setnint(cfg_opt_t *opt, long int value, unsigned int index);
 
DLLIMPORT int __export cfg_setint(cfg_t *cfg, const char *name, long int value);
 
DLLIMPORT int __export cfg_setnint(cfg_t *cfg, const char *name, long int value, unsigned int index);
 
DLLIMPORT int __export cfg_opt_setnfloat(cfg_opt_t *opt, double value, unsigned int index);
 
DLLIMPORT int __export cfg_setfloat(cfg_t *cfg, const char *name, double value);
 
DLLIMPORT int __export cfg_setnfloat(cfg_t *cfg, const char *name, double value, unsigned int index);
 
DLLIMPORT int __export cfg_opt_setnbool(cfg_opt_t *opt, cfg_bool_t value, unsigned int index);
 
DLLIMPORT int __export cfg_setbool(cfg_t *cfg, const char *name, cfg_bool_t value);
 
DLLIMPORT int __export cfg_setnbool(cfg_t *cfg, const char *name, cfg_bool_t value, unsigned int index);
 
DLLIMPORT int __export cfg_opt_setnstr(cfg_opt_t *opt, const char *value, unsigned int index);
 
DLLIMPORT int __export cfg_setstr(cfg_t *cfg, const char *name, const char *value);
 
DLLIMPORT int __export cfg_setnstr(cfg_t *cfg, const char *name, const char *value, unsigned int index);
 
DLLIMPORT int __export cfg_setlist(cfg_t *cfg, const char *name, unsigned int nvalues, ...);
 
DLLIMPORT int __export cfg_numopts(cfg_opt_t *opts);
 
DLLIMPORT unsigned int __export cfg_num(cfg_t *cfg);
 
DLLIMPORT int __export cfg_addlist(cfg_t *cfg, const char *name, unsigned int nvalues, ...);
 
DLLIMPORT int cfg_opt_setmulti(cfg_t *cfg, cfg_opt_t *opt, unsigned int nvalues, char **values);
 
DLLIMPORT int cfg_setmulti(cfg_t *cfg, const char *name, unsigned int nvalues, char **values);
 
DLLIMPORT cfg_t *cfg_addtsec(cfg_t *cfg, const char *name, const char *title);
 
DLLIMPORT int __export cfg_opt_rmnsec(cfg_opt_t *opt, unsigned int index);
 
DLLIMPORT int __export cfg_rmnsec(cfg_t *cfg, const char *name, unsigned int index);
 
DLLIMPORT int __export cfg_rmsec(cfg_t *cfg, const char *name);
 
DLLIMPORT int __export cfg_opt_rmtsec(cfg_opt_t *opt, const char *title);
 
DLLIMPORT int __export cfg_rmtsec(cfg_t *cfg, const char *name, const char *title);
 
DLLIMPORT int __export cfg_opt_nprint_var(cfg_opt_t *opt, unsigned int index, FILE *fp);
 
DLLIMPORT int __export cfg_opt_print_indent(cfg_opt_t *opt, FILE *fp, int indent);
 
DLLIMPORT int __export cfg_opt_print(cfg_opt_t *opt, FILE *fp);
 
DLLIMPORT int __export cfg_print_indent(cfg_t *cfg, FILE *fp, int indent);
 
DLLIMPORT int __export cfg_print(cfg_t *cfg, FILE *fp);
 
DLLIMPORT cfg_print_func_t __export cfg_opt_set_print_func(cfg_opt_t *opt, cfg_print_func_t pf);
 
DLLIMPORT cfg_print_func_t __export cfg_set_print_func(cfg_t *cfg, const char *name, cfg_print_func_t pf);
 
DLLIMPORT cfg_print_filter_func_t __export cfg_set_print_filter_func(cfg_t *cfg, cfg_print_filter_func_t pff);
 
DLLIMPORT cfg_validate_callback_t __export cfg_set_validate_func(cfg_t *cfg, const char *name, cfg_validate_callback_t vf);
 
DLLIMPORT cfg_validate_callback2_t __export cfg_set_validate_func2(cfg_t *cfg, const char *name, cfg_validate_callback2_t vf);
 
#ifdef __cplusplus
}
#endif
#endif /* CONFUSE_H_ */