Context Navigation

parseargs.cfa @ 5ce7f4a

ADTast-experimentalpthread-emulationqualifiedEnum

Last change on this file since 5ce7f4a was 789f279, checked in by Thierry Delisle <tdelisle@…>, 3 years ago
More standard lib visibility
Property mode set to `100644`
File size: 7.8 KB

Line
1	#include "parseargs.hfa"
2
3	#include <stdint.h>
4	#include <string.h>
5	#include <errno.h>
6	#include <unistd.h>
7	extern "C" {
8	#include <getopt.h>
9	#include <sys/ioctl.h>
10
11	struct FILE;
12	extern FILE * stderr;
13	extern FILE * stdout;
14
15	extern int fileno(FILE *stream);
16
17	extern int fprintf ( FILE * stream, const char * format, ... );
18
19	extern long long int strtoll (const char* str, char** endptr, int base);
20	extern unsigned long long int strtoull(const char* str, char** endptr, int base);
21	extern double strtod (const char* str, char** endptr);
22	}
23
24	#include "common.hfa"
25	#include "limits.hfa"
26
27	#pragma GCC visibility push(default)
28
29	extern int cfa_args_argc __attribute__((weak));
30	extern char ** cfa_args_argv __attribute__((weak));
31	extern char ** cfa_args_envp __attribute__((weak));
32
33	static void usage(char * cmd, cfa_option options[], size_t opt_count, const char * usage, FILE * out) __attribute__ ((noreturn));
34	//-----------------------------------------------------------------------------
35	// checking
36	static void check_args(cfa_option options[], size_t opt_count) {
37	for(i; opt_count) {
38	for(j; opt_count) {
39	if(i == j) continue;
40
41	if( options[i].short_name != '\0'
42	&& options[i].short_name == options[j].short_name)
43	abort("Parse Args error: two options have short name '%c' (%zu & %zu)", options[i].short_name, i, j);
44
45	if(0 == strcmp(options[i].long_name, options[j].long_name)) abort("Parse Args error: two options have long name '%s' (%zu & %zu)", options[i].long_name, i, j);
46	}
47	}
48	}
49
50
51	//-----------------------------------------------------------------------------
52	// Parsing args
53	void parse_args( cfa_option options[], size_t opt_count, const char * usage, char ** & left ) {
54	if( 0p != &cfa_args_argc ) {
55	parse_args(cfa_args_argc, cfa_args_argv, options, opt_count, usage, left );
56	}
57	else {
58	char * temp = "";
59	parse_args(0, &temp, options, opt_count, usage, left );
60	}
61	}
62
63	void parse_args(
64	int argc,
65	char * argv[],
66	cfa_option options[],
67	size_t opt_count,
68	const char * usage,
69	char ** & left
70	) {
71	check_args(options, opt_count);
72
73	int maxv = 'h';
74	char optstring[opt_count * 3] = { '\0' };
75	{
76	int idx = 0;
77	for(i; opt_count) {
78	if (options[i].short_name) {
79	maxv = max(options[i].short_name, maxv);
80	optstring[idx] = options[i].short_name;
81	idx++;
82	if( ((intptr_t)options[i].parse) != ((intptr_t)parse_settrue)
83	&& ((intptr_t)options[i].parse) != ((intptr_t)parse_setfalse) ) {
84	optstring[idx] = ':';
85	idx++;
86	}
87	}
88	}
89	optstring[idx+0] = 'h';
90	optstring[idx+1] = '\0';
91	}
92
93	struct option optarr[opt_count + 2];
94	{
95	int idx = 0;
96	for(i; opt_count) {
97	if(options[i].long_name) {
98	options[i].val = (options[i].short_name != '\0') ? ((int)options[i].short_name) : ++maxv;
99	optarr[idx].name = options[i].long_name;
100	optarr[idx].flag = 0p;
101	optarr[idx].val = options[i].val;
102	if( ((intptr_t)options[i].parse) == ((intptr_t)parse_settrue)
103	\|\| ((intptr_t)options[i].parse) == ((intptr_t)parse_setfalse) ) {
104	optarr[idx].has_arg = no_argument;
105	} else {
106	optarr[idx].has_arg = required_argument;
107	}
108	idx++;
109	}
110	}
111	optarr[idx+0].[name, has_arg, flag, val] = ["help", no_argument, 0, 'h'];
112	optarr[idx+1].[name, has_arg, flag, val] = [0, no_argument, 0, 0];
113	}
114
115	FILE * out = stderr;
116	NEXT_ARG:
117	for() {
118	int idx = 0;
119	int opt = getopt_long(argc, argv, optstring, optarr, &idx);
120	switch(opt) {
121	case -1:
122	if(&left != 0p) left = argv + optind;
123	return;
124	case 'h':
125	out = stdout;
126	case '?':
127	usage(argv[0], options, opt_count, usage, out);
128	default:
129	for(i; opt_count) {
130	if(opt == options[i].val) {
131	const char * arg = optarg ? optarg : "";
132	if( arg[0] == '=' ) { arg++; }
133	bool success = options[i].parse( arg, options[i].variable );
134	if(success) continue NEXT_ARG;
135
136	fprintf(out, "Argument '%s' for option %c could not be parsed\n\n", arg, (char)opt);
137	usage(argv[0], options, opt_count, usage, out);
138	}
139	}
140	abort("Internal parse arg error\n");
141	}
142
143	}
144	}
145
146	//-----------------------------------------------------------------------------
147	// Print usage
148	static void printopt(FILE * out, int width, int max, char sn, const char * ln, const char * help) {
149	int hwidth = max - (11 + width);
150	if(hwidth <= 0) hwidth = max;
151
152	char sname[4] = { ' ', ' ', ' ', '\0' };
153	if(sn != '\0') {
154	sname[0] = '-';
155	sname[1] = sn;
156	sname[2] = ',';
157	}
158
159	fprintf(out, " %s --%-s %.s\n", sname, width, ln, hwidth, help);
160	for() {
161	help += min(strlen(help), hwidth);
162	if('\0' == *help) break;
163	fprintf(out, "%s%.s\n", width + 11, "", hwidth, help);
164	}
165	}
166
167	void print_args_usage(cfa_option options[], size_t opt_count, const char * usage, bool error) __attribute__ ((noreturn)) {
168	usage(cfa_args_argv[0], options, opt_count, usage, error ? stderr : stdout);
169	}
170
171	void print_args_usage(int , char * argv[], cfa_option options[], size_t opt_count, const char * usage, bool error) __attribute__ ((noreturn)) {
172	usage(argv[0], options, opt_count, usage, error ? stderr : stdout);
173	}
174
175	static void usage(char * cmd, cfa_option options[], size_t opt_count, const char * help, FILE * out) __attribute__((noreturn)) {
176	int width = 0;
177	{
178	for(i; opt_count) {
179	if(options[i].long_name) {
180	int w = strlen(options[i].long_name);
181	if(w > width) width = w;
182	}
183	}
184	}
185
186	int max_width = 1_000_000;
187	int outfd = fileno(out);
188	if(isatty(outfd)) {
189	struct winsize size;
190	int ret = ioctl(outfd, TIOCGWINSZ, &size);
191	if(ret < 0) abort( "ioctl error: (%d) %s\n", (int)errno, strerror(errno) );
192	max_width = size.ws_col;
193	}
194
195	fprintf(out, "Usage:\n %s %s\n", cmd, help);
196
197	for(i; opt_count) {
198	printopt(out, width, max_width, options[i].short_name, options[i].long_name, options[i].help);
199	}
200	fprintf(out, " -%c, --%-*s %s\n", 'h', width, "help", "print this help message");
201	exit(out == stdout ? 0 : 1);
202	}
203
204	//-----------------------------------------------------------------------------
205	// Typed argument parsing
206	bool parse_yesno(const char * arg, bool & value ) {
207	if(strcmp(arg, "yes") == 0) {
208	value = true;
209	return true;
210	}
211
212	if(strcmp(arg, "Y") == 0) {
213	value = true;
214	return true;
215	}
216
217	if(strcmp(arg, "y") == 0) {
218	value = true;
219	return true;
220	}
221
222	if(strcmp(arg, "no") == 0) {
223	value = false;
224	return true;
225	}
226
227	if(strcmp(arg, "N") == 0) {
228	value = false;
229	return true;
230	}
231
232	if(strcmp(arg, "n") == 0) {
233	value = false;
234	return true;
235	}
236
237	return false;
238	}
239
240	bool parse_truefalse(const char * arg, bool & value) {
241	if(strcmp(arg, "true") == 0) {
242	value = true;
243	return true;
244	}
245
246	if(strcmp(arg, "false") == 0) {
247	value = false;
248	return true;
249	}
250
251	return false;
252	}
253
254	bool parse_settrue (const char *, bool & value ) {
255	value = true;
256	return true;
257	}
258
259	bool parse_setfalse(const char *, bool & value ) {
260	value = false;
261	return true;
262	}
263
264	bool parse(const char * arg, const char * & value ) {
265	value = arg;
266	return true;
267	}
268
269	bool parse(const char * arg, int & value) {
270	char * end;
271	int r = strtoll(arg, &end, 10);
272	if(*end != '\0') return false;
273
274	value = r;
275	return true;
276	}
277
278	bool parse(const char * arg, unsigned & value) {
279	char * end;
280	unsigned long long int r = strtoull(arg, &end, 10);
281	if(*end != '\0') return false;
282	if(r > (unsigned)MAX) return false;
283
284	value = r;
285	return true;
286	}
287
288	bool parse(const char * arg, unsigned long & value) {
289	char * end;
290	unsigned long long int r = strtoull(arg, &end, 10);
291	if(*end != '\0') return false;
292	if(r > (unsigned long)MAX) return false;
293
294	value = r;
295	return true;
296	}
297
298	bool parse(const char * arg, unsigned long long & value) {
299	char * end;
300	unsigned long long int r = strtoull(arg, &end, 10);
301	if(*end != '\0') return false;
302	if(r > (unsigned long long)MAX) return false;
303
304	value = r;
305	return true;
306	}
307
308	bool parse(const char * arg, double & value) {
309	char * end;
310	double r = strtod(arg, &end);
311	if(*end != '\0') return false;
312
313	value = r;
314	return true;
315	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

Original Format