From 6892095998d2c86f60c69670107696a623812951 Mon Sep 17 00:00:00 2001 From: Nigel Tao Date: Tue, 3 Mar 2020 11:25:18 +1100 Subject: [PATCH] Have C programs handle flags consistently --- example/gifplayer/gifplayer.c | 118 ++++++++++++---- example/jsonptr/jsonptr.cc | 119 +++++++++------- fuzz/c/fuzzlib/fuzzlib.c | 71 +++++++--- script/adler32-standalone.c | 55 +++++++- script/print-json-token-debug-format.c | 76 ++++++++--- test/c/std/gif.c | 2 +- test/c/std/lzw.c | 2 +- test/c/testlib/testlib.c | 179 ++++++++++++++++--------- 8 files changed, 433 insertions(+), 189 deletions(-) diff --git a/example/gifplayer/gifplayer.c b/example/gifplayer/gifplayer.c index 1b068775..972c2ed1 100644 --- a/example/gifplayer/gifplayer.c +++ b/example/gifplayer/gifplayer.c @@ -71,11 +71,31 @@ micros_since_start(struct timespec* now) { // compiling it. #define WUFFS_IMPLEMENTATION +// Defining the WUFFS_CONFIG__MODULE* macros are optional, but it lets users of +// release/c/etc.c whitelist which parts of Wuffs to build. That file contains +// the entire Wuffs standard library, implementing a variety of codecs and file +// formats. Without this macro definition, an optimizing compiler or linker may +// very well discard Wuffs code for unused codecs, but listing the Wuffs +// modules we use makes that process explicit. Preprocessing means that such +// code simply isn't compiled. +#define WUFFS_CONFIG__MODULES +#define WUFFS_CONFIG__MODULE__BASE +#define WUFFS_CONFIG__MODULE__LZW +#define WUFFS_CONFIG__MODULE__GIF + // If building this program in an environment that doesn't easily accommodate // relative includes, you can use the script/inline-c-relative-includes.go // program to generate a stand-alone C file. #include "../../release/c/wuffs-unsupported-snapshot.c" +#define TRY(error_msg) \ + do { \ + const char* z = error_msg; \ + if (z) { \ + return z; \ + } \ + } while (false) + // Limit the input GIF image to (64 MiB - 1 byte) compressed and 4096 × 4096 // pixels uncompressed. This is a limitation of this example program (which // uses the Wuffs standard library), not a limitation of Wuffs per se. @@ -123,6 +143,55 @@ read_stdin() { // ---- +struct { + int remaining_argc; + char** remaining_argv; + + bool color; + bool quirk_honor_background_color; +} flags = {0}; + +const char* // +parse_flags(int argc, char** argv) { + int c = (argc > 0) ? 1 : 0; // Skip argv[0], the program name. + for (; c < argc; c++) { + char* arg = argv[c]; + if (*arg++ != '-') { + break; + } + + // A double-dash "--foo" is equivalent to a single-dash "-foo". As special + // cases, a bare "-" is not a flag (some programs may interpret it as + // stdin) and a bare "--" means to stop parsing flags. + if (*arg == '\x00') { + break; + } else if (*arg == '-') { + arg++; + if (*arg == '\x00') { + c++; + break; + } + } + + if (!strcmp(arg, "c") || !strcmp(arg, "color")) { + flags.color = true; + continue; + } + if (!strcmp(arg, "quirk_honor_background_color")) { + flags.quirk_honor_background_color = true; + continue; + } + + return "main: unrecognized flag argument"; + } + + flags.remaining_argc = argc - c; + flags.remaining_argv = argv + c; + return NULL; +} + +// ---- + // BYTES_PER_COLOR_PIXEL is long enough to contain "\x1B[38;2;255;255;255mABC" // plus a trailing NUL byte and a few bytes of slack. It starts with a true // color terminal escape code. ABC is three bytes for the UTF-8 representation @@ -131,10 +200,6 @@ read_stdin() { const char* reset_color = "\x1B[0m"; -bool color_flag = false; -bool quirk_honor_background_color_flag = false; -const int stdout_fd = 1; - void // restore_background(wuffs_base__pixel_buffer* pb, wuffs_base__rect_ie_u32 bounds, @@ -243,7 +308,7 @@ try_allocate(wuffs_gif__decoder* dec) { } uint64_t plen = 1 + ((uint64_t)(width) + 1) * (uint64_t)(height); - uint64_t bytes_per_print_pixel = color_flag ? BYTES_PER_COLOR_PIXEL : 1; + uint64_t bytes_per_print_pixel = flags.color ? BYTES_PER_COLOR_PIXEL : 1; if (plen <= ((uint64_t)SIZE_MAX) / bytes_per_print_pixel) { printbuf = wuffs_base__malloc_slice_u8(malloc, plen * bytes_per_print_pixel); @@ -281,7 +346,7 @@ play() { return wuffs_base__status__message(&status); } - if (quirk_honor_background_color_flag) { + if (flags.quirk_honor_background_color) { wuffs_gif__decoder__set_quirk_enabled( &dec, WUFFS_GIF__QUIRK_HONOR_BACKGROUND_COLOR, true); } @@ -360,7 +425,7 @@ play() { break; } - size_t n = color_flag ? print_color_art(&pb) : print_ascii_art(&pb); + size_t n = flags.color ? print_color_art(&pb) : print_ascii_art(&pb); switch (wuffs_base__frame_config__disposal(&fc)) { case WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND: { @@ -424,30 +489,15 @@ play() { return NULL; } -int // -main(int argc, char** argv) { - int i; - for (i = 1; i < argc; i++) { - if (!strcmp(argv[i], "-color")) { - color_flag = true; - } - if (!strcmp(argv[i], "-quirk_honor_background_color")) { - quirk_honor_background_color_flag = true; - } +const char* // +main1(int argc, char** argv) { + TRY(parse_flags(argc, argv)); + if (flags.remaining_argc > 0) { + return "main: bad argument: use \"program < input\", not \"program input\""; } - - const char* status_msg = read_stdin(); - if (status_msg) { - fprintf(stderr, "%s\n", status_msg); - return 1; - } - + TRY(read_stdin()); while (true) { - status_msg = play(); - if (status_msg) { - fprintf(stderr, "%s\n", status_msg); - return 1; - } + TRY(play()); if (num_loops_remaining == 0) { continue; } @@ -456,5 +506,15 @@ main(int argc, char** argv) { break; } } + return NULL; +} + +int // +main(int argc, char** argv) { + const char* z = main1(argc, argv); + if (z) { + fprintf(stderr, "%s\n", z); + return 1; + } return 0; } diff --git a/example/jsonptr/jsonptr.cc b/example/jsonptr/jsonptr.cc index 6b18dad0..c7fe7802 100644 --- a/example/jsonptr/jsonptr.cc +++ b/example/jsonptr/jsonptr.cc @@ -77,10 +77,6 @@ static const char* eod = "main: end of data"; #define INDENT_SPACES_STRING " " #define INDENT_TABS_STRING "\t\t\t\t\t\t\t\t" -bool flag_compact; -size_t flag_indent; -bool flag_tabs; - #ifndef DST_BUFFER_SIZE #define DST_BUFFER_SIZE (32 * 1024) #endif @@ -116,12 +112,70 @@ enum class context { wuffs_json__decoder dec; +struct { + int remaining_argc; + char** remaining_argv; + + bool compact; + size_t indent; + bool tabs; +} flags = {0}; + +const char* // +parse_flags(int argc, char** argv) { + bool explicit_indent = false; + + int c = (argc > 0) ? 1 : 0; // Skip argv[0], the program name. + for (; c < argc; c++) { + char* arg = argv[c]; + if (*arg++ != '-') { + break; + } + + // A double-dash "--foo" is equivalent to a single-dash "-foo". As special + // cases, a bare "-" is not a flag (some programs may interpret it as + // stdin) and a bare "--" means to stop parsing flags. + if (*arg == '\x00') { + break; + } else if (*arg == '-') { + arg++; + if (*arg == '\x00') { + c++; + break; + } + } + + if (!strcmp(arg, "c") || !strcmp(arg, "compact")) { + flags.compact = true; + continue; + } + if (!strncmp(arg, "i=", 2) || !strncmp(arg, "indent=", 7)) { + while (*arg++ != '=') { + } + if (('0' <= arg[0]) && (arg[0] <= '8') && (arg[1] == '\x00')) { + flags.indent = arg[0] - '0'; + explicit_indent = true; + continue; + } + } + if (!strcmp(arg, "t") || !strcmp(arg, "tabs")) { + flags.tabs = true; + continue; + } + + return "main: unrecognized flag argument"; + } + + flags.remaining_argc = argc - c; + flags.remaining_argv = argv + c; + if (!explicit_indent) { + flags.indent = flags.tabs ? 1 : 4; + } + return NULL; +} + const char* // initialize_globals(int argc, char** argv) { - flag_compact = false; - flag_indent = 4; - flag_tabs = false; - dst = wuffs_base__make_io_buffer( wuffs_base__make_slice_u8(dst_array, DST_BUFFER_SIZE), wuffs_base__empty_io_buffer_meta()); @@ -140,38 +194,9 @@ initialize_globals(int argc, char** argv) { ctx = context::none; - int i; - for (i = 1; i < argc; i++) { - if (argv[i][0] != '-') { - return "main: bad argument: use \"jsonptr < foo.json\", not \"jsonptr " - "foo.json\""; - } - - if ((strcmp(argv[i], "-c") == 0) || // - (strcmp(argv[i], "--compact") == 0)) { - flag_compact = true; - continue; - - } else if ((strncmp(argv[i], "-i=", 3) == 0) || // - (strncmp(argv[i], "--indent=", 9) == 0)) { - // Set p to point just after the '='. - char* p = argv[i]; - for (; *p != '='; p++) { - } - p++; - - if (('0' <= p[0]) && (p[0] <= '8') && (p[1] == '\x00')) { - flag_indent = p[0] - '0'; - continue; - } - - } else if ((strcmp(argv[i], "-t") == 0) || // - (strcmp(argv[i], "--tabs") == 0)) { - flag_tabs = true; - continue; - } - - return "main: bad argument"; + TRY(parse_flags(argc, argv)); + if (flags.remaining_argc > 0) { + return "main: bad argument: use \"program < input\", not \"program input\""; } return dec.initialize(sizeof__wuffs_json__decoder(), WUFFS_VERSION, 0) @@ -340,11 +365,11 @@ handle_token(wuffs_base__token t) { // Write preceding whitespace. if ((ctx != context::in_list_after_bracket) && - (ctx != context::in_dict_after_brace) && !flag_compact) { + (ctx != context::in_dict_after_brace) && !flags.compact) { TRY(write_dst("\n", 1)); for (size_t i = 0; i < depth; i++) { - TRY(write_dst(flag_tabs ? INDENT_TABS_STRING : INDENT_SPACES_STRING, - flag_indent)); + TRY(write_dst(flags.tabs ? INDENT_TABS_STRING : INDENT_SPACES_STRING, + flags.indent)); } } @@ -361,17 +386,17 @@ handle_token(wuffs_base__token t) { if (t.link_prev()) { // No-op. } else if (ctx == context::in_dict_after_key) { - TRY(write_dst(": ", flag_compact ? 1 : 2)); + TRY(write_dst(": ", flags.compact ? 1 : 2)); } else if (ctx != context::none) { if ((ctx != context::in_list_after_bracket) && (ctx != context::in_dict_after_brace)) { TRY(write_dst(",", 1)); } - if (!flag_compact) { + if (!flags.compact) { TRY(write_dst("\n", 1)); for (size_t i = 0; i < depth; i++) { - TRY(write_dst(flag_tabs ? INDENT_TABS_STRING : INDENT_SPACES_STRING, - flag_indent)); + TRY(write_dst(flags.tabs ? INDENT_TABS_STRING : INDENT_SPACES_STRING, + flags.indent)); } } } diff --git a/fuzz/c/fuzzlib/fuzzlib.c b/fuzz/c/fuzzlib/fuzzlib.c index ee6af967..35b72735 100644 --- a/fuzz/c/fuzzlib/fuzzlib.c +++ b/fuzz/c/fuzzlib/fuzzlib.c @@ -114,7 +114,47 @@ make_limited_reader(wuffs_base__io_buffer b, uint64_t limit) { #include #include -static bool flag_color; +struct { + int remaining_argc; + char** remaining_argv; + + bool color; +} flags = {0}; + +const char* // +parse_flags(int argc, char** argv) { + int c = (argc > 0) ? 1 : 0; // Skip argv[0], the program name. + for (; c < argc; c++) { + char* arg = argv[c]; + if (*arg++ != '-') { + break; + } + + // A double-dash "--foo" is equivalent to a single-dash "-foo". As special + // cases, a bare "-" is not a flag (some programs may interpret it as + // stdin) and a bare "--" means to stop parsing flags. + if (*arg == '\x00') { + break; + } else if (*arg == '-') { + arg++; + if (*arg == '\x00') { + c++; + break; + } + } + + if (!strcmp(arg, "c") || !strcmp(arg, "color")) { + flags.color = true; + continue; + } + + return "main: unrecognized flag argument"; + } + + flags.remaining_argc = argc - c; + flags.remaining_argv = argv + c; + return NULL; +} static int num_files_processed; @@ -125,7 +165,7 @@ static struct { void // errorf(const char* msg) { - if (flag_color) { + if (flags.color) { printf("\e[31m%s\e[0m\n", msg); } else { printf("%s\n", msg); @@ -151,7 +191,7 @@ visit_dir(int fd) { return 1; } - printf("+dir\n"); + printf("dir\n"); while (true) { struct dirent* e = readdir(d); if (!e) { @@ -202,7 +242,7 @@ visit_reg(int fd, off_t size) { const char* msg = llvmFuzzerTestOneInput((const uint8_t*)(data), size); if (msg) { errorf(msg); - } else if (flag_color) { + } else if (flags.color) { printf("\e[32mok\e[0m\n"); } else { printf("ok\n"); @@ -279,28 +319,17 @@ visit(char* filename) { int // main(int argc, char** argv) { - flag_color = false; num_files_processed = 0; relative_cwd.len = 0; - int i; - for (i = 1; i < argc; i++) { - if (argv[i][0] != '-') { - continue; - } - if ((strcmp(argv[i], "-c") == 0) || // - (strcmp(argv[i], "--color") == 0)) { - flag_color = true; - continue; - } - fprintf(stderr, "FAIL: unrecognized flag argument\n"); + const char* z = parse_flags(argc, argv); + if (z) { + fprintf(stderr, "FAIL: %s\n", z); return 1; } - for (i = 1; i < argc; i++) { - if (argv[i][0] == '-') { - continue; - } - int v = visit(argv[i]); + int i; + for (i = 0; i < flags.remaining_argc; i++) { + int v = visit(flags.remaining_argv[i]); if (v) { return v; } diff --git a/script/adler32-standalone.c b/script/adler32-standalone.c index 786cc552..67260836 100644 --- a/script/adler32-standalone.c +++ b/script/adler32-standalone.c @@ -53,6 +53,48 @@ const char* cc = "cc"; const char* cc_version = "???"; #endif +struct { + int remaining_argc; + char** remaining_argv; + + bool no_check; +} flags = {0}; + +const char* // +parse_flags(int argc, char** argv) { + int c = (argc > 0) ? 1 : 0; // Skip argv[0], the program name. + for (; c < argc; c++) { + char* arg = argv[c]; + if (*arg++ != '-') { + break; + } + + // A double-dash "--foo" is equivalent to a single-dash "-foo". As special + // cases, a bare "-" is not a flag (some programs may interpret it as + // stdin) and a bare "--" means to stop parsing flags. + if (*arg == '\x00') { + break; + } else if (*arg == '-') { + arg++; + if (*arg == '\x00') { + c++; + break; + } + } + + if (!strcmp(arg, "no-check")) { + flags.no_check = true; + continue; + } + + return "main: unrecognized flag argument"; + } + + flags.remaining_argc = argc - c; + flags.remaining_argv = argv + c; + return NULL; +} + static uint32_t // calculate_hash(uint8_t* x_ptr, size_t x_len) { uint32_t s1 = 1; @@ -118,12 +160,10 @@ uint8_t buffer[BUFFER_SIZE] = {0}; int // main(int argc, char** argv) { - bool nocheck = false; - int i; - for (i = 0; i < argc; i++) { - if (!strcmp(argv[i], "-nocheck")) { - nocheck = true; - } + const char* err_msg = parse_flags(argc, argv); + if (err_msg) { + fprintf(stderr, "%s\n", err_msg); + return 1; } struct timeval bench_start_tv; @@ -135,10 +175,11 @@ main(int argc, char** argv) { // https://play.golang.org/p/IU2T58P00C const uint32_t expected_hash_of_1mib_of_zeroes = 0x00f00001UL; + int i; int num_bad = 0; for (i = 0; i < num_reps; i++) { uint32_t actual_hash = calculate_hash(buffer, BUFFER_SIZE); - if (!nocheck && (actual_hash != expected_hash_of_1mib_of_zeroes)) { + if (!flags.no_check && (actual_hash != expected_hash_of_1mib_of_zeroes)) { num_bad++; } } diff --git a/script/print-json-token-debug-format.c b/script/print-json-token-debug-format.c index 1f3d65b6..15125f18 100644 --- a/script/print-json-token-debug-format.c +++ b/script/print-json-token-debug-format.c @@ -108,6 +108,10 @@ wuffs_base__status dec_status; } \ } while (false) +// ignore_return_value suppresses errors from -Wall -Werror. +static void // +ignore_return_value(int ignored) {} + const char* // read_src() { if (src.meta.closed) { @@ -129,6 +133,53 @@ read_src() { // ---- +struct { + int remaining_argc; + char** remaining_argv; + + bool all_tokens; + bool human_readable; +} flags = {0}; + +const char* // +parse_flags(int argc, char** argv) { + int c = (argc > 0) ? 1 : 0; // Skip argv[0], the program name. + for (; c < argc; c++) { + char* arg = argv[c]; + if (*arg++ != '-') { + break; + } + + // A double-dash "--foo" is equivalent to a single-dash "-foo". As special + // cases, a bare "-" is not a flag (some programs may interpret it as + // stdin) and a bare "--" means to stop parsing flags. + if (*arg == '\x00') { + break; + } else if (*arg == '-') { + arg++; + if (*arg == '\x00') { + c++; + break; + } + } + + if (!strcmp(arg, "a") || !strcmp(arg, "all-tokens")) { + flags.all_tokens = true; + continue; + } + if (!strcmp(arg, "h") || !strcmp(arg, "human-readable")) { + flags.human_readable = true; + continue; + } + + return "main: unrecognized flag argument"; + } + + flags.remaining_argc = argc - c; + flags.remaining_argv = argv + c; + return NULL; +} + const char* vbc_names[8] = { "0:Filler..........", // "1:Structure.......", // @@ -148,20 +199,9 @@ const int base38_decode[38] = { const char* // main1(int argc, char** argv) { - bool all_tokens = false; - bool human_readable = false; - int i; - for (i = 1; i < argc; i++) { - if ((strcmp(argv[i], "-a") == 0) || - (strcmp(argv[i], "--all-tokens") == 0)) { - all_tokens = true; - continue; - } - if ((strcmp(argv[i], "-h") == 0) || - (strcmp(argv[i], "--human-readable") == 0)) { - human_readable = true; - continue; - } + TRY(parse_flags(argc, argv)); + if (flags.remaining_argc > 0) { + return "main: bad argument: use \"program < input\", not \"program input\""; } src = wuffs_base__make_io_buffer( @@ -187,7 +227,7 @@ main1(int argc, char** argv) { wuffs_base__token* t = &tok.data.ptr[tok.meta.ri++]; uint16_t len = wuffs_base__token__length(t); - if (all_tokens || (wuffs_base__token__value(t) != 0)) { + if (flags.all_tokens || (wuffs_base__token__value(t) != 0)) { uint8_t lp = wuffs_base__token__link_prev(t) ? 1 : 0; uint8_t ln = wuffs_base__token__link_next(t) ? 1 : 0; uint32_t vmajor = wuffs_base__token__value_major(t); @@ -195,7 +235,7 @@ main1(int argc, char** argv) { uint8_t vbc = wuffs_base__token__value_base_category(t); uint32_t vbd = wuffs_base__token__value_base_detail(t); - if (human_readable) { + if (flags.human_readable) { printf("pos=0x%08" PRIX32 " len=0x%04" PRIX16 " link=0b%d%d ", (uint32_t)(pos), len, (int)(lp), (int)(ln)); @@ -213,7 +253,7 @@ main1(int argc, char** argv) { vmajor, base38_decode[m0], base38_decode[m1], base38_decode[m2], base38_decode[m3], vminor); } else { - printf("vbc=%s vbd=0x%06" PRIX32 "\n", vbc_names[vbc & 7], vbd); + printf("vbc=%s. vbd=0x%06" PRIX32 "\n", vbc_names[vbc & 7], vbd); } } else { @@ -230,7 +270,7 @@ main1(int argc, char** argv) { wuffs_base__store_u24be__no_bounds_check(&buf[0xD], vbd); } const int stdout_fd = 1; - write(stdout_fd, &buf[0], 16); + ignore_return_value(write(stdout_fd, &buf[0], 16)); } } diff --git a/test/c/std/gif.c b/test/c/std/gif.c index e70be1fe..7b365e15 100644 --- a/test/c/std/gif.c +++ b/test/c/std/gif.c @@ -2135,7 +2135,7 @@ do_bench_gif_decode(const char* (*decode_func)(wuffs_base__io_buffer*, bench_start(); uint64_t n_bytes = 0; uint64_t i; - uint64_t iters = iters_unscaled * iterscale; + uint64_t iters = iters_unscaled * flags.iterscale; for (i = 0; i < iters; i++) { have.meta.wi = 0; src.meta.ri = 0; diff --git a/test/c/std/lzw.c b/test/c/std/lzw.c index 129ddb6c..afad3979 100644 --- a/test/c/std/lzw.c +++ b/test/c/std/lzw.c @@ -406,7 +406,7 @@ do_bench_wuffs_lzw_decode(const char* filename, uint64_t iters_unscaled) { bench_start(); uint64_t n_bytes = 0; uint64_t i; - uint64_t iters = iters_unscaled * iterscale; + uint64_t iters = iters_unscaled * flags.iterscale; for (i = 0; i < iters; i++) { have.meta.wi = 0; src.meta.ri = 1; // Skip the literal width. diff --git a/test/c/testlib/testlib.c b/test/c/testlib/testlib.c index fe61b707..592c847d 100644 --- a/test/c/testlib/testlib.c +++ b/test/c/testlib/testlib.c @@ -106,11 +106,103 @@ char fail_msg[65536] = {0}; int tests_run = 0; -uint64_t iterscale = 100; +struct { + int remaining_argc; + char** remaining_argv; + + bool bench; + const char* focus; + uint64_t iterscale; + int reps; +} flags = {0}; + +const char* // +parse_flags(int argc, char** argv) { + bool explicit_iterscale = false; + bool explicit_reps = false; + + int c = (argc > 0) ? 1 : 0; // Skip argv[0], the program name. + for (; c < argc; c++) { + char* arg = argv[c]; + if (*arg++ != '-') { + break; + } + + // A double-dash "--foo" is equivalent to a single-dash "-foo". As special + // cases, a bare "-" is not a flag (some programs may interpret it as + // stdin) and a bare "--" means to stop parsing flags. + if (*arg == '\x00') { + break; + } else if (*arg == '-') { + arg++; + if (*arg == '\x00') { + c++; + break; + } + } + + if (!strcmp(arg, "bench")) { + flags.bench = true; + continue; + } + + if (!strncmp(arg, "focus=", 6)) { + flags.focus = arg + 6; + continue; + } + + if (!strncmp(arg, "iterscale=", 10)) { + arg += 10; + if (!*arg) { + return "missing -iterscale=N value"; + } + char* end = NULL; + long int n = strtol(arg, &end, 10); + if (*end) { + return "invalid -iterscale=N value"; + } + if ((n < 0) || (1000000 < n)) { + return "out-of-range -iterscale=N value"; + } + flags.iterscale = n; + explicit_iterscale = true; + continue; + } + + if (!strncmp(arg, "reps=", 5)) { + arg += 5; + if (!*arg) { + return "missing -reps=N value"; + } + char* end = NULL; + long int n = strtol(arg, &end, 10); + if (*end) { + return "invalid -reps=N value"; + } + if ((n < 0) || (1000000 < n)) { + return "out-of-range -reps=N value"; + } + flags.reps = n; + explicit_reps = true; + continue; + } + + return "unrecognized flag argument"; + } + + flags.remaining_argc = argc - c; + flags.remaining_argv = argv + c; + if (!explicit_iterscale) { + flags.iterscale = 100; + } + if (!explicit_reps) { + flags.reps = 5; + } + return NULL; +} const char* proc_package_name = "unknown_package_name"; const char* proc_func_name = "unknown_func_name"; -const char* focus = ""; bool in_focus = false; #define CHECK_FOCUS(func_name) \ @@ -122,8 +214,8 @@ bool in_focus = false; bool // check_focus() { - const char* p = focus; - if (!*p) { + const char* p = flags.focus; + if (!p || !*p) { return true; } size_t n = strlen(proc_func_name); @@ -295,66 +387,20 @@ test_main(int argc, char** argv, proc* tests, proc* benches) { return 1; } - bool bench = false; - int reps = 5; - - int i; - for (i = 1; i < argc; i++) { - const char* arg = argv[i]; - size_t arg_len = strlen(arg); - if (!strcmp(arg, "-bench")) { - bench = true; - - } else if ((arg_len >= 7) && !strncmp(arg, "-focus=", 7)) { - focus = arg + 7; - - } else if ((arg_len >= 11) && !strncmp(arg, "-iterscale=", 11)) { - arg += 11; - if (!*arg) { - fprintf(stderr, "missing -iterscale=N value\n"); - return 1; - } - char* end = NULL; - long int n = strtol(arg, &end, 10); - if (*end) { - fprintf(stderr, "invalid -iterscale=N value\n"); - return 1; - } - if ((n < 0) || (1000000 < n)) { - fprintf(stderr, "out-of-range -iterscale=N value\n"); - return 1; - } - iterscale = n; - - } else if ((arg_len >= 6) && !strncmp(arg, "-reps=", 6)) { - arg += 6; - if (!*arg) { - fprintf(stderr, "missing -reps=N value\n"); - return 1; - } - char* end = NULL; - long int n = strtol(arg, &end, 10); - if (*end) { - fprintf(stderr, "invalid -reps=N value\n"); - return 1; - } - if ((n < 0) || (1000000 < n)) { - fprintf(stderr, "out-of-range -reps=N value\n"); - return 1; - } - reps = n; - - } else { - fprintf(stderr, "unknown flag \"%s\"\n", arg); - return 1; - } + status = parse_flags(argc, argv); + if (status) { + fprintf(stderr, "%s\n", status); + return 1; + } + if (flags.remaining_argc > 0) { + fprintf(stderr, "unexpected (non-flag) argument\n"); + return 1; } + int reps = 1; proc* procs = tests; - if (!bench) { - reps = 1; - } else { - reps++; // +1 for the warm up run. + if (flags.bench) { + reps = flags.reps + 1; // +1 for the warm up run. procs = benches; printf("# %s\n# %s version %s\n#\n", proc_package_name, cc, cc_version); printf( @@ -365,6 +411,7 @@ test_main(int argc, char** argv, proc* tests, proc* benches) { "# install Go, then run \"go get golang.org/x/perf/cmd/benchstat\".\n"); } + int i; for (i = 0; i < reps; i++) { bench_warm_up = i == 0; proc* p; @@ -388,9 +435,9 @@ test_main(int argc, char** argv, proc* tests, proc* benches) { if (i != 0) { continue; } - if (bench) { + if (flags.bench) { printf("# %d benchmarks, 1+%d reps per benchmark, iterscale=%d\n", - tests_run, reps - 1, (int)(iterscale)); + tests_run, flags.reps, (int)(flags.iterscale)); } else { printf("%-16s%-8sPASS (%d tests)\n", proc_package_name, cc, tests_run); } @@ -866,7 +913,8 @@ do_bench_io_buffers(const char* (*codec_func)(wuffs_base__io_buffer*, uint64_t rlimit, uint64_t iters_unscaled) { return proc_io_buffers(codec_func, wuffs_initialize_flags, tcounter, gt, - wlimit, rlimit, iters_unscaled * iterscale, true); + wlimit, rlimit, iters_unscaled * flags.iterscale, + true); } const char* // @@ -882,7 +930,8 @@ do_bench_token_decoder(const char* (*codec_func)(wuffs_base__token_buffer*, uint64_t rlimit, uint64_t iters_unscaled) { return proc_token_decoder(codec_func, wuffs_initialize_flags, tcounter, gt, - wlimit, rlimit, iters_unscaled * iterscale, true); + wlimit, rlimit, iters_unscaled * flags.iterscale, + true); } const char* //