Changeset df6cc9d for libcfa/src/parseargs.cfa

Timestamp:

Oct 19, 2022, 4:43:26 PM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, ast-experimental, master

Children:

1a45263

Parents:

9cd5bd2 (diff), 135143ba (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into pthread-emulation

File:

• libcfa/src/parseargs.cfa (modified) (9 diffs)

libcfa/src/parseargs.cfa

@@ +1 @@
+//
+// Cforall Version 1.0.0 Copyright (C) 2022 University of Waterloo
+//
+// The contents of this file are covered under the licence agreement in the
+// file "LICENCE" distributed with Cforall.
+//
+// parseargs.cfa
+// implementation of arguments parsing (argc, argv)
+//
+// Author           : Thierry Delisle
+// Created On       : Wed Oct 12 15:28:01 2022
+// Last Modified By :
+// Last Modified On :
+// Update Count     :
+//
+
 #include "parseargs.hfa"
 
+#include <assert.h>
+#include <ctype.h>
 #include <stdint.h>
 #include <string.h>
 #include <errno.h>
 #include <unistd.h>
-#include <assert.h>
 
 extern "C" {
@@ -33 +50 @@
 extern char ** cfa_args_envp __attribute__((weak));
 
-static void usage(char * cmd, cfa_option options[], size_t opt_count, const char * usage, FILE * out)  __attribute__ ((noreturn));
+forall([N])
+static void usage(char * cmd, const array( cfa_option, N ) & options, const char * usage, FILE * out)  __attribute__ ((noreturn));
 //-----------------------------------------------------------------------------
 // checking
-static void check_args(cfa_option options[], size_t opt_count) {
-        for(i; opt_count) {
-                for(j; opt_count) {
+forall([N])
+static void check_args( const array( cfa_option, N ) & options ) {
+        for(i; N) {
+                for(j; N) {
                         if(i == j) continue;
 
@@ -53 +72 @@
 //-----------------------------------------------------------------------------
 // Parsing args
-void parse_args( cfa_option options[], size_t opt_count, const char * usage, char ** & left ) {
-        if( 0p != &cfa_args_argc ) {
-                parse_args(cfa_args_argc, cfa_args_argv, options, opt_count, usage, left );
-        }
-        else {
-                char * temp = "";
-                parse_args(0, &temp, options, opt_count, usage, left );
-        }
-}
-
-void parse_args(
-        int argc,
-        char * argv[],
-        cfa_option options[],
-        size_t opt_count,
-        const char * usage,
-        char ** & left
-) {
-        check_args(options, opt_count);
-
-        int maxv = 'h';
-        assert( opt_count > 0 );
-        char optstring[opt_count * 3] = { '\0' };
-        {
-                int idx = 0;
-                for(i; opt_count) {
-                        if (options[i].short_name) {
-                                maxv = max(options[i].short_name, maxv);
-                                optstring[idx] = options[i].short_name;
-                                idx++;
-                                if(    ((intptr_t)options[i].parse) != ((intptr_t)parse_settrue)
-                                && ((intptr_t)options[i].parse) != ((intptr_t)parse_setfalse) ) {
-                                        optstring[idx] = ':';
+forall([opt_count]) {
+        void parse_args( const array( cfa_option, opt_count ) & options, const char * usage, char ** & left ) {
+                if( 0p != &cfa_args_argc ) {
+                        parse_args(cfa_args_argc, cfa_args_argv, options, usage, left );
+                }
+                else {
+                        char * temp = "";
+                        parse_args(0, &temp, options, usage, left );
+                }
+        }
+
+        void parse_args(
+                int argc,
+                char * argv[],
+                const array( cfa_option, opt_count ) & options,
+                const char * usage,
+                char ** & left
+        ) {
+                check_args(options);
+
+                int maxv = 'h';
+                char optstring[(opt_count * 3) + 2] = { '\0' };
+                {
+                        int idx = 0;
+                        for(i; opt_count) {
+                                if (options[i].short_name) {
+                                        maxv = max(options[i].short_name, maxv);
+                                        optstring[idx] = options[i].short_name;
+                                        idx++;
+                                        if(    ((intptr_t)options[i].parse) != ((intptr_t)parse_settrue)
+                                        && ((intptr_t)options[i].parse) != ((intptr_t)parse_setfalse) ) {
+                                                optstring[idx] = ':';
+                                                idx++;
+                                        }
+                                }
+                        }
+                        optstring[idx+0] = 'h';
+                        optstring[idx+1] = '\0';
+                }
+
+                struct option optarr[opt_count + 2];
+                {
+                        int idx = 0;
+                        for(i; opt_count) {
+                                if(options[i].long_name) {
+                                        // we don't have the mutable keyword here, which is really what we would want
+                                        int & val_ref = (int &)(const int &)options[i].val;
+                                        val_ref = (options[i].short_name != '\0') ? ((int)options[i].short_name) : ++maxv;
+
+                                        optarr[idx].name = options[i].long_name;
+                                        optarr[idx].flag = 0p;
+                                        optarr[idx].val  = options[i].val;
+                                        if(    ((intptr_t)options[i].parse) == ((intptr_t)parse_settrue)
+                                        || ((intptr_t)options[i].parse) == ((intptr_t)parse_setfalse) ) {
+                                                optarr[idx].has_arg = no_argument;
+                                        } else {
+                                                optarr[idx].has_arg = required_argument;
+                                        }
                                         idx++;
                                 }
                         }
-                }
-                optstring[idx+0] = 'h';
-                optstring[idx+1] = '\0';
-        }
-
-        struct option optarr[opt_count + 2];
-        {
-                int idx = 0;
-                for(i; opt_count) {
-                        if(options[i].long_name) {
-                                options[i].val = (options[i].short_name != '\0') ? ((int)options[i].short_name) : ++maxv;
-                                optarr[idx].name = options[i].long_name;
-                                optarr[idx].flag = 0p;
-                                optarr[idx].val  = options[i].val;
-                                if(    ((intptr_t)options[i].parse) == ((intptr_t)parse_settrue)
-                                    || ((intptr_t)options[i].parse) == ((intptr_t)parse_setfalse) ) {
-                                        optarr[idx].has_arg = no_argument;
-                                } else {
-                                        optarr[idx].has_arg = required_argument;
-                                }
-                                idx++;
+                        optarr[idx+0].[name, has_arg, flag, val] = ["help", no_argument, 0, 'h'];
+                        optarr[idx+1].[name, has_arg, flag, val] = [0, no_argument, 0, 0];
+                }
+
+                FILE * out = stderr;
+                NEXT_ARG:
+                for() {
+                        int idx = 0;
+                        int opt = getopt_long(argc, argv, optstring, optarr, &idx);
+                        switch(opt) {
+                                case -1:
+                                        if(&left != 0p) left = argv + optind;
+                                        return;
+                                case 'h':
+                                        out = stdout;
+                                case '?':
+                                        usage(argv[0], options, usage, out);
+                                default:
+                                        for(i; opt_count) {
+                                                if(opt == options[i].val) {
+                                                        const char * arg = optarg ? optarg : "";
+                                                        if( arg[0] == '=' ) { arg++; }
+                                                        // work around for some weird bug
+                                                        void * variable = options[i].variable;
+                                                        bool (*parse_func)(const char *, void * ) = options[i].parse;
+                                                        bool success = parse_func( arg, variable );
+                                                        if(success) continue NEXT_ARG;
+
+                                                        fprintf(out, "Argument '%s' for option %c could not be parsed\n\n", arg, (char)opt);
+                                                        usage(argv[0], options, usage, out);
+                                                }
+                                        }
+                                        abort("Internal parse arg error\n");
                         }
-                }
-                optarr[idx+0].[name, has_arg, flag, val] = ["help", no_argument, 0, 'h'];
-                optarr[idx+1].[name, has_arg, flag, val] = [0, no_argument, 0, 0];
-        }
-
-        FILE * out = stderr;
-        NEXT_ARG:
-        for() {
-                int idx = 0;
-                int opt = getopt_long(argc, argv, optstring, optarr, &idx);
-                switch(opt) {
-                        case -1:
-                                if(&left != 0p) left = argv + optind;
-                                return;
-                        case 'h':
-                                out = stdout;
-                        case '?':
-                                usage(argv[0], options, opt_count, usage, out);
-                        default:
-                                for(i; opt_count) {
-                                        if(opt == options[i].val) {
-                                                const char * arg = optarg ? optarg : "";
-                                                if( arg[0] == '=' ) { arg++; }
-                                                bool success = options[i].parse( arg, options[i].variable );
-                                                if(success) continue NEXT_ARG;
-
-                                                fprintf(out, "Argument '%s' for option %c could not be parsed\n\n", arg, (char)opt);
-                                                usage(argv[0], options, opt_count, usage, out);
-                                        }
-                                }
-                                abort("Internal parse arg error\n");
-                }
-
-        }
+
+                }
+        }
+}
+
+static inline int next_newline(const char * str) {
+        int ret;
+        const char * ptr = strstr(str, "\n");
+        if(!ptr) return MAX;
+
+        /* paranoid */ verify( str <= ptr);
+        intptr_t low = (intptr_t)str;
+        intptr_t hi  = (intptr_t)ptr;
+        ret = hi - low;
+
+        return ret;
 }
 
@@ -150 +188 @@
 // Print usage
 static void printopt(FILE * out, int width, int max, char sn, const char * ln, const char * help) {
+        // check how wide we should be printing
+        // this includes all options and the help message
         int hwidth = max - (11 + width);
         if(hwidth <= 0) hwidth = max;
 
-        char sname[4] = { ' ', ' ', ' ', '\0' };
-        if(sn != '\0') {
-                sname[0] = '-';
-                sname[1] = sn;
-                sname[2] = ',';
-        }
-
-        fprintf(out, "  %s --%-*s   %.*s\n", sname, width, ln, hwidth, help);
-        for() {
-                help += min(strlen(help), hwidth);
-                if('\0' == *help) break;
-                fprintf(out, "%*s%.*s\n", width + 11, "", hwidth, help);
-        }
+        // check which pieces we have
+        bool has_ln = ln && strcmp("", ln);
+        bool has_help = help && strcmp("", help);
+
+        // print the small name if present
+        if(sn != '\0') fprintf(out, "  -%c", sn);
+        else fprintf(out, "    ");
+
+        // print a comma if we have both short and long names
+        if(sn != '\0' && has_ln) fprintf(out, ", ");
+        else fprintf(out, "  ");
+
+        // print the long name if present
+        if(has_ln)        fprintf(out, "--%-*s", width, ln);
+        else if(has_help) fprintf(out, "  %-*s", width, "");
+
+        if(has_help) {
+                // print the help
+                // We need to wrap at the max width, and also indent newlines so everything is nice and pretty
+
+                // for each line to print
+                for() {
+                        //find out if there is a newline
+                        int nextnl = next_newline(help);
+                        int real = min(min(strlen(help), hwidth), nextnl);
+
+                        fprintf(out, "   %.*s", real, help);
+                        // printf("%d %d\n", real, nextnl);
+                        help += real;
+                        if( nextnl == real ) help++;
+                        if('\0' == *help) break;
+                        fprintf(out, "\n%*s", width + 8, "");
+                }
+        }
+        fprintf(out, "\n");
 }
 
 void print_args_usage(cfa_option options[], size_t opt_count, const char * usage, bool error)  __attribute__ ((noreturn)) {
-        usage(cfa_args_argv[0], options, opt_count, usage, error ? stderr : stdout);
+        const array( cfa_option, opt_count ) & arr = (const array( cfa_option, opt_count ) &) *options;
+        usage(cfa_args_argv[0], arr, usage, error ? stderr : stdout);
 }
 
 void print_args_usage(int , char * argv[], cfa_option options[], size_t opt_count, const char * usage, bool error)  __attribute__ ((noreturn)) {
-        usage(argv[0], options, opt_count, usage, error ? stderr : stdout);
-}
-
-static void usage(char * cmd, cfa_option options[], size_t opt_count, const char * help, FILE * out) __attribute__((noreturn)) {
+        const array( cfa_option, opt_count ) & arr = (const array( cfa_option, opt_count ) &) *options;
+        usage(argv[0], arr, usage, error ? stderr : stdout);
+}
+
+forall( [N] ) {
+        void print_args_usage( const array(cfa_option, N ) & options, const char * usage, bool error) {
+                usage(cfa_args_argv[0], options, usage, error ? stderr : stdout);
+        }
+
+        void print_args_usage(int argc, char * argv[], const array( cfa_option, N ) & options, const char * usage, bool error) {
+                usage(argv[0], options, usage, error ? stderr : stdout);
+        }
+}
+
+forall([N])
+static void usage(char * cmd, const array( cfa_option, N ) & options, const char * help, FILE * out) __attribute__((noreturn)) {
         int width = 0;
         {
-                for(i; opt_count) {
+                for(i; N) {
                         if(options[i].long_name) {
                                 int w = strlen(options[i].long_name);
@@ -198 +273 @@
         fprintf(out, "Usage:\n  %s %s\n", cmd, help);
 
-        for(i; opt_count) {
+        for(i; N) {
                 printopt(out, width, max_width, options[i].short_name, options[i].long_name, options[i].help);
         }
@@ -272 +347 @@
 bool parse(const char * arg, int & value) {
         char * end;
-        int r = strtoll(arg, &end, 10);
+
+        errno = 0;
+        long long int r = strtoll(arg, &end, 0);
+        if(errno) return false;
         if(*end != '\0') return false;
+        if(r > (int)MAX) return false;
+        if(r < (int)MIN) return false;
 
         value = r;
@@ -279 +359 @@
 }
 
+static unsigned long long int strict_strtoull( const char * arg, int base) {
+        errno = 0;
+        {
+                const char * in = arg;
+                for() {
+                        if('\0' == *in) {
+                                errno = EINVAL;
+                                return 0;
+                        }
+                        if(!isspace(*in)) break;
+                        in++;
+                }
+                if(!isdigit(*in)) {
+                        errno = EINVAL;
+                        return 0;
+                }
+        }
+
+        *char end;
+        unsigned long long int r = strtoull(arg, &end, base);
+        if(*end != '\0') errno = EINVAL;
+        if(errno) return 0;
+        return r;
+}
+
 bool parse(const char * arg, unsigned & value) {
-        char * end;
-        unsigned long long int r = strtoull(arg, &end, 10);
-        if(*end != '\0') return false;
+        unsigned long long int r = strict_strtoull(arg, 0);
+        if(errno) return false;
         if(r > (unsigned)MAX) return false;
 
@@ -290 +394 @@
 
 bool parse(const char * arg, unsigned long & value) {
-        char * end;
-        unsigned long long int r = strtoull(arg, &end, 10);
-        if(*end != '\0') return false;
+        unsigned long long int r = strict_strtoull(arg, 0);
+        if(errno) return false;
         if(r > (unsigned long)MAX) return false;
 
@@ -300 +403 @@
 
 bool parse(const char * arg, unsigned long long & value) {
-        char * end;
-        unsigned long long int r = strtoull(arg, &end, 10);
-        if(*end != '\0') return false;
-        if(r > (unsigned long long)MAX) return false;
-
-        value = r;
-        return true;
+        unsigned long long int r = strict_strtoull(arg, 0);
+        if(errno) return false;
+        if(r > (unsigned long long)MAX) return false;
+
+        value = r;
+        return true;
 }