diff --git a/example/crc32/crc32.cc b/example/crc32/crc32.cc index dd4089ad..49f4a096 100644 --- a/example/crc32/crc32.cc +++ b/example/crc32/crc32.cc @@ -54,7 +54,7 @@ for a C++ compiler $CXX, such as clang++ or g++. #define SRC_BUFFER_ARRAY_SIZE (32 * 1024) #endif -uint8_t src_buffer_array[SRC_BUFFER_ARRAY_SIZE]; +uint8_t g_src_buffer_array[SRC_BUFFER_ARRAY_SIZE]; int // main(int argc, char** argv) { @@ -66,10 +66,10 @@ main(int argc, char** argv) { } while (true) { - size_t n = - fread(src_buffer_array, sizeof(uint8_t), SRC_BUFFER_ARRAY_SIZE, stdin); + size_t n = fread(g_src_buffer_array, sizeof(uint8_t), SRC_BUFFER_ARRAY_SIZE, + stdin); uint32_t checksum = - h.update_u32(wuffs_base__make_slice_u8(src_buffer_array, n)); + h.update_u32(wuffs_base__make_slice_u8(g_src_buffer_array, n)); if (feof(stdin)) { printf("%08" PRIx32 "\n", checksum); return 0; diff --git a/example/gifplayer/gifplayer.c b/example/gifplayer/gifplayer.c index 01f599c1..0ad7154a 100644 --- a/example/gifplayer/gifplayer.c +++ b/example/gifplayer/gifplayer.c @@ -41,16 +41,16 @@ support true color: https://gist.github.com/XVilka/8346728 #include #define WUFFS_EXAMPLE_USE_TIMERS -bool started = false; -struct timespec start_time = {0}; +bool g_started = false; +struct timespec g_start_time = {0}; int64_t // micros_since_start(struct timespec* now) { - if (!started) { + if (!g_started) { return 0; } - int64_t nanos = (int64_t)(now->tv_sec - start_time.tv_sec) * 1000000000 + - (int64_t)(now->tv_nsec - start_time.tv_nsec); + int64_t nanos = (int64_t)(now->tv_sec - g_start_time.tv_sec) * 1000000000 + + (int64_t)(now->tv_nsec - g_start_time.tv_nsec); if (nanos < 0) { return 0; } @@ -109,29 +109,29 @@ micros_since_start(struct timespec* now) { #define MAX_DIMENSION (4096) #endif -uint8_t src_buffer_array[SRC_BUFFER_ARRAY_SIZE] = {0}; -size_t src_len = 0; +uint8_t g_src_buffer_array[SRC_BUFFER_ARRAY_SIZE] = {0}; +size_t g_src_len = 0; -uint8_t* curr_dst_buffer = NULL; -uint8_t* prev_dst_buffer = NULL; -size_t dst_len; // Length in bytes. +uint8_t* g_curr_dst_buffer = NULL; +uint8_t* g_prev_dst_buffer = NULL; +size_t g_dst_len; // Length in bytes. -wuffs_base__slice_u8 workbuf = {0}; -wuffs_base__slice_u8 printbuf = {0}; +wuffs_base__slice_u8 g_workbuf = {0}; +wuffs_base__slice_u8 g_printbuf = {0}; -bool first_play = true; -uint32_t num_loops_remaining = 0; -wuffs_base__image_config ic = {0}; -wuffs_base__pixel_buffer pb = {0}; +bool g_first_play = true; +uint32_t g_num_loops_remaining = 0; +wuffs_base__image_config g_ic = {0}; +wuffs_base__pixel_buffer g_pb = {0}; -wuffs_base__flicks cumulative_delay_micros = 0; +wuffs_base__flicks g_cumulative_delay_micros = 0; const char* // read_stdin() { - while (src_len < SRC_BUFFER_ARRAY_SIZE) { - size_t n = fread(src_buffer_array + src_len, sizeof(uint8_t), - SRC_BUFFER_ARRAY_SIZE - src_len, stdin); - src_len += n; + while (g_src_len < SRC_BUFFER_ARRAY_SIZE) { + size_t n = fread(g_src_buffer_array + g_src_len, sizeof(uint8_t), + SRC_BUFFER_ARRAY_SIZE - g_src_len, stdin); + g_src_len += n; if (feof(stdin)) { return NULL; } else if (ferror(stdin)) { @@ -149,7 +149,7 @@ struct { bool color; bool quirk_honor_background_color; -} flags = {0}; +} g_flags = {0}; const char* // parse_flags(int argc, char** argv) { @@ -174,19 +174,19 @@ parse_flags(int argc, char** argv) { } if (!strcmp(arg, "c") || !strcmp(arg, "color")) { - flags.color = true; + g_flags.color = true; continue; } if (!strcmp(arg, "quirk_honor_background_color")) { - flags.quirk_honor_background_color = true; + g_flags.quirk_honor_background_color = true; continue; } return "main: unrecognized flag argument"; } - flags.remaining_argc = argc - c; - flags.remaining_argv = argv + c; + g_flags.remaining_argc = argc - c; + g_flags.remaining_argv = argv + c; return NULL; } @@ -198,7 +198,7 @@ parse_flags(int argc, char** argv) { // "\xE2\x96\x88" of "█", U+2588 FULL BLOCK. #define BYTES_PER_COLOR_PIXEL 32 -const char* reset_color = "\x1B[0m"; +const char* g_reset_color = "\x1B[0m"; void // restore_background(wuffs_base__pixel_buffer* pb, @@ -208,7 +208,7 @@ restore_background(wuffs_base__pixel_buffer* pb, size_t y; for (y = bounds.min_incl_y; y < bounds.max_excl_y; y++) { size_t x; - uint8_t* d = curr_dst_buffer + (y * width4) + (bounds.min_incl_x * 4); + uint8_t* d = g_curr_dst_buffer + (y * width4) + (bounds.min_incl_x * 4); for (x = bounds.min_incl_x; x < bounds.max_excl_x; x++) { wuffs_base__store_u32le__no_bounds_check(d, background_color); d += sizeof(wuffs_base__color_u32_argb_premul); @@ -221,8 +221,8 @@ print_ascii_art(wuffs_base__pixel_buffer* pb) { uint32_t width = wuffs_base__pixel_config__width(&pb->pixcfg); uint32_t height = wuffs_base__pixel_config__height(&pb->pixcfg); - uint8_t* d = curr_dst_buffer; - uint8_t* p = printbuf.ptr; + uint8_t* d = g_curr_dst_buffer; + uint8_t* p = g_printbuf.ptr; *p++ = '\n'; uint32_t y; for (y = 0; y < height; y++) { @@ -242,7 +242,7 @@ print_ascii_art(wuffs_base__pixel_buffer* pb) { } *p++ = '\n'; } - return p - printbuf.ptr; + return p - g_printbuf.ptr; } size_t // @@ -250,10 +250,10 @@ print_color_art(wuffs_base__pixel_buffer* pb) { uint32_t width = wuffs_base__pixel_config__width(&pb->pixcfg); uint32_t height = wuffs_base__pixel_config__height(&pb->pixcfg); - uint8_t* d = curr_dst_buffer; - uint8_t* p = printbuf.ptr; + uint8_t* d = g_curr_dst_buffer; + uint8_t* p = g_printbuf.ptr; *p++ = '\n'; - p += sprintf((char*)p, "%s", reset_color); + p += sprintf((char*)p, "%s", g_reset_color); uint32_t y; for (y = 0; y < height; y++) { uint32_t x; @@ -270,50 +270,50 @@ print_color_art(wuffs_base__pixel_buffer* pb) { } *p++ = '\n'; } - p += sprintf((char*)p, "%s", reset_color); - return p - printbuf.ptr; + p += sprintf((char*)p, "%s", g_reset_color); + return p - g_printbuf.ptr; } // ---- const char* // try_allocate(wuffs_gif__decoder* dec) { - uint32_t width = wuffs_base__pixel_config__width(&ic.pixcfg); - uint32_t height = wuffs_base__pixel_config__height(&ic.pixcfg); + uint32_t width = wuffs_base__pixel_config__width(&g_ic.pixcfg); + uint32_t height = wuffs_base__pixel_config__height(&g_ic.pixcfg); uint64_t num_pixels = ((uint64_t)width) * ((uint64_t)height); if (num_pixels > (SIZE_MAX / sizeof(wuffs_base__color_u32_argb_premul))) { return "could not allocate dst buffer"; } - dst_len = num_pixels * sizeof(wuffs_base__color_u32_argb_premul); - curr_dst_buffer = (uint8_t*)calloc(dst_len, 1); - if (!curr_dst_buffer) { + g_dst_len = num_pixels * sizeof(wuffs_base__color_u32_argb_premul); + g_curr_dst_buffer = (uint8_t*)calloc(g_dst_len, 1); + if (!g_curr_dst_buffer) { return "could not allocate curr-dst buffer"; } - prev_dst_buffer = (uint8_t*)malloc(dst_len); - if (!prev_dst_buffer) { + g_prev_dst_buffer = (uint8_t*)malloc(g_dst_len); + if (!g_prev_dst_buffer) { return "could not allocate prev-dst buffer"; } uint64_t workbuf_len_max_incl = wuffs_gif__decoder__workbuf_len(dec).max_incl; if (workbuf_len_max_incl > 0) { - workbuf = wuffs_base__malloc_slice_u8( + g_workbuf = wuffs_base__malloc_slice_u8( malloc, wuffs_gif__decoder__workbuf_len(dec).max_incl); - if (!workbuf.ptr) { + if (!g_workbuf.ptr) { return "could not allocate work buffer"; } } else { - workbuf = wuffs_base__make_slice_u8(NULL, 0); + g_workbuf = wuffs_base__make_slice_u8(NULL, 0); } uint64_t plen = 1 + ((uint64_t)(width) + 1) * (uint64_t)(height); - uint64_t bytes_per_print_pixel = flags.color ? BYTES_PER_COLOR_PIXEL : 1; + uint64_t bytes_per_print_pixel = g_flags.color ? BYTES_PER_COLOR_PIXEL : 1; if (plen <= ((uint64_t)SIZE_MAX) / bytes_per_print_pixel) { - printbuf = + g_printbuf = wuffs_base__malloc_slice_u8(malloc, plen * bytes_per_print_pixel); } - if (!printbuf.ptr) { + if (!g_printbuf.ptr) { return "could not allocate print buffer"; } @@ -324,15 +324,15 @@ const char* // allocate(wuffs_gif__decoder* dec) { const char* status_msg = try_allocate(dec); if (status_msg) { - free(printbuf.ptr); - printbuf = wuffs_base__make_slice_u8(NULL, 0); - free(workbuf.ptr); - workbuf = wuffs_base__make_slice_u8(NULL, 0); - free(prev_dst_buffer); - prev_dst_buffer = NULL; - free(curr_dst_buffer); - curr_dst_buffer = NULL; - dst_len = 0; + free(g_printbuf.ptr); + g_printbuf = wuffs_base__make_slice_u8(NULL, 0); + free(g_workbuf.ptr); + g_workbuf = wuffs_base__make_slice_u8(NULL, 0); + free(g_prev_dst_buffer); + g_prev_dst_buffer = NULL; + free(g_curr_dst_buffer); + g_curr_dst_buffer = NULL; + g_dst_len = 0; } return status_msg; } @@ -346,36 +346,36 @@ play() { return wuffs_base__status__message(&status); } - if (flags.quirk_honor_background_color) { + if (g_flags.quirk_honor_background_color) { wuffs_gif__decoder__set_quirk_enabled( &dec, WUFFS_GIF__QUIRK_HONOR_BACKGROUND_COLOR, true); } wuffs_base__io_buffer src; - src.data.ptr = src_buffer_array; - src.data.len = src_len; - src.meta.wi = src_len; + src.data.ptr = &g_src_buffer_array[0]; + src.data.len = g_src_len; + src.meta.wi = g_src_len; src.meta.ri = 0; src.meta.pos = 0; src.meta.closed = true; - if (first_play) { - status = wuffs_gif__decoder__decode_image_config(&dec, &ic, &src); + if (g_first_play) { + status = wuffs_gif__decoder__decode_image_config(&dec, &g_ic, &src); if (!wuffs_base__status__is_ok(&status)) { return wuffs_base__status__message(&status); } - if (!wuffs_base__image_config__is_valid(&ic)) { + if (!wuffs_base__image_config__is_valid(&g_ic)) { return "invalid image configuration"; } - uint32_t width = wuffs_base__pixel_config__width(&ic.pixcfg); - uint32_t height = wuffs_base__pixel_config__height(&ic.pixcfg); + uint32_t width = wuffs_base__pixel_config__width(&g_ic.pixcfg); + uint32_t height = wuffs_base__pixel_config__height(&g_ic.pixcfg); if ((width > MAX_DIMENSION) || (height > MAX_DIMENSION)) { return "image dimensions are too large"; } // Override the source's indexed pixel format to be non-indexed. wuffs_base__pixel_config__set( - &ic.pixcfg, WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL, + &g_ic.pixcfg, WUFFS_BASE__PIXEL_FORMAT__BGRA_PREMUL, WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, width, height); const char* msg = allocate(&dec); @@ -383,7 +383,8 @@ play() { return msg; } status = wuffs_base__pixel_buffer__set_from_slice( - &pb, &ic.pixcfg, wuffs_base__make_slice_u8(curr_dst_buffer, dst_len)); + &g_pb, &g_ic.pixcfg, + wuffs_base__make_slice_u8(g_curr_dst_buffer, g_dst_len)); if (!wuffs_base__status__is_ok(&status)) { return wuffs_base__status__message(&status); } @@ -404,8 +405,8 @@ play() { wuffs_base__color_u32_argb_premul background_color = wuffs_base__frame_config__background_color(&fc); size_t i; - size_t n = dst_len / sizeof(wuffs_base__color_u32_argb_premul); - uint8_t* p = curr_dst_buffer; + size_t n = g_dst_len / sizeof(wuffs_base__color_u32_argb_premul); + uint8_t* p = g_curr_dst_buffer; for (i = 0; i < n; i++) { wuffs_base__store_u32le__no_bounds_check(p, background_color); p += sizeof(wuffs_base__color_u32_argb_premul); @@ -414,33 +415,33 @@ play() { switch (wuffs_base__frame_config__disposal(&fc)) { case WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS: { - memcpy(prev_dst_buffer, curr_dst_buffer, dst_len); + memcpy(g_prev_dst_buffer, g_curr_dst_buffer, g_dst_len); break; } } wuffs_base__status decode_frame_status = wuffs_gif__decoder__decode_frame( - &dec, &pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC_OVER, workbuf, NULL); + &dec, &g_pb, &src, WUFFS_BASE__PIXEL_BLEND__SRC_OVER, g_workbuf, NULL); if (decode_frame_status.repr == wuffs_base__note__end_of_data) { break; } - size_t n = flags.color ? print_color_art(&pb) : print_ascii_art(&pb); + size_t n = g_flags.color ? print_color_art(&g_pb) : print_ascii_art(&g_pb); switch (wuffs_base__frame_config__disposal(&fc)) { case WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_BACKGROUND: { - restore_background(&pb, wuffs_base__frame_config__bounds(&fc), + restore_background(&g_pb, wuffs_base__frame_config__bounds(&fc), wuffs_base__frame_config__background_color(&fc)); break; } case WUFFS_BASE__ANIMATION_DISPOSAL__RESTORE_PREVIOUS: { - uint8_t* swap = curr_dst_buffer; - curr_dst_buffer = prev_dst_buffer; - prev_dst_buffer = swap; + uint8_t* swap = g_curr_dst_buffer; + g_curr_dst_buffer = g_prev_dst_buffer; + g_prev_dst_buffer = swap; wuffs_base__status status = wuffs_base__pixel_buffer__set_from_slice( - &pb, &ic.pixcfg, - wuffs_base__make_slice_u8(curr_dst_buffer, dst_len)); + &g_pb, &g_ic.pixcfg, + wuffs_base__make_slice_u8(g_curr_dst_buffer, g_dst_len)); if (!wuffs_base__status__is_ok(&status)) { return wuffs_base__status__message(&status); } @@ -449,28 +450,28 @@ play() { } #if defined(WUFFS_EXAMPLE_USE_TIMERS) - if (started) { + if (g_started) { struct timespec now; if (clock_gettime(CLOCK_MONOTONIC, &now)) { return strerror(errno); } int64_t elapsed_micros = micros_since_start(&now); - if (cumulative_delay_micros > elapsed_micros) { - usleep(cumulative_delay_micros - elapsed_micros); + if (g_cumulative_delay_micros > elapsed_micros) { + usleep(g_cumulative_delay_micros - elapsed_micros); } } else { - if (clock_gettime(CLOCK_MONOTONIC, &start_time)) { + if (clock_gettime(CLOCK_MONOTONIC, &g_start_time)) { return strerror(errno); } - started = true; + g_started = true; } #endif - fwrite(printbuf.ptr, sizeof(uint8_t), n, stdout); + fwrite(g_printbuf.ptr, sizeof(uint8_t), n, stdout); fflush(stdout); - cumulative_delay_micros += + g_cumulative_delay_micros += (1000 * wuffs_base__frame_config__duration(&fc)) / WUFFS_BASE__FLICKS_PER_MILLISECOND; @@ -481,9 +482,9 @@ play() { } } - if (first_play) { - first_play = false; - num_loops_remaining = wuffs_gif__decoder__num_animation_loops(&dec); + if (g_first_play) { + g_first_play = false; + g_num_loops_remaining = wuffs_gif__decoder__num_animation_loops(&dec); } return NULL; @@ -492,17 +493,17 @@ play() { const char* // main1(int argc, char** argv) { TRY(parse_flags(argc, argv)); - if (flags.remaining_argc > 0) { + if (g_flags.remaining_argc > 0) { return "main: bad argument: use \"program < input\", not \"program input\""; } TRY(read_stdin()); while (true) { TRY(play()); - if (num_loops_remaining == 0) { + if (g_num_loops_remaining == 0) { continue; } - num_loops_remaining--; - if (num_loops_remaining == 0) { + g_num_loops_remaining--; + if (g_num_loops_remaining == 0) { break; } } diff --git a/example/imageviewer/imageviewer.c b/example/imageviewer/imageviewer.c index 4b5fe4dd..1447ceef 100644 --- a/example/imageviewer/imageviewer.c +++ b/example/imageviewer/imageviewer.c @@ -69,8 +69,6 @@ The Escape key quits. #define NUM_BACKGROUND_COLORS 3 #define SRC_BUFFER_ARRAY_SIZE (64 * 1024) -// Global variable names start with a "g_" prefix. - wuffs_base__color_u32_argb_premul g_background_colors[NUM_BACKGROUND_COLORS] = { 0xFF000000, 0xFFFFFFFF, diff --git a/example/jsonfindptrs/jsonfindptrs.cc b/example/jsonfindptrs/jsonfindptrs.cc index 73ed7ad2..325661e1 100644 --- a/example/jsonfindptrs/jsonfindptrs.cc +++ b/example/jsonfindptrs/jsonfindptrs.cc @@ -18,7 +18,7 @@ jsonfindptrs reads UTF-8 JSON from stdin and writes every node's JSON Pointer (RFC 6901) to stdout. -See the "const char* usage" string below for details. +See the "const char* g_usage" string below for details. ---- @@ -97,7 +97,7 @@ for a C++ compiler $CXX, such as clang++ or g++. } \ } while (false) -static const char* usage = +static const char* g_usage = "Usage: jsonfindptrs -flags input.json\n" "\n" "Flags:\n" @@ -177,11 +177,11 @@ struct { uint32_t max_output_depth; bool strict_json_pointer_syntax; -} flags = {0}; +} g_flags = {0}; std::string // parse_flags(int argc, char** argv) { - flags.max_output_depth = 0xFFFFFFFF; + g_flags.max_output_depth = 0xFFFFFFFF; int c = (argc > 0) ? 1 : 0; // Skip argv[0], the program name. for (; c < argc; c++) { @@ -204,7 +204,7 @@ parse_flags(int argc, char** argv) { } if (!strcmp(arg, "o") || !strcmp(arg, "max-output-depth")) { - flags.max_output_depth = 1; + g_flags.max_output_depth = 1; continue; } else if (!strncmp(arg, "o=", 2) || !strncmp(arg, "max-output-depth=", 16)) { @@ -213,21 +213,21 @@ parse_flags(int argc, char** argv) { wuffs_base__result_u64 u = wuffs_base__parse_number_u64( wuffs_base__make_slice_u8((uint8_t*)arg, strlen(arg))); if (wuffs_base__status__is_ok(&u.status) && (u.value <= 0xFFFFFFFF)) { - flags.max_output_depth = (uint32_t)(u.value); + g_flags.max_output_depth = (uint32_t)(u.value); continue; } - return usage; + return g_usage; } if (!strcmp(arg, "s") || !strcmp(arg, "strict-json-pointer-syntax")) { - flags.strict_json_pointer_syntax = true; + g_flags.strict_json_pointer_syntax = true; continue; } - return usage; + return g_usage; } - flags.remaining_argc = argc - c; - flags.remaining_argv = argv + c; + g_flags.remaining_argc = argc - c; + g_flags.remaining_argv = argv + c; return ""; } @@ -698,13 +698,13 @@ escape_needed: e += "~1"; break; case '\n': - if (flags.strict_json_pointer_syntax) { + if (g_flags.strict_json_pointer_syntax) { return ""; } e += "~n"; break; case '\r': - if (flags.strict_json_pointer_syntax) { + if (g_flags.strict_json_pointer_syntax) { return ""; } e += "~r"; @@ -720,7 +720,7 @@ escape_needed: std::string // print_json_pointers(JsonThing& jt, std::string s, uint32_t depth) { std::cout << s << std::endl; - if (depth++ >= flags.max_output_depth) { + if (depth++ >= g_flags.max_output_depth) { return ""; } @@ -752,10 +752,10 @@ main1(int argc, char** argv) { TRY(parse_flags(argc, argv)); int input_file_descriptor = 0; // A 0 default means stdin. - if (flags.remaining_argc > 1) { - return usage; - } else if (flags.remaining_argc == 1) { - const char* arg = flags.remaining_argv[0]; + if (g_flags.remaining_argc > 1) { + return g_usage; + } else if (g_flags.remaining_argc == 1) { + const char* arg = g_flags.remaining_argv[0]; input_file_descriptor = open(arg, O_RDONLY); if (input_file_descriptor < 0) { return std::string("main: cannot read ") + arg + ": " + strerror(errno); diff --git a/example/jsonptr/jsonptr.cc b/example/jsonptr/jsonptr.cc index e9ba1512..9fd764fd 100644 --- a/example/jsonptr/jsonptr.cc +++ b/example/jsonptr/jsonptr.cc @@ -19,7 +19,7 @@ jsonptr is a JSON formatter (pretty-printer) that supports the JSON Pointer (RFC 6901) query syntax. It reads UTF-8 JSON from stdin and writes canonicalized, formatted UTF-8 JSON to stdout. -See the "const char* usage" string below for details. +See the "const char* g_usage" string below for details. ---- @@ -60,7 +60,7 @@ After modifying this program, run "build-example.sh example/jsonptr/" and then This program uses Wuffs' JSON decoder at a relatively low level, processing the decoder's token-stream output individually. The core loop, in pseudo-code, is "for_each_token { handle_token(etc); }", where the handle_token function -changes global state (e.g. the `depth` and `context` variables) and prints +changes global state (e.g. the `g_depth` and `g_ctx` variables) and prints output text based on that state and the token's source text. Notably, handle_token is not recursive, even though JSON values can nest. @@ -140,9 +140,9 @@ for a C++ compiler $CXX, such as clang++ or g++. } \ } while (false) -static const char* eod = "main: end of data"; +static const char* g_eod = "main: end of data"; -static const char* usage = +static const char* g_usage = "Usage: jsonptr -flags input.json\n" "\n" "Flags:\n" @@ -237,15 +237,15 @@ static const char* usage = #define WORK_BUFFER_ARRAY_SIZE \ WUFFS_JSON__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE #if WORK_BUFFER_ARRAY_SIZE > 0 -uint8_t work_buffer_array[WORK_BUFFER_ARRAY_SIZE]; +uint8_t g_work_buffer_array[WORK_BUFFER_ARRAY_SIZE]; #else // Not all C/C++ compilers support 0-length arrays. -uint8_t work_buffer_array[1]; +uint8_t g_work_buffer_array[1]; #endif -bool sandboxed = false; +bool g_sandboxed = false; -int input_file_descriptor = 0; // A 0 default means stdin. +int g_input_file_descriptor = 0; // A 0 default means stdin. #define MAX_INDENT 8 #define INDENT_SPACES_STRING " " @@ -261,19 +261,20 @@ int input_file_descriptor = 0; // A 0 default means stdin. #define TOKEN_BUFFER_ARRAY_SIZE (4 * 1024) #endif -uint8_t dst_array[DST_BUFFER_ARRAY_SIZE]; -uint8_t src_array[SRC_BUFFER_ARRAY_SIZE]; -wuffs_base__token tok_array[TOKEN_BUFFER_ARRAY_SIZE]; +uint8_t g_dst_array[DST_BUFFER_ARRAY_SIZE]; +uint8_t g_src_array[SRC_BUFFER_ARRAY_SIZE]; +wuffs_base__token g_tok_array[TOKEN_BUFFER_ARRAY_SIZE]; -wuffs_base__io_buffer dst; -wuffs_base__io_buffer src; -wuffs_base__token_buffer tok; +wuffs_base__io_buffer g_dst; +wuffs_base__io_buffer g_src; +wuffs_base__token_buffer g_tok; -// curr_token_end_src_index is the src.data.ptr index of the end of the current -// token. An invariant is that (curr_token_end_src_index <= src.meta.ri). -size_t curr_token_end_src_index; +// g_curr_token_end_src_index is the g_src.data.ptr index of the end of the +// current token. An invariant is that (g_curr_token_end_src_index <= +// g_src.meta.ri). +size_t g_curr_token_end_src_index; -uint32_t depth; +uint32_t g_depth; enum class context { none, @@ -282,18 +283,18 @@ enum class context { in_dict_after_brace, in_dict_after_key, in_dict_after_value, -} ctx; +} g_ctx; bool // in_dict_before_key() { - return (ctx == context::in_dict_after_brace) || - (ctx == context::in_dict_after_value); + return (g_ctx == context::in_dict_after_brace) || + (g_ctx == context::in_dict_after_value); } -uint32_t suppress_write_dst; -bool wrote_to_dst; +uint32_t g_suppress_write_dst; +bool g_wrote_to_dst; -wuffs_json__decoder dec; +wuffs_json__decoder g_dec; // ---- @@ -542,7 +543,7 @@ class Query { } return !previous_was_tilde; } -} query; +} g_query; // ---- @@ -557,12 +558,12 @@ struct { char* query_c_string; bool strict_json_pointer_syntax; bool tabs; -} flags = {0}; +} g_flags = {0}; const char* // parse_flags(int argc, char** argv) { - flags.indent = 4; - flags.max_output_depth = 0xFFFFFFFF; + g_flags.indent = 4; + g_flags.max_output_depth = 0xFFFFFFFF; int c = (argc > 0) ? 1 : 0; // Skip argv[0], the program name. for (; c < argc; c++) { @@ -585,24 +586,24 @@ parse_flags(int argc, char** argv) { } if (!strcmp(arg, "c") || !strcmp(arg, "compact-output")) { - flags.compact_output = true; + g_flags.compact_output = true; continue; } if (!strcmp(arg, "fail-if-unsandboxed")) { - flags.fail_if_unsandboxed = true; + g_flags.fail_if_unsandboxed = 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'; + g_flags.indent = arg[0] - '0'; continue; } - return usage; + return g_usage; } if (!strcmp(arg, "o") || !strcmp(arg, "max-output-depth")) { - flags.max_output_depth = 1; + g_flags.max_output_depth = 1; continue; } else if (!strncmp(arg, "o=", 2) || !strncmp(arg, "max-output-depth=", 16)) { @@ -611,84 +612,85 @@ parse_flags(int argc, char** argv) { wuffs_base__result_u64 u = wuffs_base__parse_number_u64( wuffs_base__make_slice_u8((uint8_t*)arg, strlen(arg))); if (wuffs_base__status__is_ok(&u.status) && (u.value <= 0xFFFFFFFF)) { - flags.max_output_depth = (uint32_t)(u.value); + g_flags.max_output_depth = (uint32_t)(u.value); continue; } - return usage; + return g_usage; } if (!strncmp(arg, "q=", 2) || !strncmp(arg, "query=", 6)) { while (*arg++ != '=') { } - flags.query_c_string = arg; + g_flags.query_c_string = arg; continue; } if (!strcmp(arg, "s") || !strcmp(arg, "strict-json-pointer-syntax")) { - flags.strict_json_pointer_syntax = true; + g_flags.strict_json_pointer_syntax = true; continue; } if (!strcmp(arg, "t") || !strcmp(arg, "tabs")) { - flags.tabs = true; + g_flags.tabs = true; continue; } - return usage; + return g_usage; } - if (flags.query_c_string && - !Query::validate(flags.query_c_string, strlen(flags.query_c_string), - flags.strict_json_pointer_syntax)) { + if (g_flags.query_c_string && + !Query::validate(g_flags.query_c_string, strlen(g_flags.query_c_string), + g_flags.strict_json_pointer_syntax)) { return "main: bad JSON Pointer (RFC 6901) syntax for the -query=STR flag"; } - flags.remaining_argc = argc - c; - flags.remaining_argv = argv + c; + g_flags.remaining_argc = argc - c; + g_flags.remaining_argv = argv + c; return nullptr; } const char* // initialize_globals(int argc, char** argv) { - dst = wuffs_base__make_io_buffer( - wuffs_base__make_slice_u8(dst_array, DST_BUFFER_ARRAY_SIZE), + g_dst = wuffs_base__make_io_buffer( + wuffs_base__make_slice_u8(g_dst_array, DST_BUFFER_ARRAY_SIZE), wuffs_base__empty_io_buffer_meta()); - src = wuffs_base__make_io_buffer( - wuffs_base__make_slice_u8(src_array, SRC_BUFFER_ARRAY_SIZE), + g_src = wuffs_base__make_io_buffer( + wuffs_base__make_slice_u8(g_src_array, SRC_BUFFER_ARRAY_SIZE), wuffs_base__empty_io_buffer_meta()); - tok = wuffs_base__make_token_buffer( - wuffs_base__make_slice_token(tok_array, TOKEN_BUFFER_ARRAY_SIZE), + g_tok = wuffs_base__make_token_buffer( + wuffs_base__make_slice_token(g_tok_array, TOKEN_BUFFER_ARRAY_SIZE), wuffs_base__empty_token_buffer_meta()); - curr_token_end_src_index = 0; + g_curr_token_end_src_index = 0; - depth = 0; + g_depth = 0; - ctx = context::none; + g_ctx = context::none; TRY(parse_flags(argc, argv)); - if (flags.fail_if_unsandboxed && !sandboxed) { + if (g_flags.fail_if_unsandboxed && !g_sandboxed) { return "main: unsandboxed"; } const int stdin_fd = 0; - if (flags.remaining_argc > ((input_file_descriptor != stdin_fd) ? 1 : 0)) { - return usage; + if (g_flags.remaining_argc > + ((g_input_file_descriptor != stdin_fd) ? 1 : 0)) { + return g_usage; } - query.reset(flags.query_c_string); + g_query.reset(g_flags.query_c_string); // If the query is non-empty, suprress writing to stdout until we've // completed the query. - suppress_write_dst = query.next_fragment() ? 1 : 0; - wrote_to_dst = false; + g_suppress_write_dst = g_query.next_fragment() ? 1 : 0; + g_wrote_to_dst = false; - TRY(dec.initialize(sizeof__wuffs_json__decoder(), WUFFS_VERSION, 0) + TRY(g_dec.initialize(sizeof__wuffs_json__decoder(), WUFFS_VERSION, 0) .message()); // Consume an optional whitespace trailer. This isn't part of the JSON spec, // but it works better with line oriented Unix tools (such as "echo 123 | // jsonptr" where it's "echo", not "echo -n") or hand-edited JSON files which // can accidentally contain trailing whitespace. - dec.set_quirk_enabled(WUFFS_JSON__QUIRK_ALLOW_TRAILING_NEW_LINE, true); + g_dec.set_quirk_enabled(WUFFS_JSON__QUIRK_ALLOW_TRAILING_NEW_LINE, true); return nullptr; } @@ -701,19 +703,19 @@ ignore_return_value(int ignored) {} const char* // read_src() { - if (src.meta.closed) { + if (g_src.meta.closed) { return "main: internal error: read requested on a closed source"; } - src.compact(); - if (src.meta.wi >= src.data.len) { - return "main: src buffer is full"; + g_src.compact(); + if (g_src.meta.wi >= g_src.data.len) { + return "main: g_src buffer is full"; } while (true) { - ssize_t n = read(input_file_descriptor, src.data.ptr + src.meta.wi, - src.data.len - src.meta.wi); + ssize_t n = read(g_input_file_descriptor, g_src.data.ptr + g_src.meta.wi, + g_src.data.len - g_src.meta.wi); if (n >= 0) { - src.meta.wi += n; - src.meta.closed = n == 0; + g_src.meta.wi += n; + g_src.meta.closed = n == 0; break; } else if (errno != EINTR) { return strerror(errno); @@ -725,49 +727,49 @@ read_src() { const char* // flush_dst() { while (true) { - size_t n = dst.meta.wi - dst.meta.ri; + size_t n = g_dst.meta.wi - g_dst.meta.ri; if (n == 0) { break; } const int stdout_fd = 1; - ssize_t i = write(stdout_fd, dst.data.ptr + dst.meta.ri, n); + ssize_t i = write(stdout_fd, g_dst.data.ptr + g_dst.meta.ri, n); if (i >= 0) { - dst.meta.ri += i; + g_dst.meta.ri += i; } else if (errno != EINTR) { return strerror(errno); } } - dst.compact(); + g_dst.compact(); return nullptr; } const char* // write_dst(const void* s, size_t n) { - if (suppress_write_dst > 0) { + if (g_suppress_write_dst > 0) { return nullptr; } const uint8_t* p = static_cast(s); while (n > 0) { - size_t i = dst.writer_available(); + size_t i = g_dst.writer_available(); if (i == 0) { const char* z = flush_dst(); if (z) { return z; } - i = dst.writer_available(); + i = g_dst.writer_available(); if (i == 0) { - return "main: dst buffer is full"; + return "main: g_dst buffer is full"; } } if (i > n) { i = n; } - memcpy(dst.data.ptr + dst.meta.wi, p, i); - dst.meta.wi += i; + memcpy(g_dst.data.ptr + g_dst.meta.wi, p, i); + g_dst.meta.wi += i; p += i; n -= i; - wrote_to_dst = true; + g_wrote_to_dst = true; } return nullptr; } @@ -841,16 +843,16 @@ handle_token(wuffs_base__token t) { // Handle ']' or '}'. if ((vbc == WUFFS_BASE__TOKEN__VBC__STRUCTURE) && (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__POP)) { - if (query.is_at(depth)) { + if (g_query.is_at(g_depth)) { return "main: no match for query"; } - if (depth <= 0) { - return "main: internal error: inconsistent depth"; + if (g_depth <= 0) { + return "main: internal error: inconsistent g_depth"; } - depth--; + g_depth--; - if (query.matched_all() && (depth >= flags.max_output_depth)) { - suppress_write_dst--; + if (g_query.matched_all() && (g_depth >= g_flags.max_output_depth)) { + g_suppress_write_dst--; // '…' is U+2026 HORIZONTAL ELLIPSIS, which is 3 UTF-8 bytes. TRY(write_dst((vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__FROM_LIST) ? "\"[…]\"" @@ -858,12 +860,14 @@ handle_token(wuffs_base__token t) { 7)); } else { // Write preceding whitespace. - if ((ctx != context::in_list_after_bracket) && - (ctx != context::in_dict_after_brace) && !flags.compact_output) { + if ((g_ctx != context::in_list_after_bracket) && + (g_ctx != context::in_dict_after_brace) && + !g_flags.compact_output) { TRY(write_dst("\n", 1)); - for (uint32_t i = 0; i < depth; i++) { - TRY(write_dst(flags.tabs ? INDENT_TAB_STRING : INDENT_SPACES_STRING, - flags.tabs ? 1 : flags.indent)); + for (uint32_t i = 0; i < g_depth; i++) { + TRY(write_dst( + g_flags.tabs ? INDENT_TAB_STRING : INDENT_SPACES_STRING, + g_flags.tabs ? 1 : g_flags.indent)); } } @@ -872,40 +876,41 @@ handle_token(wuffs_base__token t) { 1)); } - ctx = (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST) - ? context::in_list_after_value - : context::in_dict_after_key; + g_ctx = (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST) + ? context::in_list_after_value + : context::in_dict_after_key; goto after_value; } // Write preceding whitespace and punctuation, if it wasn't ']', '}' or a // continuation of a multi-token chain. if (!t.link_prev()) { - if (ctx == context::in_dict_after_key) { - TRY(write_dst(": ", flags.compact_output ? 1 : 2)); - } else if (ctx != context::none) { - if ((ctx != context::in_list_after_bracket) && - (ctx != context::in_dict_after_brace)) { + if (g_ctx == context::in_dict_after_key) { + TRY(write_dst(": ", g_flags.compact_output ? 1 : 2)); + } else if (g_ctx != context::none) { + if ((g_ctx != context::in_list_after_bracket) && + (g_ctx != context::in_dict_after_brace)) { TRY(write_dst(",", 1)); } - if (!flags.compact_output) { + if (!g_flags.compact_output) { TRY(write_dst("\n", 1)); - for (size_t i = 0; i < depth; i++) { - TRY(write_dst(flags.tabs ? INDENT_TAB_STRING : INDENT_SPACES_STRING, - flags.tabs ? 1 : flags.indent)); + for (size_t i = 0; i < g_depth; i++) { + TRY(write_dst( + g_flags.tabs ? INDENT_TAB_STRING : INDENT_SPACES_STRING, + g_flags.tabs ? 1 : g_flags.indent)); } } } bool query_matched_fragment = false; - if (query.is_at(depth)) { - switch (ctx) { + if (g_query.is_at(g_depth)) { + switch (g_ctx) { case context::in_list_after_bracket: case context::in_list_after_value: - query_matched_fragment = query.tick(); + query_matched_fragment = g_query.tick(); break; case context::in_dict_after_key: - query_matched_fragment = query.matched_fragment(); + query_matched_fragment = g_query.matched_fragment(); break; default: break; @@ -913,20 +918,20 @@ handle_token(wuffs_base__token t) { } if (!query_matched_fragment) { // No-op. - } else if (!query.next_fragment()) { + } else if (!g_query.next_fragment()) { // There is no next fragment. We have matched the complete query, and // the upcoming JSON value is the result of that query. // - // Un-suppress writing to stdout and reset the ctx and depth as if we - // were about to decode a top-level value. This makes any subsequent - // indentation be relative to this point, and we will return eod after - // the upcoming JSON value is complete. - if (suppress_write_dst != 1) { - return "main: internal error: inconsistent suppress_write_dst"; + // Un-suppress writing to stdout and reset the g_ctx and g_depth as if + // we were about to decode a top-level value. This makes any subsequent + // indentation be relative to this point, and we will return g_eod + // after the upcoming JSON value is complete. + if (g_suppress_write_dst != 1) { + return "main: internal error: inconsistent g_suppress_write_dst"; } - suppress_write_dst = 0; - ctx = context::none; - depth = 0; + g_suppress_write_dst = 0; + g_ctx = context::none; + g_depth = 0; } else if ((vbc != WUFFS_BASE__TOKEN__VBC__STRUCTURE) || !(vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__PUSH)) { // The query has moved on to the next fragment but the upcoming JSON @@ -939,32 +944,33 @@ handle_token(wuffs_base__token t) { // value: string (a chain of raw or escaped parts), literal or number. switch (vbc) { case WUFFS_BASE__TOKEN__VBC__STRUCTURE: - if (query.matched_all() && (depth >= flags.max_output_depth)) { - suppress_write_dst++; + if (g_query.matched_all() && (g_depth >= g_flags.max_output_depth)) { + g_suppress_write_dst++; } else { TRY(write_dst( (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST) ? "[" : "{", 1)); } - depth++; - ctx = (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST) - ? context::in_list_after_bracket - : context::in_dict_after_brace; + g_depth++; + g_ctx = (vbd & WUFFS_BASE__TOKEN__VBD__STRUCTURE__TO_LIST) + ? context::in_list_after_bracket + : context::in_dict_after_brace; return nullptr; case WUFFS_BASE__TOKEN__VBC__STRING: if (!t.link_prev()) { TRY(write_dst("\"", 1)); - query.restart_fragment(in_dict_before_key() && query.is_at(depth)); + g_query.restart_fragment(in_dict_before_key() && + g_query.is_at(g_depth)); } if (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_0_DST_1_SRC_DROP) { // No-op. } else if (vbd & WUFFS_BASE__TOKEN__VBD__STRING__CONVERT_1_DST_1_SRC_COPY) { - uint8_t* ptr = src.data.ptr + curr_token_end_src_index - len; + uint8_t* ptr = g_src.data.ptr + g_curr_token_end_src_index - len; TRY(write_dst(ptr, len)); - query.incremental_match_slice(ptr, len); + g_query.incremental_match_slice(ptr, len); } else { return "main: internal error: unexpected string-token conversion"; } @@ -980,12 +986,12 @@ handle_token(wuffs_base__token t) { return "main: internal error: unexpected unlinked token"; } TRY(handle_unicode_code_point(vbd)); - query.incremental_match_code_point(vbd); + g_query.incremental_match_code_point(vbd); return nullptr; case WUFFS_BASE__TOKEN__VBC__LITERAL: case WUFFS_BASE__TOKEN__VBC__NUMBER: - TRY(write_dst(src.data.ptr + curr_token_end_src_index - len, len)); + TRY(write_dst(g_src.data.ptr + g_curr_token_end_src_index - len, len)); goto after_value; } @@ -997,21 +1003,21 @@ handle_token(wuffs_base__token t) { // simple value). Empty parent containers are no longer empty. If the parent // container is a "{...}" object, toggle between keys and values. after_value: - if (depth == 0) { - return eod; + if (g_depth == 0) { + return g_eod; } - switch (ctx) { + switch (g_ctx) { case context::in_list_after_bracket: - ctx = context::in_list_after_value; + g_ctx = context::in_list_after_value; break; case context::in_dict_after_brace: - ctx = context::in_dict_after_key; + g_ctx = context::in_dict_after_key; break; case context::in_dict_after_key: - ctx = context::in_dict_after_value; + g_ctx = context::in_dict_after_value; break; case context::in_dict_after_value: - ctx = context::in_dict_after_key; + g_ctx = context::in_dict_after_key; break; default: break; @@ -1024,17 +1030,17 @@ main1(int argc, char** argv) { TRY(initialize_globals(argc, argv)); while (true) { - wuffs_base__status status = dec.decode_tokens( - &tok, &src, - wuffs_base__make_slice_u8(work_buffer_array, WORK_BUFFER_ARRAY_SIZE)); + wuffs_base__status status = g_dec.decode_tokens( + &g_tok, &g_src, + wuffs_base__make_slice_u8(g_work_buffer_array, WORK_BUFFER_ARRAY_SIZE)); - while (tok.meta.ri < tok.meta.wi) { - wuffs_base__token t = tok.data.ptr[tok.meta.ri++]; + while (g_tok.meta.ri < g_tok.meta.wi) { + wuffs_base__token t = g_tok.data.ptr[g_tok.meta.ri++]; uint64_t n = t.length(); - if ((src.meta.ri - curr_token_end_src_index) < n) { - return "main: internal error: inconsistent src indexes"; + if ((g_src.meta.ri - g_curr_token_end_src_index) < n) { + return "main: internal error: inconsistent g_src indexes"; } - curr_token_end_src_index += n; + g_curr_token_end_src_index += n; // Skip filler tokens (e.g. whitespace). if (t.value() == 0) { @@ -1044,7 +1050,7 @@ main1(int argc, char** argv) { const char* z = handle_token(t); if (z == nullptr) { continue; - } else if (z == eod) { + } else if (z == g_eod) { goto end_of_data; } return z; @@ -1053,30 +1059,30 @@ main1(int argc, char** argv) { if (status.repr == nullptr) { return "main: internal error: unexpected end of token stream"; } else if (status.repr == wuffs_base__suspension__short_read) { - if (curr_token_end_src_index != src.meta.ri) { - return "main: internal error: inconsistent src indexes"; + if (g_curr_token_end_src_index != g_src.meta.ri) { + return "main: internal error: inconsistent g_src indexes"; } TRY(read_src()); - curr_token_end_src_index = src.meta.ri; + g_curr_token_end_src_index = g_src.meta.ri; } else if (status.repr == wuffs_base__suspension__short_write) { - tok.compact(); + g_tok.compact(); } else { return status.message(); } } end_of_data: - // With a non-empty query, don't try to consume trailing whitespace or + // With a non-empty g_query, don't try to consume trailing whitespace or // confirm that we've processed all the tokens. - if (flags.query_c_string && *flags.query_c_string) { + if (g_flags.query_c_string && *g_flags.query_c_string) { return nullptr; } // Check that we've exhausted the input. - if ((src.meta.ri == src.meta.wi) && !src.meta.closed) { + if ((g_src.meta.ri == g_src.meta.wi) && !g_src.meta.closed) { TRY(read_src()); } - if ((src.meta.ri < src.meta.wi) || !src.meta.closed) { + if ((g_src.meta.ri < g_src.meta.wi) || !g_src.meta.closed) { return "main: valid JSON followed by further (unexpected) data"; } @@ -1084,8 +1090,8 @@ end_of_data: // filler tokens. For example, "true\n" is valid JSON (and fully consumed // with WUFFS_JSON__QUIRK_ALLOW_TRAILING_NEW_LINE enabled) with a trailing // filler token for the "\n". - for (; tok.meta.ri < tok.meta.wi; tok.meta.ri++) { - if (tok.data.ptr[tok.meta.ri].value_base_category() != + for (; g_tok.meta.ri < g_tok.meta.wi; g_tok.meta.ri++) { + if (g_tok.data.ptr[g_tok.meta.ri].value_base_category() != WUFFS_BASE__TOKEN__VBC__FILLER) { return "main: internal error: decoded OK but unprocessed tokens remain"; } @@ -1100,7 +1106,7 @@ compute_exit_code(const char* status_msg) { return 0; } size_t n; - if (status_msg == usage) { + if (status_msg == g_usage) { n = strlen(status_msg); } else { n = strnlen(status_msg, 2047); @@ -1141,8 +1147,8 @@ main(int argc, char** argv) { dash_dash = (arg[1] == '-') && (arg[2] == '\x00'); continue; } - input_file_descriptor = open(arg, O_RDONLY); - if (input_file_descriptor < 0) { + g_input_file_descriptor = open(arg, O_RDONLY); + if (g_input_file_descriptor < 0) { fprintf(stderr, "%s: %s\n", arg, strerror(errno)); return 1; } @@ -1152,11 +1158,11 @@ main(int argc, char** argv) { #if defined(WUFFS_EXAMPLE_USE_SECCOMP) prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT); - sandboxed = true; + g_sandboxed = true; #endif const char* z = main1(argc, argv); - if (wrote_to_dst) { + if (g_wrote_to_dst) { const char* z1 = write_dst("\n", 1); const char* z2 = flush_dst(); z = z ? z : (z1 ? z1 : z2); diff --git a/example/library/library.c b/example/library/library.c index e6162d19..78cab0ff 100644 --- a/example/library/library.c +++ b/example/library/library.c @@ -48,7 +48,7 @@ for a C compiler $CC, such as clang or gcc. #ifndef DST_BUFFER_ARRAY_SIZE #define DST_BUFFER_ARRAY_SIZE 1024 #endif -uint8_t dst_buffer_array[DST_BUFFER_ARRAY_SIZE]; +uint8_t g_dst_buffer_array[DST_BUFFER_ARRAY_SIZE]; // src_ptr and src_len hold a gzip-encoded "Hello Wuffs." // @@ -59,28 +59,28 @@ uint8_t dst_buffer_array[DST_BUFFER_ARRAY_SIZE]; // // Passing --no-name to the gzip command line also means to skip the timestamp, // which means that its output is deterministic. -uint8_t src_ptr[] = { +uint8_t g_src_ptr[] = { 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, // 00..07 0x00, 0x03, 0xf3, 0x48, 0xcd, 0xc9, 0xc9, 0x57, // 08..0F 0x08, 0x2f, 0x4d, 0x4b, 0x2b, 0xd6, 0xe3, 0x02, // 10..17 0x00, 0x3c, 0x84, 0x75, 0xbb, 0x0d, 0x00, 0x00, // 18..1F 0x00, // 20..20 }; -size_t src_len = 0x21; +size_t g_src_len = 0x21; #define WORK_BUFFER_ARRAY_SIZE \ WUFFS_GZIP__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE #if WORK_BUFFER_ARRAY_SIZE > 0 -uint8_t work_buffer_array[WORK_BUFFER_ARRAY_SIZE]; +uint8_t g_work_buffer_array[WORK_BUFFER_ARRAY_SIZE]; #else // Not all C/C++ compilers support 0-length arrays. -uint8_t work_buffer_array[1]; +uint8_t g_work_buffer_array[1]; #endif static const char* // decode() { wuffs_base__io_buffer dst; - dst.data.ptr = dst_buffer_array; + dst.data.ptr = g_dst_buffer_array; dst.data.len = DST_BUFFER_ARRAY_SIZE; dst.meta.wi = 0; dst.meta.ri = 0; @@ -88,9 +88,9 @@ decode() { dst.meta.closed = false; wuffs_base__io_buffer src; - src.data.ptr = src_ptr; - src.data.len = src_len; - src.meta.wi = src_len; + src.data.ptr = g_src_ptr; + src.data.len = g_src_len; + src.meta.wi = g_src_len; src.meta.ri = 0; src.meta.pos = 0; src.meta.closed = true; @@ -109,7 +109,7 @@ decode() { } status = wuffs_gzip__decoder__transform_io( dec, &dst, &src, - wuffs_base__make_slice_u8(work_buffer_array, WORK_BUFFER_ARRAY_SIZE)); + wuffs_base__make_slice_u8(g_work_buffer_array, WORK_BUFFER_ARRAY_SIZE)); if (!wuffs_base__status__is_ok(&status)) { free(dec); return wuffs_base__status__message(&status); diff --git a/example/zcat/zcat.c b/example/zcat/zcat.c index 07f96793..d1cefba0 100644 --- a/example/zcat/zcat.c +++ b/example/zcat/zcat.c @@ -72,25 +72,25 @@ for a C compiler $CC, such as clang or gcc. #define WORK_BUFFER_ARRAY_SIZE \ WUFFS_GZIP__DECODER_WORKBUF_LEN_MAX_INCL_WORST_CASE -uint8_t dst_buffer_array[DST_BUFFER_ARRAY_SIZE]; -uint8_t src_buffer_array[SRC_BUFFER_ARRAY_SIZE]; +uint8_t g_dst_buffer_array[DST_BUFFER_ARRAY_SIZE]; +uint8_t g_src_buffer_array[SRC_BUFFER_ARRAY_SIZE]; #if WORK_BUFFER_ARRAY_SIZE > 0 -uint8_t work_buffer_array[WORK_BUFFER_ARRAY_SIZE]; +uint8_t g_work_buffer_array[WORK_BUFFER_ARRAY_SIZE]; #else // Not all C/C++ compilers support 0-length arrays. -uint8_t work_buffer_array[1]; +uint8_t g_work_buffer_array[1]; #endif // ---- -static bool sandboxed = false; +static bool g_sandboxed = false; struct { int remaining_argc; char** remaining_argv; bool fail_if_unsandboxed; -} flags = {0}; +} g_flags = {0}; const char* // parse_flags(int argc, char** argv) { @@ -115,15 +115,15 @@ parse_flags(int argc, char** argv) { } if (!strcmp(arg, "fail-if-unsandboxed")) { - flags.fail_if_unsandboxed = true; + g_flags.fail_if_unsandboxed = true; continue; } return "main: unrecognized flag argument"; } - flags.remaining_argc = argc - c; - flags.remaining_argv = argv + c; + g_flags.remaining_argc = argc - c; + g_flags.remaining_argv = argv + c; return NULL; } @@ -139,7 +139,7 @@ main1(int argc, char** argv) { if (z) { return z; } - if (flags.fail_if_unsandboxed && !sandboxed) { + if (g_flags.fail_if_unsandboxed && !g_sandboxed) { return "main: unsandboxed"; } @@ -151,7 +151,7 @@ main1(int argc, char** argv) { } wuffs_base__io_buffer dst; - dst.data.ptr = dst_buffer_array; + dst.data.ptr = g_dst_buffer_array; dst.data.len = DST_BUFFER_ARRAY_SIZE; dst.meta.wi = 0; dst.meta.ri = 0; @@ -159,7 +159,7 @@ main1(int argc, char** argv) { dst.meta.closed = false; wuffs_base__io_buffer src; - src.data.ptr = src_buffer_array; + src.data.ptr = g_src_buffer_array; src.data.len = SRC_BUFFER_ARRAY_SIZE; src.meta.wi = 0; src.meta.ri = 0; @@ -184,12 +184,13 @@ main1(int argc, char** argv) { while (true) { status = wuffs_gzip__decoder__transform_io( &dec, &dst, &src, - wuffs_base__make_slice_u8(work_buffer_array, WORK_BUFFER_ARRAY_SIZE)); + wuffs_base__make_slice_u8(g_work_buffer_array, + WORK_BUFFER_ARRAY_SIZE)); if (dst.meta.wi) { // TODO: handle EINTR and other write errors; see "man 2 write". const int stdout_fd = 1; - ignore_return_value(write(stdout_fd, dst_buffer_array, dst.meta.wi)); + ignore_return_value(write(stdout_fd, g_dst_buffer_array, dst.meta.wi)); dst.meta.ri = dst.meta.wi; wuffs_base__io_buffer__compact(&dst); } @@ -241,7 +242,7 @@ int // main(int argc, char** argv) { #if defined(WUFFS_EXAMPLE_USE_SECCOMP) prctl(PR_SET_SECCOMP, SECCOMP_MODE_STRICT); - sandboxed = true; + g_sandboxed = true; #endif int exit_code = compute_exit_code(main1(argc, argv));