mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-19 16:47:28 +01:00
Have C programs handle flags consistently
This commit is contained in:
1 parent
f928944d64
commit
6892095998
8 files changed
+433
-189
No files matched your search
@@ -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;
|
||||
}
|
||||
+72
-47
@@ -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));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+50
-21
@@ -114,7 +114,47 @@ make_limited_reader(wuffs_base__io_buffer b, uint64_t limit) {
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
@@ -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++;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+1
-1
@@ -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;
|
||||
|
||||
+1
-1
@@ -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.
|
||||
|
||||
+114
-65
@@ -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* //
|
||||
|
||||
Reference in new issue
Block a user