1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
|
/*
-------------------------------------------------------------------
cfgparse.h - Generic Config File and Argument Parser
-------------------------------------------------------------------
* Copyright (C) 2001, David Olofson
*
* This code is released under the terms of the GNU LGPL.
*/
#ifndef CFGPARSE_H
#define CFGPARSE_H
#include <stdio.h>
enum cfg_types_t
{
CFG_NONE,
CFG_BOOL,
CFG_INT,
CFG_FLOAT,
CFG_STRING
};
#define CFG_STRING_LENGTH 256
typedef char cfg_string_t[CFG_STRING_LENGTH];
class cfg_key_t
{
public:
cfg_key_t *next;
int save;
int redefined;
cfg_types_t typecode;
const char *name;
char *description;
cfg_key_t();
virtual ~cfg_key_t();
virtual int copy(cfg_key_t *from);
virtual int test(const char *arg);
virtual int read(int argc, char *argv[]);
virtual void write(FILE *f);
virtual void set_default();
virtual int is_your_var(void *var);
};
class cfg_comment_t : public cfg_key_t
{
public:
cfg_comment_t(const char *text) { name = text; }
int test(const char *arg) { return 0; }
void write(FILE *f);
void set_default() { ; }
};
class cfg_switch_t : public cfg_key_t
{
public:
int *value;
int default_value;
cfg_switch_t(const char *_name, int &var, int def, int _save);
int copy(cfg_key_t *from);
virtual int test(const char *arg);
int read(int argc, char *argv[]);
void write(FILE *f);
void set_default();
int is_your_var(void *var);
};
class cfg_key_int_t : public cfg_key_t
{
public:
int *value;
int default_value;
cfg_key_int_t(const char *_name, int &var, int def, int _save);
int copy(cfg_key_t *from);
int read(int argc, char *argv[]);
void write(FILE *f);
void set_default();
int is_your_var(void *var);
};
class cfg_key_float_t : public cfg_key_t
{
public:
float *value;
float default_value;
cfg_key_float_t(const char *_name, float &var, float def, int _save);
int copy(cfg_key_t *from);
int read(int argc, char *argv[]);
void write(FILE *f);
void set_default();
int is_your_var(void *var);
};
class cfg_key_string_t : public cfg_key_t
{
public:
cfg_string_t *value;
cfg_string_t default_value;
cfg_key_string_t(const char *_name, cfg_string_t &var,
const cfg_string_t def, int _save);
int copy(cfg_key_t *from);
int read(int argc, char *argv[]);
void write(FILE *f);
void set_default();
int is_your_var(void *var);
};
class config_parser_t
{
cfg_key_t *keys, *last_key;
int initialized;
int nkeys; // For symbol table API
cfg_key_t **table; // For symbol table API
cfg_string_t retbuf; // For symbol table API
void initialize();
void print_switch(FILE *f, const char *base, int flag);
int read_config(char ***cv, FILE *f);
void add(cfg_key_t *_key);
int _redefined(void *var);
void _accept(void *var);
void build_table();
int check_symbol(int symbol);
protected:
//Key registration: For use in inherited init()
void comment(const char *text);
void yesno(const char *name, int &var, int def, int save = 1);
void command(const char *name, int &var);
void key(const char *name, int &var, int def, int save = 1);
void key(const char *name, float &var, float def, int save = 1);
void key(const char *name, cfg_string_t &var, const cfg_string_t def,
int save = 1);
void desc(const char *text);
//Plug key registration and custom stuff in here!
virtual void init() = 0;
virtual void postload() { ; }
virtual void presave() { ; }
public:
int changed; //Set when *edited* by the user
config_parser_t();
virtual ~config_parser_t();
config_parser_t &operator = (config_parser_t &from);
void set_defaults();
int parse(int argc, char *argv[]);
int read(FILE *f);
int write(FILE *f);
//Changed since last accept() call?
int redefined(int &var) { return _redefined(&var); }
int redefined(float &var) { return _redefined(&var); }
int redefined(cfg_string_t &var) { return _redefined(&var); }
//Reset redefined() state to 0.
void accept(int &var) { _accept(&var); }
void accept(float &var) { _accept(&var); }
void accept(cfg_string_t &var) { _accept(&var); }
/* Generic Symbol Table Style API */
int find(const char *name);
int find_next(int symbol = -1);
cfg_types_t type(int symbol);
const char *name(int symbol);
const char *description(int symbol);
void set(int symbol, int value);
void set(int symbol, float value);
void set(int symbol, const char *text);
int get_i(int symbol);
float get_f(int symbol);
/*
* WARNING: This one sometimes returns a pointer to a non-constant
* buffer! Therefore, you need to copy the returned string
* before you call this function again.
*/
const char *get_s(int symbol);
};
#endif //CFGPARSE_H
|
