confuse.h

Go to the documentation of this file.

/* Configuration file parser -*- tab-width: 4; -*-
 *
 * $Id: confuse_8h-source.html,v 1.4 2004/05/23 09:48:31 mhe Exp $
 *
 * Copyright (c) 2002-2003, Martin Hedenfalk <[email protected]>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
 */

#ifndef _cfg_h_
#define _cfg_h_

#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h>
#include <stdarg.h>

#ifdef _WIN32

# ifdef HAVE__FILENO
#  define fileno _fileno
# endif
# include <io.h>
# ifdef HAVE__ISATTY
#  define isatty _isatty
# endif

# ifdef BUILDING_DLL
#  define DLLIMPORT __declspec (dllexport)
# else /* Not BUILDING_DLL */
#  define DLLIMPORT __declspec (dllimport)
# endif /* Not BUILDING_DLL */

#else /* ! _WIN32 */
# 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     
};
typedef enum cfg_type_t cfg_type_t;

#define CFGF_NONE 0
#define CFGF_MULTI 1       
#define CFGF_LIST 2        
#define CFGF_NOCASE 4      
#define CFGF_TITLE 8       
#define CFGF_RESET 32
#define CFGF_DEFINIT 64

#define CFG_SUCCESS 0
#define CFG_FILE_ERROR -1
#define CFG_PARSE_ERROR 1

typedef union cfg_value_t cfg_value_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 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 enum {cfg_false, cfg_true} cfg_bool_t;

typedef void (*cfg_errfunc_t)(cfg_t *cfg, const char *fmt, va_list ap);

struct cfg_t {
    cfg_flag_t flags;       
    char *name;             
    cfg_opt_t *opts;        
    char *title;            
    char *filename;         
    int line;               
    cfg_errfunc_t errfunc;  
};

union cfg_value_t {
    long int number;        
    double fpnumber;        
    cfg_bool_t boolean;     
    char *string;           
    cfg_t *section;         
};

struct cfg_defvalue_t {
    long int number;        
    double fpnumber;        
    cfg_bool_t boolean;     
    char *string;           
    char *parsed;           
};

struct cfg_opt_t {
    char *name;             
    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;        
    void *simple_value;     
    cfg_callback_t parsecb; 
    cfg_validate_callback_t validcb; 
    cfg_print_func_t pf;    
};

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,CFGT_STR,0,0,flags,0,{0,0,cfg_false,def,0},0,svalue,cb,0,0}
#define __CFG_STR_LIST(name, def, flags, svalue, cb) \
  {name,CFGT_STR,0,0,flags | CFGF_LIST,0,{0,0,cfg_false,0,def},0,svalue,cb,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,CFGT_INT,0,0,flags,0,{def,0,cfg_false,0,0},0,svalue,cb,0,0}
#define __CFG_INT_LIST(name, def, flags, svalue, cb) \
  {name,CFGT_INT,0,0,flags | CFGF_LIST,0,{0,0,cfg_false,0,def},0,svalue,cb,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,CFGT_FLOAT,0,0,flags,0,{0,def,cfg_false,0,0},0,svalue,cb,0,0}
#define __CFG_FLOAT_LIST(name, def, flags, svalue, cb) \
  {name,CFGT_FLOAT,0,0,flags | CFGF_LIST,0,{0,0,cfg_false,0,def},0,svalue,cb,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,CFGT_BOOL,0,0,flags,0,{0,0,def,0,0},0,svalue,cb,0,0}
#define __CFG_BOOL_LIST(name, def, flags, svalue, cb) \
  {name,CFGT_BOOL,0,0,flags | CFGF_LIST,0,{0,0,cfg_false,0,def},0,svalue,cb,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,CFGT_SEC,0,0,flags,opts,{0,0,cfg_false,0,0},0,0,0,0,0}



#define CFG_FUNC(name, func) \
  {name,CFGT_FUNC,0,0,CFGF_NONE,0,{0,0,cfg_false,0,0},func,0,0,0,0}



#define CFG_END() \
   {0,CFGT_NONE,0,0,CFGF_NONE,0,{0,0,cfg_false,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_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 void __export cfg_free_value(cfg_opt_t *opt);

DLLIMPORT void __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 signed long 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 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 *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 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 cfg_t *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 *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 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 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 * __export cfg_getopt(cfg_t *cfg, const char *name);

DLLIMPORT void __export cfg_opt_setnint(cfg_opt_t *opt,
                                        long int value, unsigned int index);

DLLIMPORT void __export cfg_setint(cfg_t *cfg, const char *name,
                                   long int value);

DLLIMPORT void __export cfg_setnint(cfg_t *cfg, const char *name,
                                    long int value, unsigned int index);

DLLIMPORT void __export cfg_opt_setnfloat(cfg_opt_t *opt,
                                          double value, unsigned int index);

DLLIMPORT void __export cfg_setfloat(cfg_t *cfg, const char *name,
                                     double value);

DLLIMPORT void __export cfg_setnfloat(cfg_t *cfg, const char *name,
                                      double value, unsigned int index);

DLLIMPORT void __export cfg_opt_setnbool(cfg_opt_t *opt,
                                         cfg_bool_t value, unsigned int index);

DLLIMPORT void __export cfg_setbool(cfg_t *cfg, const char *name,
                                    cfg_bool_t value);

DLLIMPORT void __export cfg_setnbool(cfg_t *cfg, const char *name,
                                     cfg_bool_t value, unsigned int index);

DLLIMPORT void __export cfg_opt_setnstr(cfg_opt_t *opt,
                                        const char *value, unsigned int index);

DLLIMPORT void __export cfg_setstr(cfg_t *cfg, const char *name,
                                   const char *value);

DLLIMPORT void __export cfg_setnstr(cfg_t *cfg, const char *name,
                                    const char *value, unsigned int index);

DLLIMPORT void __export cfg_setlist(cfg_t *cfg, const char *name,
                                    unsigned int nvalues, ...);


DLLIMPORT void __export cfg_addlist(cfg_t *cfg, const char *name,
                                    unsigned int nvalues, ...);

DLLIMPORT void cfg_opt_nprint_var(cfg_opt_t *opt, unsigned int index,
                                  FILE *fp);

DLLIMPORT void cfg_opt_print_indent(cfg_opt_t *opt, FILE *fp, int indent);

DLLIMPORT void cfg_opt_print(cfg_opt_t *opt, FILE *fp);

DLLIMPORT void cfg_print_indent(cfg_t *cfg, FILE *fp, int indent);

DLLIMPORT void cfg_print(cfg_t *cfg, FILE *fp);

DLLIMPORT cfg_print_func_t cfg_opt_set_print_func(cfg_opt_t *opt,
                                                  cfg_print_func_t pf);

DLLIMPORT cfg_print_func_t cfg_set_print_func(cfg_t *cfg, const char *name,
                                              cfg_print_func_t pf);

DLLIMPORT cfg_validate_callback_t cfg_set_validate_func(cfg_t *cfg,
                                                        const char *name,
                                                        cfg_validate_callback_t vf);

#ifdef __cplusplus
}
#endif

#endif