include/isl/arg.h

/*
 * Copyright 2008-2009 Katholieke Universiteit Leuven
 *
 * Use of this software is governed by the MIT license
 *
 * Written by Sven Verdoolaege, K.U.Leuven, Departement
 * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
 */

#ifndef ISL_ARG_H
#define ISL_ARG_H

#include <stddef.h>
#include <stdlib.h>

#if defined(__cplusplus)
extern "C" {
#endif

struct isl_arg_choice {
        const char      *name;
        unsigned         value;
};

struct isl_arg_flags {
        const char      *name;
        unsigned         mask;
        unsigned         value;
};

enum isl_arg_type {
        isl_arg_end,
        isl_arg_alias,
        isl_arg_arg,
        isl_arg_bool,
        isl_arg_child,
        isl_arg_choice,
        isl_arg_flags,
        isl_arg_footer,
        isl_arg_int,
        isl_arg_user,
        isl_arg_long,
        isl_arg_ulong,
        isl_arg_str,
        isl_arg_str_list,
        isl_arg_version
};

struct isl_args;

struct isl_arg {
        enum isl_arg_type        type;
        char                     short_name;
        const char              *long_name;
        const char              *argument_name;
#define ISL_ARG_OFFSET_NONE     ((size_t) -1)
        size_t                   offset;
        const char              *help_msg;
#define ISL_ARG_SINGLE_DASH     (1 << 0)
#define ISL_ARG_BOOL_ARG        (1 << 1)
#define ISL_ARG_HIDDEN          (1 << 2)
        unsigned                 flags;
        union {
        struct {
                struct isl_arg_choice   *choice;
                unsigned                 default_value;
                unsigned                 default_selected;
                int (*set)(void *opt, unsigned val);
        } choice;
        struct {
                struct isl_arg_flags    *flags;
                unsigned                 default_value;
        } flags;
        struct {
                unsigned                 default_value;
                int (*set)(void *opt, unsigned val);
        } b;
        struct {
                int                     default_value;
        } i;
        struct {
                long                    default_value;
                long                    default_selected;
                int (*set)(void *opt, long val);
        } l;
        struct {
                unsigned long           default_value;
        } ul;
        struct {
                const char              *default_value;
        } str;
        struct {
                size_t                   offset_n;
        } str_list;
        struct {
                struct isl_args         *child;
        } child;
        struct {
                void (*print_version)(void);
        } version;
        struct {
                int (*init)(void*);
                void (*clear)(void*);
        } user;
        } u;
};

struct isl_args {
        size_t                   options_size;
        struct isl_arg          *args;
};

#define ISL_ARGS_START(s,name)                                          \
        struct isl_arg name ## LIST[];                                  \
        struct isl_args name = { sizeof(s), name ## LIST };             \
        struct isl_arg name ## LIST[] = {
#define ISL_ARGS_END                                                    \
        { isl_arg_end } };

#define ISL_ARG_ALIAS(l)        {                                       \
        .type = isl_arg_alias,                                          \
        .long_name = l,                                                 \
},
#define ISL_ARG_ARG(st,f,a,d)   {                                       \
        .type = isl_arg_arg,                                            \
        .argument_name = a,                                             \
        .offset = offsetof(st, f),                                      \
        .u = { .str = { .default_value = d } }                          \
},
#define ISL_ARG_FOOTER(h)       {                                       \
        .type = isl_arg_footer,                                         \
        .help_msg = h,                                                  \
},
#define ISL_ARG_CHOICE(st,f,s,l,c,d,h)  {                               \
        .type = isl_arg_choice,                                         \
        .short_name = s,                                                \
        .long_name = l,                                                 \
        .offset = offsetof(st, f),                                      \
        .help_msg = h,                                                  \
        .u = { .choice = { .choice = c, .default_value = d,             \
                            .default_selected = d, .set = NULL } }      \
},
#define ISL_ARG_OPT_CHOICE(st,f,s,l,c,d,ds,h)   {                       \
        .type = isl_arg_choice,                                         \
        .short_name = s,                                                \
        .long_name = l,                                                 \
        .offset = offsetof(st, f),                                      \
        .help_msg = h,                                                  \
        .u = { .choice = { .choice = c, .default_value = d,             \
                            .default_selected = ds, .set = NULL } }     \
},
#define ISL_ARG_PHANTOM_USER_CHOICE_F(s,l,c,setter,d,h,fl)      {       \
        .type = isl_arg_choice,                                         \
        .short_name = s,                                                \
        .long_name = l,                                                 \
        .offset = ISL_ARG_OFFSET_NONE,                                  \
        .help_msg = h,                                                  \
        .flags = fl,                                                    \
        .u = { .choice = { .choice = c, .default_value = d,             \
                            .default_selected = d, .set = setter } }    \
},
#define ISL_ARG_USER_OPT_CHOICE(st,f,s,l,c,setter,d,ds,h)       {       \
        .type = isl_arg_choice,                                         \
        .short_name = s,                                                \
        .long_name = l,                                                 \
        .offset = offsetof(st, f),                                      \
        .help_msg = h,                                                  \
        .u = { .choice = { .choice = c, .default_value = d,             \
                            .default_selected = ds, .set = setter } }   \
},
#define _ISL_ARG_BOOL_F(o,s,l,setter,d,h,fl)    {                       \
        .type = isl_arg_bool,                                           \
        .short_name = s,                                                \
        .long_name = l,                                                 \
        .offset = o,                                                    \
        .help_msg = h,                                                  \
        .flags = fl,                                                    \
        .u = { .b = { .default_value = d, .set = setter } }             \
},
#define ISL_ARG_BOOL_F(st,f,s,l,d,h,fl)                                 \
        _ISL_ARG_BOOL_F(offsetof(st, f),s,l,NULL,d,h,fl)
#define ISL_ARG_BOOL(st,f,s,l,d,h)                                      \
        ISL_ARG_BOOL_F(st,f,s,l,d,h,0)
#define ISL_ARG_PHANTOM_BOOL_F(s,l,setter,h,fl)                         \
        _ISL_ARG_BOOL_F(ISL_ARG_OFFSET_NONE,s,l,setter,0,h,fl)
#define ISL_ARG_PHANTOM_BOOL(s,l,setter,h)                              \
        ISL_ARG_PHANTOM_BOOL_F(s,l,setter,h,0)
#define ISL_ARG_INT_F(st,f,s,l,a,d,h,fl)        {                       \
        .type = isl_arg_int,                                            \
        .short_name = s,                                                \
        .long_name = l,                                                 \
        .argument_name = a,                                             \
        .offset = offsetof(st, f),                                      \
        .help_msg = h,                                                  \
        .flags = fl,                                                    \
        .u = { .i = { .default_value = d } }                            \
},
#define ISL_ARG_INT(st,f,s,l,a,d,h)                                     \
        ISL_ARG_INT_F(st,f,s,l,a,d,h,0)
#define ISL_ARG_LONG(st,f,s,lo,d,h)     {                               \
        .type = isl_arg_long,                                           \
        .short_name = s,                                                \
        .long_name = lo,                                                \
        .offset = offsetof(st, f),                                      \
        .help_msg = h,                                                  \
        .u = { .l = { .default_value = d, .default_selected = d,        \
                      .set = NULL } }                                   \
},
#define ISL_ARG_USER_LONG(st,f,s,lo,setter,d,h) {                       \
        .type = isl_arg_long,                                           \
        .short_name = s,                                                \
        .long_name = lo,                                                \
        .offset = offsetof(st, f),                                      \
        .help_msg = h,                                                  \
        .u = { .l = { .default_value = d, .default_selected = d,        \
                      .set = setter } }                                 \
},
#define ISL_ARG_OPT_LONG(st,f,s,lo,d,ds,h)      {                       \
        .type = isl_arg_long,                                           \
        .short_name = s,                                                \
        .long_name = lo,                                                \
        .offset = offsetof(st, f),                                      \
        .help_msg = h,                                                  \
        .u = { .l = { .default_value = d, .default_selected = ds,       \
                      .set = NULL } }                                   \
},
#define ISL_ARG_ULONG(st,f,s,l,d,h)     {                               \
        .type = isl_arg_ulong,                                          \
        .short_name = s,                                                \
        .long_name = l,                                                 \
        .offset = offsetof(st, f),                                      \
        .help_msg = h,                                                  \
        .u = { .ul = { .default_value = d } }                           \
},
#define ISL_ARG_STR_F(st,f,s,l,a,d,h,fl)        {                       \
        .type = isl_arg_str,                                            \
        .short_name = s,                                                \
        .long_name = l,                                                 \
        .argument_name = a,                                             \
        .offset = offsetof(st, f),                                      \
        .help_msg = h,                                                  \
        .flags = fl,                                                    \
        .u = { .str = { .default_value = d } }                          \
},
#define ISL_ARG_STR(st,f,s,l,a,d,h)                                     \
        ISL_ARG_STR_F(st,f,s,l,a,d,h,0)
#define ISL_ARG_STR_LIST(st,f_n,f_l,s,l,a,h)    {                       \
        .type = isl_arg_str_list,                                       \
        .short_name = s,                                                \
        .long_name = l,                                                 \
        .argument_name = a,                                             \
        .offset = offsetof(st, f_l),                                    \
        .help_msg = h,                                                  \
        .u = { .str_list = { .offset_n = offsetof(st, f_n) } }          \
},
#define _ISL_ARG_CHILD(o,l,c,h,fl)      {                               \
        .type = isl_arg_child,                                          \
        .long_name = l,                                                 \
        .offset = o,                                                    \
        .help_msg = h,                                                  \
        .flags = fl,                                                    \
        .u = { .child = { .child = c } }                                \
},
#define ISL_ARG_CHILD(st,f,l,c,h)                                       \
        _ISL_ARG_CHILD(offsetof(st, f),l,c,h,0)
#define ISL_ARG_GROUP_F(l,c,h,fl)                                       \
        _ISL_ARG_CHILD(ISL_ARG_OFFSET_NONE,l,c,h,fl)
#define ISL_ARG_GROUP(l,c,h)                                            \
        ISL_ARG_GROUP_F(l,c,h,0)
#define ISL_ARG_FLAGS(st,f,s,l,c,d,h)   {                               \
        .type = isl_arg_flags,                                          \
        .short_name = s,                                                \
        .long_name = l,                                                 \
        .offset = offsetof(st, f),                                      \
        .help_msg = h,                                                  \
        .u = { .flags = { .flags = c, .default_value = d } }            \
},
#define ISL_ARG_USER(st,f,i,c) {                                        \
        .type = isl_arg_user,                                           \
        .offset = offsetof(st, f),                                      \
        .u = { .user = { .init = i, .clear = c} }                       \
},
#define ISL_ARG_VERSION(print) {                                        \
        .type = isl_arg_version,                                        \
        .u = { .version = { .print_version = print } }                  \
},

#define ISL_ARG_ALL             (1 << 0)
#define ISL_ARG_SKIP_HELP       (1 << 1)

void isl_args_set_defaults(struct isl_args *args, void *opt);
void isl_args_free(struct isl_args *args, void *opt);
int isl_args_parse(struct isl_args *args, int argc, char **argv, void *opt,
        unsigned flags);

#define ISL_ARG_DECL(prefix,st,args)                                    \
extern struct isl_args args;                                            \
st *prefix ## _new_with_defaults(void);                                 \
void prefix ## _free(st *opt);                                          \
int prefix ## _parse(st *opt, int argc, char **argv, unsigned flags);

#define ISL_ARG_DEF(prefix,st,args)                                     \
st *prefix ## _new_with_defaults()                                      \
{                                                                       \
        st *opt = (st *)calloc(1, sizeof(st));                          \
        if (opt)                                                        \
                isl_args_set_defaults(&(args), opt);                    \
        return opt;                                                     \
}                                                                       \
                                                                        \
void prefix ## _free(st *opt)                                           \
{                                                                       \
        isl_args_free(&(args), opt);                                    \
}                                                                       \
                                                                        \
int prefix ## _parse(st *opt, int argc, char **argv, unsigned flags)    \
{                                                                       \
        return isl_args_parse(&(args), argc, argv, opt, flags);         \
}

#if defined(__cplusplus)
}
#endif

#endif
Revision:	1166
Committed:	Tue Oct 26 14:22:36 2021 UTC (4 years ago) by rossy
Content type:	text/x-chdr
File size:	8506 byte(s)
Log Message:	Daodan: Replace MinGW build env with an up-to-date MSYS2 env
#	Content
1	/*
2	* Copyright 2008-2009 Katholieke Universiteit Leuven
3	*
4	* Use of this software is governed by the MIT license
5	*
6	* Written by Sven Verdoolaege, K.U.Leuven, Departement
7	* Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
8	*/
9
10	#ifndef ISL_ARG_H
11	#define ISL_ARG_H
12
13	#include <stddef.h>
14	#include <stdlib.h>
15
16	#if defined(__cplusplus)
17	extern "C" {
18	#endif
19
20	struct isl_arg_choice {
21	const char *name;
22	unsigned value;
23	};
24
25	struct isl_arg_flags {
26	const char *name;
27	unsigned mask;
28	unsigned value;
29	};
30
31	enum isl_arg_type {
32	isl_arg_end,
33	isl_arg_alias,
34	isl_arg_arg,
35	isl_arg_bool,
36	isl_arg_child,
37	isl_arg_choice,
38	isl_arg_flags,
39	isl_arg_footer,
40	isl_arg_int,
41	isl_arg_user,
42	isl_arg_long,
43	isl_arg_ulong,
44	isl_arg_str,
45	isl_arg_str_list,
46	isl_arg_version
47	};
48
49	struct isl_args;
50
51	struct isl_arg {
52	enum isl_arg_type type;
53	char short_name;
54	const char *long_name;
55	const char *argument_name;
56	#define ISL_ARG_OFFSET_NONE ((size_t) -1)
57	size_t offset;
58	const char *help_msg;
59	#define ISL_ARG_SINGLE_DASH (1 << 0)
60	#define ISL_ARG_BOOL_ARG (1 << 1)
61	#define ISL_ARG_HIDDEN (1 << 2)
62	unsigned flags;
63	union {
64	struct {
65	struct isl_arg_choice *choice;
66	unsigned default_value;
67	unsigned default_selected;
68	int (set)(void opt, unsigned val);
69	} choice;
70	struct {
71	struct isl_arg_flags *flags;
72	unsigned default_value;
73	} flags;
74	struct {
75	unsigned default_value;
76	int (set)(void opt, unsigned val);
77	} b;
78	struct {
79	int default_value;
80	} i;
81	struct {
82	long default_value;
83	long default_selected;
84	int (set)(void opt, long val);
85	} l;
86	struct {
87	unsigned long default_value;
88	} ul;
89	struct {
90	const char *default_value;
91	} str;
92	struct {
93	size_t offset_n;
94	} str_list;
95	struct {
96	struct isl_args *child;
97	} child;
98	struct {
99	void (*print_version)(void);
100	} version;
101	struct {
102	int (init)(void);
103	void (clear)(void);
104	} user;
105	} u;
106	};
107
108	struct isl_args {
109	size_t options_size;
110	struct isl_arg *args;
111	};
112
113	#define ISL_ARGS_START(s,name) \
114	struct isl_arg name ## LIST[]; \
115	struct isl_args name = { sizeof(s), name ## LIST }; \
116	struct isl_arg name ## LIST[] = {
117	#define ISL_ARGS_END \
118	{ isl_arg_end } };
119
120	#define ISL_ARG_ALIAS(l) { \
121	.type = isl_arg_alias, \
122	.long_name = l, \
123	},
124	#define ISL_ARG_ARG(st,f,a,d) { \
125	.type = isl_arg_arg, \
126	.argument_name = a, \
127	.offset = offsetof(st, f), \
128	.u = { .str = { .default_value = d } } \
129	},
130	#define ISL_ARG_FOOTER(h) { \
131	.type = isl_arg_footer, \
132	.help_msg = h, \
133	},
134	#define ISL_ARG_CHOICE(st,f,s,l,c,d,h) { \
135	.type = isl_arg_choice, \
136	.short_name = s, \
137	.long_name = l, \
138	.offset = offsetof(st, f), \
139	.help_msg = h, \
140	.u = { .choice = { .choice = c, .default_value = d, \
141	.default_selected = d, .set = NULL } } \
142	},
143	#define ISL_ARG_OPT_CHOICE(st,f,s,l,c,d,ds,h) { \
144	.type = isl_arg_choice, \
145	.short_name = s, \
146	.long_name = l, \
147	.offset = offsetof(st, f), \
148	.help_msg = h, \
149	.u = { .choice = { .choice = c, .default_value = d, \
150	.default_selected = ds, .set = NULL } } \
151	},
152	#define ISL_ARG_PHANTOM_USER_CHOICE_F(s,l,c,setter,d,h,fl) { \
153	.type = isl_arg_choice, \
154	.short_name = s, \
155	.long_name = l, \
156	.offset = ISL_ARG_OFFSET_NONE, \
157	.help_msg = h, \
158	.flags = fl, \
159	.u = { .choice = { .choice = c, .default_value = d, \
160	.default_selected = d, .set = setter } } \
161	},
162	#define ISL_ARG_USER_OPT_CHOICE(st,f,s,l,c,setter,d,ds,h) { \
163	.type = isl_arg_choice, \
164	.short_name = s, \
165	.long_name = l, \
166	.offset = offsetof(st, f), \
167	.help_msg = h, \
168	.u = { .choice = { .choice = c, .default_value = d, \
169	.default_selected = ds, .set = setter } } \
170	},
171	#define _ISL_ARG_BOOL_F(o,s,l,setter,d,h,fl) { \
172	.type = isl_arg_bool, \
173	.short_name = s, \
174	.long_name = l, \
175	.offset = o, \
176	.help_msg = h, \
177	.flags = fl, \
178	.u = { .b = { .default_value = d, .set = setter } } \
179	},
180	#define ISL_ARG_BOOL_F(st,f,s,l,d,h,fl) \
181	_ISL_ARG_BOOL_F(offsetof(st, f),s,l,NULL,d,h,fl)
182	#define ISL_ARG_BOOL(st,f,s,l,d,h) \
183	ISL_ARG_BOOL_F(st,f,s,l,d,h,0)
184	#define ISL_ARG_PHANTOM_BOOL_F(s,l,setter,h,fl) \
185	_ISL_ARG_BOOL_F(ISL_ARG_OFFSET_NONE,s,l,setter,0,h,fl)
186	#define ISL_ARG_PHANTOM_BOOL(s,l,setter,h) \
187	ISL_ARG_PHANTOM_BOOL_F(s,l,setter,h,0)
188	#define ISL_ARG_INT_F(st,f,s,l,a,d,h,fl) { \
189	.type = isl_arg_int, \
190	.short_name = s, \
191	.long_name = l, \
192	.argument_name = a, \
193	.offset = offsetof(st, f), \
194	.help_msg = h, \
195	.flags = fl, \
196	.u = { .i = { .default_value = d } } \
197	},
198	#define ISL_ARG_INT(st,f,s,l,a,d,h) \
199	ISL_ARG_INT_F(st,f,s,l,a,d,h,0)
200	#define ISL_ARG_LONG(st,f,s,lo,d,h) { \
201	.type = isl_arg_long, \
202	.short_name = s, \
203	.long_name = lo, \
204	.offset = offsetof(st, f), \
205	.help_msg = h, \
206	.u = { .l = { .default_value = d, .default_selected = d, \
207	.set = NULL } } \
208	},
209	#define ISL_ARG_USER_LONG(st,f,s,lo,setter,d,h) { \
210	.type = isl_arg_long, \
211	.short_name = s, \
212	.long_name = lo, \
213	.offset = offsetof(st, f), \
214	.help_msg = h, \
215	.u = { .l = { .default_value = d, .default_selected = d, \
216	.set = setter } } \
217	},
218	#define ISL_ARG_OPT_LONG(st,f,s,lo,d,ds,h) { \
219	.type = isl_arg_long, \
220	.short_name = s, \
221	.long_name = lo, \
222	.offset = offsetof(st, f), \
223	.help_msg = h, \
224	.u = { .l = { .default_value = d, .default_selected = ds, \
225	.set = NULL } } \
226	},
227	#define ISL_ARG_ULONG(st,f,s,l,d,h) { \
228	.type = isl_arg_ulong, \
229	.short_name = s, \
230	.long_name = l, \
231	.offset = offsetof(st, f), \
232	.help_msg = h, \
233	.u = { .ul = { .default_value = d } } \
234	},
235	#define ISL_ARG_STR_F(st,f,s,l,a,d,h,fl) { \
236	.type = isl_arg_str, \
237	.short_name = s, \
238	.long_name = l, \
239	.argument_name = a, \
240	.offset = offsetof(st, f), \
241	.help_msg = h, \
242	.flags = fl, \
243	.u = { .str = { .default_value = d } } \
244	},
245	#define ISL_ARG_STR(st,f,s,l,a,d,h) \
246	ISL_ARG_STR_F(st,f,s,l,a,d,h,0)
247	#define ISL_ARG_STR_LIST(st,f_n,f_l,s,l,a,h) { \
248	.type = isl_arg_str_list, \
249	.short_name = s, \
250	.long_name = l, \
251	.argument_name = a, \
252	.offset = offsetof(st, f_l), \
253	.help_msg = h, \
254	.u = { .str_list = { .offset_n = offsetof(st, f_n) } } \
255	},
256	#define _ISL_ARG_CHILD(o,l,c,h,fl) { \
257	.type = isl_arg_child, \
258	.long_name = l, \
259	.offset = o, \
260	.help_msg = h, \
261	.flags = fl, \
262	.u = { .child = { .child = c } } \
263	},
264	#define ISL_ARG_CHILD(st,f,l,c,h) \
265	_ISL_ARG_CHILD(offsetof(st, f),l,c,h,0)
266	#define ISL_ARG_GROUP_F(l,c,h,fl) \
267	_ISL_ARG_CHILD(ISL_ARG_OFFSET_NONE,l,c,h,fl)
268	#define ISL_ARG_GROUP(l,c,h) \
269	ISL_ARG_GROUP_F(l,c,h,0)
270	#define ISL_ARG_FLAGS(st,f,s,l,c,d,h) { \
271	.type = isl_arg_flags, \
272	.short_name = s, \
273	.long_name = l, \
274	.offset = offsetof(st, f), \
275	.help_msg = h, \
276	.u = { .flags = { .flags = c, .default_value = d } } \
277	},
278	#define ISL_ARG_USER(st,f,i,c) { \
279	.type = isl_arg_user, \
280	.offset = offsetof(st, f), \
281	.u = { .user = { .init = i, .clear = c} } \
282	},
283	#define ISL_ARG_VERSION(print) { \
284	.type = isl_arg_version, \
285	.u = { .version = { .print_version = print } } \
286	},
287
288	#define ISL_ARG_ALL (1 << 0)
289	#define ISL_ARG_SKIP_HELP (1 << 1)
290
291	void isl_args_set_defaults(struct isl_args args, void opt);
292	void isl_args_free(struct isl_args args, void opt);
293	int isl_args_parse(struct isl_args args, int argc, char argv, void opt,
294	unsigned flags);
295
296	#define ISL_ARG_DECL(prefix,st,args) \
297	extern struct isl_args args; \
298	st *prefix ## _new_with_defaults(void); \
299	void prefix ## _free(st *opt); \
300	int prefix ## _parse(st opt, int argc, char *argv, unsigned flags);
301
302	#define ISL_ARG_DEF(prefix,st,args) \
303	st *prefix ## _new_with_defaults() \
304	{ \
305	st opt = (st )calloc(1, sizeof(st)); \
306	if (opt) \
307	isl_args_set_defaults(&(args), opt); \
308	return opt; \
309	} \
310	\
311	void prefix ## _free(st *opt) \
312	{ \
313	isl_args_free(&(args), opt); \
314	} \
315	\
316	int prefix ## _parse(st opt, int argc, char *argv, unsigned flags) \
317	{ \
318	return isl_args_parse(&(args), argc, argv, opt, flags); \
319	}
320
321	#if defined(__cplusplus)
322	}
323	#endif
324
325	#endif