/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/tools/polly/lib/External/isl/include/isl/arg.h

Source (jump to first uncovered line)
/*
 * 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;
  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 = -1,             \
  .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(-1,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(-1,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

Coverage Report

Created: 2019-07-24 05:18

Line	Count	Source (jump to first uncovered line)
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		size_t offset;
57		const char *help_msg;
58	0	#define ISL_ARG_SINGLE_DASH (1 << 0)
59	0	#define ISL_ARG_BOOL_ARG (1 << 1)
60	0	#define ISL_ARG_HIDDEN (1 << 2)
61		unsigned flags;
62		union {
63		struct {
64		struct isl_arg_choice *choice;
65		unsigned default_value;
66		unsigned default_selected;
67		int (set)(void opt, unsigned val);
68		} choice;
69		struct {
70		struct isl_arg_flags *flags;
71		unsigned default_value;
72		} flags;
73		struct {
74		unsigned default_value;
75		int (set)(void opt, unsigned val);
76		} b;
77		struct {
78		int default_value;
79		} i;
80		struct {
81		long default_value;
82		long default_selected;
83		int (set)(void opt, long val);
84		} l;
85		struct {
86		unsigned long default_value;
87		} ul;
88		struct {
89		const char *default_value;
90		} str;
91		struct {
92		size_t offset_n;
93		} str_list;
94		struct {
95		struct isl_args *child;
96		} child;
97		struct {
98		void (*print_version)(void);
99		} version;
100		struct {
101		int (init)(void);
102		void (clear)(void);
103		} user;
104		} u;
105		};
106
107		struct isl_args {
108		size_t options_size;
109		struct isl_arg *args;
110		};
111
112		#define ISL_ARGS_START(s,name) \
113		struct isl_arg name ## LIST[]; \
114		struct isl_args name = { sizeof(s), name ## LIST }; \
115		struct isl_arg name ## LIST[] = {
116		#define ISL_ARGS_END \
117		{ isl_arg_end } };
118
119		#define ISL_ARG_ALIAS(l) { \
120		.type = isl_arg_alias, \
121		.long_name = l, \
122		},
123		#define ISL_ARG_ARG(st,f,a,d) { \
124		.type = isl_arg_arg, \
125		.argument_name = a, \
126		.offset = offsetof(st, f), \
127		.u = { .str = { .default_value = d } } \
128		},
129		#define ISL_ARG_FOOTER(h) { \
130		.type = isl_arg_footer, \
131		.help_msg = h, \
132		},
133		#define ISL_ARG_CHOICE(st,f,s,l,c,d,h) { \
134		.type = isl_arg_choice, \
135		.short_name = s, \
136		.long_name = l, \
137		.offset = offsetof(st, f), \
138		.help_msg = h, \
139		.u = { .choice = { .choice = c, .default_value = d, \
140		.default_selected = d, .set = NULL } } \
141		},
142		#define ISL_ARG_OPT_CHOICE(st,f,s,l,c,d,ds,h) { \
143		.type = isl_arg_choice, \
144		.short_name = s, \
145		.long_name = l, \
146		.offset = offsetof(st, f), \
147		.help_msg = h, \
148		.u = { .choice = { .choice = c, .default_value = d, \
149		.default_selected = ds, .set = NULL } } \
150		},
151		#define ISL_ARG_PHANTOM_USER_CHOICE_F(s,l,c,setter,d,h,fl) { \
152		.type = isl_arg_choice, \
153		.short_name = s, \
154		.long_name = l, \
155		.offset = -1, \
156		.help_msg = h, \
157		.flags = fl, \
158		.u = { .choice = { .choice = c, .default_value = d, \
159		.default_selected = d, .set = setter } } \
160		},
161		#define ISL_ARG_USER_OPT_CHOICE(st,f,s,l,c,setter,d,ds,h) { \
162		.type = isl_arg_choice, \
163		.short_name = s, \
164		.long_name = l, \
165		.offset = offsetof(st, f), \
166		.help_msg = h, \
167		.u = { .choice = { .choice = c, .default_value = d, \
168		.default_selected = ds, .set = setter } } \
169		},
170		#define _ISL_ARG_BOOL_F(o,s,l,setter,d,h,fl) { \
171		.type = isl_arg_bool, \
172		.short_name = s, \
173		.long_name = l, \
174		.offset = o, \
175		.help_msg = h, \
176		.flags = fl, \
177		.u = { .b = { .default_value = d, .set = setter } } \
178		},
179		#define ISL_ARG_BOOL_F(st,f,s,l,d,h,fl) \
180		_ISL_ARG_BOOL_F(offsetof(st, f),s,l,NULL,d,h,fl)
181		#define ISL_ARG_BOOL(st,f,s,l,d,h) \
182		ISL_ARG_BOOL_F(st,f,s,l,d,h,0)
183		#define ISL_ARG_PHANTOM_BOOL_F(s,l,setter,h,fl) \
184		_ISL_ARG_BOOL_F(-1,s,l,setter,0,h,fl)
185		#define ISL_ARG_PHANTOM_BOOL(s,l,setter,h) \
186		ISL_ARG_PHANTOM_BOOL_F(s,l,setter,h,0)
187		#define ISL_ARG_INT_F(st,f,s,l,a,d,h,fl) { \
188		.type = isl_arg_int, \
189		.short_name = s, \
190		.long_name = l, \
191		.argument_name = a, \
192		.offset = offsetof(st, f), \
193		.help_msg = h, \
194		.flags = fl, \
195		.u = { .i = { .default_value = d } } \
196		},
197		#define ISL_ARG_INT(st,f,s,l,a,d,h) \
198		ISL_ARG_INT_F(st,f,s,l,a,d,h,0)
199		#define ISL_ARG_LONG(st,f,s,lo,d,h) { \
200		.type = isl_arg_long, \
201		.short_name = s, \
202		.long_name = lo, \
203		.offset = offsetof(st, f), \
204		.help_msg = h, \
205		.u = { .l = { .default_value = d, .default_selected = d, \
206		.set = NULL } } \
207		},
208		#define ISL_ARG_USER_LONG(st,f,s,lo,setter,d,h) { \
209		.type = isl_arg_long, \
210		.short_name = s, \
211		.long_name = lo, \
212		.offset = offsetof(st, f), \
213		.help_msg = h, \
214		.u = { .l = { .default_value = d, .default_selected = d, \
215		.set = setter } } \
216		},
217		#define ISL_ARG_OPT_LONG(st,f,s,lo,d,ds,h) { \
218		.type = isl_arg_long, \
219		.short_name = s, \
220		.long_name = lo, \
221		.offset = offsetof(st, f), \
222		.help_msg = h, \
223		.u = { .l = { .default_value = d, .default_selected = ds, \
224		.set = NULL } } \
225		},
226		#define ISL_ARG_ULONG(st,f,s,l,d,h) { \
227		.type = isl_arg_ulong, \
228		.short_name = s, \
229		.long_name = l, \
230		.offset = offsetof(st, f), \
231		.help_msg = h, \
232		.u = { .ul = { .default_value = d } } \
233		},
234		#define ISL_ARG_STR_F(st,f,s,l,a,d,h,fl) { \
235		.type = isl_arg_str, \
236		.short_name = s, \
237		.long_name = l, \
238		.argument_name = a, \
239		.offset = offsetof(st, f), \
240		.help_msg = h, \
241		.flags = fl, \
242		.u = { .str = { .default_value = d } } \
243		},
244		#define ISL_ARG_STR(st,f,s,l,a,d,h) \
245		ISL_ARG_STR_F(st,f,s,l,a,d,h,0)
246		#define ISL_ARG_STR_LIST(st,f_n,f_l,s,l,a,h) { \
247		.type = isl_arg_str_list, \
248		.short_name = s, \
249		.long_name = l, \
250		.argument_name = a, \
251		.offset = offsetof(st, f_l), \
252		.help_msg = h, \
253		.u = { .str_list = { .offset_n = offsetof(st, f_n) } } \
254		},
255		#define _ISL_ARG_CHILD(o,l,c,h,fl) { \
256		.type = isl_arg_child, \
257		.long_name = l, \
258		.offset = o, \
259		.help_msg = h, \
260		.flags = fl, \
261		.u = { .child = { .child = c } } \
262		},
263		#define ISL_ARG_CHILD(st,f,l,c,h) \
264		_ISL_ARG_CHILD(offsetof(st, f),l,c,h,0)
265		#define ISL_ARG_GROUP_F(l,c,h,fl) \
266		_ISL_ARG_CHILD(-1,l,c,h,fl)
267		#define ISL_ARG_GROUP(l,c,h) \
268		ISL_ARG_GROUP_F(l,c,h,0)
269		#define ISL_ARG_FLAGS(st,f,s,l,c,d,h) { \
270		.type = isl_arg_flags, \
271		.short_name = s, \
272		.long_name = l, \
273		.offset = offsetof(st, f), \
274		.help_msg = h, \
275		.u = { .flags = { .flags = c, .default_value = d } } \
276		},
277		#define ISL_ARG_USER(st,f,i,c) { \
278		.type = isl_arg_user, \
279		.offset = offsetof(st, f), \
280		.u = { .user = { .init = i, .clear = c} } \
281		},
282		#define ISL_ARG_VERSION(print) { \
283		.type = isl_arg_version, \
284		.u = { .version = { .print_version = print } } \
285		},
286
287		#define ISL_ARG_ALL (1 << 0)
288		#define ISL_ARG_SKIP_HELP (1 << 1)
289
290		void isl_args_set_defaults(struct isl_args args, void opt);
291		void isl_args_free(struct isl_args args, void opt);
292		int isl_args_parse(struct isl_args args, int argc, char argv, void opt,
293		unsigned flags);
294
295		#define ISL_ARG_DECL(prefix,st,args) \
296		extern struct isl_args args; \
297		st *prefix ## _new_with_defaults(void); \
298		void prefix ## _free(st *opt); \
299		int prefix ## _parse(st opt, int argc, char *argv, unsigned flags);
300
301		#define ISL_ARG_DEF(prefix,st,args) \
302	1.29k	st *prefix ## _new_with_defaults() \
303	1.29k	{ \
304	1.29k	st opt = (st )calloc(1, sizeof(st)); \
305	1.29k	if (opt) \
306	1.29k	isl_args_set_defaults(&(args), opt); \
307	1.29k	return opt; \
308	1.29k	} \
309		\
310	0	void prefix ## _free(st *opt) \
311	0	{ \
312	0	isl_args_free(&(args), opt); \
313	0	} \
314		\
315	1	int prefix ## _parse(st opt, int argc, char *argv, unsigned flags) \
316	1	{ \
317	1	return isl_args_parse(&(args), argc, argv, opt, flags); \
318	1	}
319
320		#if defined(__cplusplus)
321		}
322		#endif
323
324		#endif