source: libcfa/src/parseargs.cfa@ 7b737df

ADT ast-experimental
Last change on this file since 7b737df was f82f07e, checked in by Thierry Delisle <tdelisle@…>, 3 years ago

Fixes to usage and corresponding tests
  • Property mode set to 100644
File size: 9.7 KB
Line 
1//
2// Cforall Version 1.0.0 Copyright (C) 2022 University of Waterloo
3//
4// The contents of this file are covered under the licence agreement in the
5// file "LICENCE" distributed with Cforall.
6//
7// parseargs.cfa
8// implementation of arguments parsing (argc, argv)
9//
10// Author : Thierry Delisle
11// Created On : Wed Oct 12 15:28:01 2022
12// Last Modified By :
13// Last Modified On :
14// Update Count :
15//
16
17#include "parseargs.hfa"
18
19#include <assert.h>
20#include <ctype.h>
21#include <stdint.h>
22#include <string.h>
23#include <errno.h>
24#include <unistd.h>
25
26extern "C" {
27 #include <getopt.h>
28 #include <sys/ioctl.h>
29
30 struct FILE;
31 extern FILE * stderr;
32 extern FILE * stdout;
33
34 extern int fileno(FILE *stream);
35
36 extern int fprintf ( FILE * stream, const char * format, ... );
37
38 extern long long int strtoll (const char* str, char** endptr, int base);
39 extern unsigned long long int strtoull(const char* str, char** endptr, int base);
40 extern double strtod (const char* str, char** endptr);
41}
42
43#include "common.hfa"
44#include "limits.hfa"
45
46#pragma GCC visibility push(default)
47
48extern int cfa_args_argc __attribute__((weak));
49extern char ** cfa_args_argv __attribute__((weak));
50extern char ** cfa_args_envp __attribute__((weak));
51
52static void usage(char * cmd, cfa_option options[], size_t opt_count, const char * usage, FILE * out) __attribute__ ((noreturn));
53//-----------------------------------------------------------------------------
54// checking
55static void check_args(cfa_option options[], size_t opt_count) {
56 for(i; opt_count) {
57 for(j; opt_count) {
58 if(i == j) continue;
59
60 if( options[i].short_name != '\0'
61 && options[i].short_name == options[j].short_name)
62 abort("Parse Args error: two options have short name '%c' (%zu & %zu)", options[i].short_name, i, j);
63
64 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);
65 }
66 }
67}
68
69
70//-----------------------------------------------------------------------------
71// Parsing args
72void parse_args( cfa_option options[], size_t opt_count, const char * usage, char ** & left ) {
73 if( 0p != &cfa_args_argc ) {
74 parse_args(cfa_args_argc, cfa_args_argv, options, opt_count, usage, left );
75 }
76 else {
77 char * temp = "";
78 parse_args(0, &temp, options, opt_count, usage, left );
79 }
80}
81
82void parse_args(
83 int argc,
84 char * argv[],
85 cfa_option options[],
86 size_t opt_count,
87 const char * usage,
88 char ** & left
89) {
90 check_args(options, opt_count);
91
92 int maxv = 'h';
93 char optstring[(opt_count * 3) + 2] = { '\0' };
94 {
95 int idx = 0;
96 for(i; opt_count) {
97 if (options[i].short_name) {
98 maxv = max(options[i].short_name, maxv);
99 optstring[idx] = options[i].short_name;
100 idx++;
101 if( ((intptr_t)options[i].parse) != ((intptr_t)parse_settrue)
102 && ((intptr_t)options[i].parse) != ((intptr_t)parse_setfalse) ) {
103 optstring[idx] = ':';
104 idx++;
105 }
106 }
107 }
108 optstring[idx+0] = 'h';
109 optstring[idx+1] = '\0';
110 }
111
112 struct option optarr[opt_count + 2];
113 {
114 int idx = 0;
115 for(i; opt_count) {
116 if(options[i].long_name) {
117 options[i].val = (options[i].short_name != '\0') ? ((int)options[i].short_name) : ++maxv;
118 optarr[idx].name = options[i].long_name;
119 optarr[idx].flag = 0p;
120 optarr[idx].val = options[i].val;
121 if( ((intptr_t)options[i].parse) == ((intptr_t)parse_settrue)
122 || ((intptr_t)options[i].parse) == ((intptr_t)parse_setfalse) ) {
123 optarr[idx].has_arg = no_argument;
124 } else {
125 optarr[idx].has_arg = required_argument;
126 }
127 idx++;
128 }
129 }
130 optarr[idx+0].[name, has_arg, flag, val] = ["help", no_argument, 0, 'h'];
131 optarr[idx+1].[name, has_arg, flag, val] = [0, no_argument, 0, 0];
132 }
133
134 FILE * out = stderr;
135 NEXT_ARG:
136 for() {
137 int idx = 0;
138 int opt = getopt_long(argc, argv, optstring, optarr, &idx);
139 switch(opt) {
140 case -1:
141 if(&left != 0p) left = argv + optind;
142 return;
143 case 'h':
144 out = stdout;
145 case '?':
146 usage(argv[0], options, opt_count, usage, out);
147 default:
148 for(i; opt_count) {
149 if(opt == options[i].val) {
150 const char * arg = optarg ? optarg : "";
151 if( arg[0] == '=' ) { arg++; }
152 bool success = options[i].parse( arg, options[i].variable );
153 if(success) continue NEXT_ARG;
154
155 fprintf(out, "Argument '%s' for option %c could not be parsed\n\n", arg, (char)opt);
156 usage(argv[0], options, opt_count, usage, out);
157 }
158 }
159 abort("Internal parse arg error\n");
160 }
161
162 }
163}
164
165static inline int next_newline(const char * str) {
166 int ret;
167 const char * ptr = strstr(str, "\n");
168 if(!ptr) return MAX;
169
170 /* paranoid */ verify( str <= ptr);
171 intptr_t low = (intptr_t)str;
172 intptr_t hi = (intptr_t)ptr;
173 ret = hi - low;
174
175 return ret;
176}
177
178//-----------------------------------------------------------------------------
179// Print usage
180static void printopt(FILE * out, int width, int max, char sn, const char * ln, const char * help) {
181 // check how wide we should be printing
182 // this includes all options and the help message
183 int hwidth = max - (11 + width);
184 if(hwidth <= 0) hwidth = max;
185
186 // check which pieces we have
187 bool has_ln = ln && strcmp("", ln);
188 bool has_help = help && strcmp("", help);
189
190 // print the small name if present
191 if(sn != '\0') fprintf(out, " -%c", sn);
192 else fprintf(out, " ");
193
194 // print a comma if we have both short and long names
195 if(sn != '\0' && has_ln) fprintf(out, ", ");
196 else fprintf(out, " ");
197
198 // print the long name if present
199 if(has_ln) fprintf(out, "--%-*s", width, ln);
200 else if(has_help) fprintf(out, " %-*s", width, "");
201
202 if(has_help) {
203 // print the help
204 // We need to wrap at the max width, and also indent newlines so everything is nice and pretty
205
206 // for each line to print
207 for() {
208 //find out if there is a newline
209 int nextnl = next_newline(help);
210 int real = min(min(strlen(help), hwidth), nextnl);
211
212 fprintf(out, " %.*s", real, help);
213 // printf("%d %d\n", real, nextnl);
214 help += real;
215 if( nextnl == real ) help++;
216 if('\0' == *help) break;
217 fprintf(out, "\n%*s", width + 8, "");
218 }
219 }
220 fprintf(out, "\n");
221}
222
223void print_args_usage(cfa_option options[], size_t opt_count, const char * usage, bool error) __attribute__ ((noreturn)) {
224 usage(cfa_args_argv[0], options, opt_count, usage, error ? stderr : stdout);
225}
226
227void print_args_usage(int , char * argv[], cfa_option options[], size_t opt_count, const char * usage, bool error) __attribute__ ((noreturn)) {
228 usage(argv[0], options, opt_count, usage, error ? stderr : stdout);
229}
230
231static void usage(char * cmd, cfa_option options[], size_t opt_count, const char * help, FILE * out) __attribute__((noreturn)) {
232 int width = 0;
233 {
234 for(i; opt_count) {
235 if(options[i].long_name) {
236 int w = strlen(options[i].long_name);
237 if(w > width) width = w;
238 }
239 }
240 }
241
242 int max_width = 1_000_000;
243 int outfd = fileno(out);
244 if(isatty(outfd)) {
245 struct winsize size;
246 int ret = ioctl(outfd, TIOCGWINSZ, &size);
247 if(ret < 0) abort( "ioctl error: (%d) %s\n", (int)errno, strerror(errno) );
248 max_width = size.ws_col;
249 }
250
251 fprintf(out, "Usage:\n %s %s\n", cmd, help);
252
253 for(i; opt_count) {
254 printopt(out, width, max_width, options[i].short_name, options[i].long_name, options[i].help);
255 }
256 fprintf(out, " -%c, --%-*s %s\n", 'h', width, "help", "print this help message");
257 exit(out == stdout ? 0 : 1);
258}
259
260//-----------------------------------------------------------------------------
261// Typed argument parsing
262bool parse_yesno(const char * arg, bool & value ) {
263 if(strcmp(arg, "yes") == 0) {
264 value = true;
265 return true;
266 }
267
268 if(strcmp(arg, "Y") == 0) {
269 value = true;
270 return true;
271 }
272
273 if(strcmp(arg, "y") == 0) {
274 value = true;
275 return true;
276 }
277
278 if(strcmp(arg, "no") == 0) {
279 value = false;
280 return true;
281 }
282
283 if(strcmp(arg, "N") == 0) {
284 value = false;
285 return true;
286 }
287
288 if(strcmp(arg, "n") == 0) {
289 value = false;
290 return true;
291 }
292
293 return false;
294}
295
296bool parse_truefalse(const char * arg, bool & value) {
297 if(strcmp(arg, "true") == 0) {
298 value = true;
299 return true;
300 }
301
302 if(strcmp(arg, "false") == 0) {
303 value = false;
304 return true;
305 }
306
307 return false;
308}
309
310bool parse_settrue (const char *, bool & value ) {
311 value = true;
312 return true;
313}
314
315bool parse_setfalse(const char *, bool & value ) {
316 value = false;
317 return true;
318}
319
320bool parse(const char * arg, const char * & value ) {
321 value = arg;
322 return true;
323}
324
325bool parse(const char * arg, int & value) {
326 char * end;
327
328 errno = 0;
329 long long int r = strtoll(arg, &end, 0);
330 if(errno) return false;
331 if(*end != '\0') return false;
332 if(r > (int)MAX) return false;
333 if(r < (int)MIN) return false;
334
335 value = r;
336 return true;
337}
338
339static unsigned long long int strict_strtoull( const char * arg, int base) {
340 errno = 0;
341 {
342 const char * in = arg;
343 for() {
344 if('\0' == *in) {
345 errno = EINVAL;
346 return 0;
347 }
348 if(!isspace(*in)) break;
349 in++;
350 }
351 if(!isdigit(*in)) {
352 errno = EINVAL;
353 return 0;
354 }
355 }
356
357 *char end;
358 unsigned long long int r = strtoull(arg, &end, base);
359 if(*end != '\0') errno = EINVAL;
360 if(errno) return 0;
361 return r;
362}
363
364bool parse(const char * arg, unsigned & value) {
365 unsigned long long int r = strict_strtoull(arg, 0);
366 if(errno) return false;
367 if(r > (unsigned)MAX) return false;
368
369 value = r;
370 return true;
371}
372
373bool parse(const char * arg, unsigned long & value) {
374 unsigned long long int r = strict_strtoull(arg, 0);
375 if(errno) return false;
376 if(r > (unsigned long)MAX) return false;
377
378 value = r;
379 return true;
380}
381
382bool parse(const char * arg, unsigned long long & value) {
383 unsigned long long int r = strict_strtoull(arg, 0);
384 if(errno) return false;
385 if(r > (unsigned long long)MAX) return false;
386
387 value = r;
388 return true;
389}
390
391bool parse(const char * arg, double & value) {
392 char * end;
393 double r = strtod(arg, &end);
394 if(*end != '\0') return false;
395
396 value = r;
397 return true;
398}
Note: See TracBrowser for help on using the repository browser.