← Commit list

f3d58a29b

Denys Vlasenko

2015-10-19

SUCCESS Duration: 193s

Subject

od: get rid of (almost all) statics

Binary

No binary (build failed)

Architecture & Compiler Flags

Architecture: x86_64-linux-gnu Compiler: gcc (Ubuntu 11.4.0-1ubuntu1~22.04.3) 11.4.0

—

Build Log

(log yok)

Commit Diff GitHub →

coreutils/od_bloaty.c +122 -108

coreutils/od_bloaty.c+122 -108

@@ -66,7 +66,7 @@ enum {
	/* -S was -s and also had optional parameter */ \
	/* but in coreutils 6.3 it was renamed and now has */ \
	/* _mandatory_ parameter */ \
-	&str_A, &str_N, &str_j, &lst_t, &str_S, &bytes_per_block)
+	&str_A, &str_N, &str_j, &lst_t, &str_S, &G.bytes_per_block)


	/* Check for 0x7f is a coreutils 6.3 addition */
@@ -174,38 +174,52 @@ struct ERR_width_bytes_has_bad_size {
	char ERR_width_bytes_has_bad_size[ARRAY_SIZE(width_bytes) == N_SIZE_SPECS ? 1 : -1];
	};

-	static smallint exit_code;
+	struct globals {
+	smallint exit_code;

-	static unsigned string_min;
+	unsigned string_min;

-	/* An array of specs describing how to format each input block. */
-	static size_t n_specs;
-	static struct tspec *spec;
+	/* An array of specs describing how to format each input block. */
+	unsigned n_specs;
+	struct tspec *spec;

-	/* Function that accepts an address and an optional following char,
-	and prints the address and char to stdout. */
-	static void (*format_address)(off_t, char);
-	/* The difference between the old-style pseudo starting address and
-	the number of bytes to skip. */
+	/* Function that accepts an address and an optional following char,
+	and prints the address and char to stdout. */
+	void (*format_address)(off_t, char);
+
+	/* The difference between the old-style pseudo starting address and
+	the number of bytes to skip. */
	#if ENABLE_LONG_OPTS
-	static off_t pseudo_offset;
-	#else
-	enum { pseudo_offset = 0 };
+	off_t pseudo_offset;
+	# define G_pseudo_offset G.pseudo_offset
	#endif
-	/* When zero, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
-	input is formatted. */
-
-	/* The number of input bytes formatted per output line. It must be
-	a multiple of the least common multiple of the sizes associated with
-	the specified output types. It should be as large as possible, but
-	no larger than 16 -- unless specified with the -w option. */
-	static unsigned bytes_per_block = 32; /* have to use unsigned, not size_t */
-
-	/* A NULL-terminated list of the file-arguments from the command line. */
-	static const char const file_list;
+	/* When zero, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
+	input is formatted. */
+
+	/* The number of input bytes formatted per output line. It must be
+	a multiple of the least common multiple of the sizes associated with
+	the specified output types. It should be as large as possible, but
+	no larger than 16 -- unless specified with the -w option. */
+	unsigned bytes_per_block; /* have to use unsigned, not size_t */
+
+	/* A NULL-terminated list of the file-arguments from the command line. */
+	const char const file_list;
+
+	/* The input stream associated with the current file. */
+	FILE *in_stream;
+
+	bool not_first;
+	bool prev_pair_equal;
+	} FIX_ALIASING;
+	#if !ENABLE_LONG_OPTS
+	enum { G_pseudo_offset = 0 };
+	#endif
+	#define G ((struct globals)&bb_common_bufsiz1)
+	#define INIT_G() do { \
+	BUILD_BUG_ON(sizeof(G) > COMMON_BUFSIZE); \
+	G.bytes_per_block = 32; \
+	} while (0)

-	/* The input stream associated with the current file. */
-	static FILE *in_stream;

	#define MAX_INTEGRAL_TYPE_SIZE sizeof(ulonglong_t)
	static const unsigned char integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1] ALIGN1 = {
@@ -476,17 +490,17 @@ static void
	open_next_file(void)
	{
	while (1) {
-	if (!*file_list)
+	if (!*G.file_list)
	return;
-	in_stream = fopen_or_warn_stdin(*file_list++);
-	if (in_stream) {
+	G.in_stream = fopen_or_warn_stdin(*G.file_list++);
+	if (G.in_stream) {
	break;
	}
-	exit_code = 1;
+	G.exit_code = 1;
	}

	if ((option_mask32 & (OPT_N\|OPT_S)) == OPT_N)
-	setbuf(in_stream, NULL);
+	setbuf(G.in_stream, NULL);
	}

	/* Test whether there have been errors on in_stream, and close it if
@@ -499,16 +513,16 @@ open_next_file(void)
	static void
	check_and_close(void)
	{
-	if (in_stream) {
-	if (ferror(in_stream)) {
-	bb_error_msg("%s: read error", (in_stream == stdin)
+	if (G.in_stream) {
+	if (ferror(G.in_stream)) {
+	bb_error_msg("%s: read error", (G.in_stream == stdin)
	? bb_msg_standard_input
-	: file_list[-1]
+	: G.file_list[-1]
	);
-	exit_code = 1;
+	G.exit_code = 1;
	}
-	fclose_if_not_stdin(in_stream);
-	in_stream = NULL;
+	fclose_if_not_stdin(G.in_stream);
+	G.in_stream = NULL;
	}

	if (ferror(stdout)) {
@@ -744,9 +758,9 @@ decode_format_string(const char *s)

	assert(s != next);
	s = next;
-	spec = xrealloc_vector(spec, 4, n_specs);
-	memcpy(&spec[n_specs], &tspec, sizeof(spec[0]));
-	n_specs++;
+	G.spec = xrealloc_vector(G.spec, 4, G.n_specs);
+	memcpy(&G.spec[G.n_specs], &tspec, sizeof(G.spec[0]));
+	G.n_specs++;
	}
	}

@@ -763,7 +777,7 @@ skip(off_t n_skip)
	if (n_skip == 0)
	return;

-	while (in_stream) { /* !EOF */
+	while (G.in_stream) { /* !EOF */
	struct stat file_stats;

	/* First try seeking. For large offsets, this extra work is
@@ -781,15 +795,15 @@ skip(off_t n_skip)
	If the number of bytes left to skip is at least
	as large as the size of the current file, we can
	decrement n_skip and go on to the next file. */
-	if (fstat(fileno(in_stream), &file_stats) == 0
+	if (fstat(fileno(G.in_stream), &file_stats) == 0
	&& S_ISREG(file_stats.st_mode) && file_stats.st_size > 0
	) {
	if (file_stats.st_size < n_skip) {
	n_skip -= file_stats.st_size;
	/* take "check & close / open_next" route */
	} else {
-	if (fseeko(in_stream, n_skip, SEEK_CUR) != 0)
-	exit_code = 1;
+	if (fseeko(G.in_stream, n_skip, SEEK_CUR) != 0)
+	G.exit_code = 1;
	return;
	}
	} else {
@@ -802,7 +816,7 @@ skip(off_t n_skip)
	while (n_skip > 0) {
	if (n_skip < n_bytes_to_read)
	n_bytes_to_read = n_skip;
-	n_bytes_read = fread(buf, 1, n_bytes_to_read, in_stream);
+	n_bytes_read = fread(buf, 1, n_bytes_to_read, G.in_stream);
	n_skip -= n_bytes_read;
	if (n_bytes_read != n_bytes_to_read)
	break; /* EOF on this file or error */
@@ -855,7 +869,7 @@ static void
	format_address_label(off_t address, char c)
	{
	format_address_std(address, ' ');
-	format_address_paren(address + pseudo_offset, c);
+	format_address_paren(address + G_pseudo_offset, c);
	}
	#endif

@@ -886,36 +900,34 @@ static void
	write_block(off_t current_offset, size_t n_bytes,
	const char prev_block, const char curr_block)
	{
-	static char first = 1;
-	static char prev_pair_equal = 0;
-	size_t i;
+	unsigned i;

	if (!(option_mask32 & OPT_v)
-	&& !first
-	&& n_bytes == bytes_per_block
-	&& memcmp(prev_block, curr_block, bytes_per_block) == 0
+	&& G.not_first
+	&& n_bytes == G.bytes_per_block
+	&& memcmp(prev_block, curr_block, G.bytes_per_block) == 0
	) {
-	if (prev_pair_equal) {
+	if (G.prev_pair_equal) {
	/* The two preceding blocks were equal, and the current
	block is the same as the last one, so print nothing. */
	} else {
	puts("*");
-	prev_pair_equal = 1;
+	G.prev_pair_equal = 1;
	}
	} else {
-	first = 0;
-	prev_pair_equal = 0;
-	for (i = 0; i < n_specs; i++) {
+	G.not_first = 1;
+	G.prev_pair_equal = 0;
+	for (i = 0; i < G.n_specs; i++) {
	if (i == 0)
-	format_address(current_offset, '\0');
+	G.format_address(current_offset, '\0');
	else
	printf("%*s", address_pad_len_char - '0', "");
-	(*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
-	if (spec[i].hexl_mode_trailer) {
+	(*G.spec[i].print_function) (n_bytes, curr_block, G.spec[i].fmt_string);
+	if (G.spec[i].hexl_mode_trailer) {
	/* space-pad out to full line width, then dump the trailer */
-	unsigned datum_width = width_bytes[spec[i].size];
-	unsigned blank_fields = (bytes_per_block - n_bytes) / datum_width;
-	unsigned field_width = spec[i].field_width + 1;
+	unsigned datum_width = width_bytes[G.spec[i].size];
+	unsigned blank_fields = (G.bytes_per_block - n_bytes) / datum_width;
+	unsigned field_width = G.spec[i].field_width + 1;
	printf("%s", blank_fields field_width, "");
	dump_hexl_mode_trailer(n_bytes, curr_block);
	}
@@ -927,19 +939,19 @@ write_block(off_t current_offset, size_t n_bytes,
	static void
	read_block(size_t n, char block, size_t n_bytes_in_buffer)
	{
-	assert(0 < n && n <= bytes_per_block);
+	assert(0 < n && n <= G.bytes_per_block);

	*n_bytes_in_buffer = 0;

	if (n == 0)
	return;

-	while (in_stream != NULL) { /* EOF. */
+	while (G.in_stream != NULL) { /* EOF. */
	size_t n_needed;
	size_t n_read;

	n_needed = n - *n_bytes_in_buffer;
-	n_read = fread(block + *n_bytes_in_buffer, 1, n_needed, in_stream);
+	n_read = fread(block + *n_bytes_in_buffer, 1, n_needed, G.in_stream);
	*n_bytes_in_buffer += n_read;
	if (n_read == n_needed)
	break;
@@ -958,8 +970,8 @@ get_lcm(void)
	size_t i;
	int l_c_m = 1;

-	for (i = 0; i < n_specs; i++)
-	l_c_m = lcm(l_c_m, width_bytes[(int) spec[i].size]);
+	for (i = 0; i < G.n_specs; i++)
+	l_c_m = lcm(l_c_m, width_bytes[(int) G.spec[i].size]);
	return l_c_m;
	}

@@ -980,8 +992,8 @@ dump(off_t current_offset, off_t end_offset)
	int idx;
	size_t n_bytes_read;

-	block[0] = xmalloc(2 * bytes_per_block);
-	block[1] = block[0] + bytes_per_block;
+	block[0] = xmalloc(2 * G.bytes_per_block);
+	block[1] = block[0] + G.bytes_per_block;

	idx = 0;
	if (option_mask32 & OPT_N) {
@@ -991,21 +1003,21 @@ dump(off_t current_offset, off_t end_offset)
	n_bytes_read = 0;
	break;
	}
-	n_needed = MIN(end_offset - current_offset, (off_t) bytes_per_block);
+	n_needed = MIN(end_offset - current_offset, (off_t) G.bytes_per_block);
	read_block(n_needed, block[idx], &n_bytes_read);
-	if (n_bytes_read < bytes_per_block)
+	if (n_bytes_read < G.bytes_per_block)
	break;
-	assert(n_bytes_read == bytes_per_block);
+	assert(n_bytes_read == G.bytes_per_block);
	write_block(current_offset, n_bytes_read, block[idx ^ 1], block[idx]);
	current_offset += n_bytes_read;
	idx ^= 1;
	}
	} else {
	while (1) {
-	read_block(bytes_per_block, block[idx], &n_bytes_read);
-	if (n_bytes_read < bytes_per_block)
+	read_block(G.bytes_per_block, block[idx], &n_bytes_read);
+	if (n_bytes_read < G.bytes_per_block)
	break;
-	assert(n_bytes_read == bytes_per_block);
+	assert(n_bytes_read == G.bytes_per_block);
	write_block(current_offset, n_bytes_read, block[idx ^ 1], block[idx]);
	current_offset += n_bytes_read;
	idx ^= 1;
@@ -1028,7 +1040,7 @@ dump(off_t current_offset, off_t end_offset)
	current_offset += n_bytes_read;
	}

-	format_address(current_offset, '\n');
+	G.format_address(current_offset, '\n');

	if ((option_mask32 & OPT_N) && current_offset >= end_offset)
	check_and_close();
@@ -1059,16 +1071,16 @@ dump(off_t current_offset, off_t end_offset)
	static void
	dump_strings(off_t address, off_t end_offset)
	{
-	unsigned bufsize = MAX(100, string_min);
+	unsigned bufsize = MAX(100, G.string_min);
	unsigned char *buf = xmalloc(bufsize);

	while (1) {
	size_t i;
	int c;

-	/* See if the next 'string_min' chars are all printing chars. */
+	/* See if the next 'G.string_min' chars are all printing chars. */
	tryline:
-	if ((option_mask32 & OPT_N) && (end_offset - string_min <= address))
+	if ((option_mask32 & OPT_N) && (end_offset - G.string_min <= address))
	break;
	i = 0;
	while (!(option_mask32 & OPT_N) \|\| address < end_offset) {
@@ -1077,8 +1089,8 @@ dump_strings(off_t address, off_t end_offset)
	buf = xrealloc(buf, bufsize);
	}

-	while (in_stream) { /* !EOF */
-	c = fgetc(in_stream);
+	while (G.in_stream) { /* !EOF */
+	c = fgetc(G.in_stream);
	if (c != EOF)
	goto got_char;
	check_and_close();
@@ -1095,12 +1107,12 @@ dump_strings(off_t address, off_t end_offset)
	buf[i++] = c; /* String continues; store it all. */
	}

-	if (i < string_min) /* Too short! */
+	if (i < G.string_min) /* Too short! */
	goto tryline;

	/* If we get here, the string is all printable and NUL-terminated */
	buf[i] = 0;
-	format_address(address - i - 1, ' ');
+	G.format_address(address - i - 1, ' ');

	for (i = 0; (c = buf[i]); i++) {
	switch (c) {
@@ -1118,7 +1130,7 @@ dump_strings(off_t address, off_t end_offset)
	}

	/* We reach this point only if we search through
-	(max_bytes_to_format - string_min) bytes before reaching EOF. */
+	(max_bytes_to_format - G.string_min) bytes before reaching EOF. */
	check_and_close();
	ret:
	free(buf);
@@ -1190,8 +1202,10 @@ int od_main(int argc UNUSED_PARAM, char **argv)
	/* The maximum number of bytes that will be formatted. */
	off_t max_bytes_to_format = 0;

-	spec = NULL;
-	format_address = format_address_std;
+	INIT_G();
+
+	/G.spec = NULL; - already is /
+	G.format_address = format_address_std;
	address_base_char = 'o';
	address_pad_len_char = '7';

@@ -1217,7 +1231,7 @@ int od_main(int argc UNUSED_PARAM, char **argv)
	bb_error_msg_and_die("bad output address radix "
	"'%c' (must be [doxn])", str_A[0]);
	pos = p - doxn;
-	if (pos == 3) format_address = format_address_none;
+	if (pos == 3) G.format_address = format_address_none;
	address_base_char = doxn_address_base_char[pos];
	address_pad_len_char = doxn_address_pad_len_char[pos];
	}
@@ -1240,11 +1254,11 @@ int od_main(int argc UNUSED_PARAM, char **argv)
	if (opt & OPT_x) decode_format_string("x2");
	if (opt & OPT_s) decode_format_string("d2");
	if (opt & OPT_S) {
-	string_min = xstrtou_sfx(str_S, 0, bkm_suffixes);
+	G.string_min = xstrtou_sfx(str_S, 0, bkm_suffixes);
	}

	// Bloat:
-	//if ((option_mask32 & OPT_S) && n_specs > 0)
+	//if ((option_mask32 & OPT_S) && G.n_specs > 0)
	// bb_error_msg_and_die("no type may be specified when dumping strings");

	/* If the --traditional option is used, there may be from
@@ -1300,14 +1314,14 @@ int od_main(int argc UNUSED_PARAM, char **argv)
	}

	if (pseudo_start >= 0) {
-	if (format_address == format_address_none) {
+	if (G.format_address == format_address_none) {
	address_base_char = 'o';
	address_pad_len_char = '7';
-	format_address = format_address_paren;
+	G.format_address = format_address_paren;
	} else {
-	format_address = format_address_label;
+	G.format_address = format_address_label;
	}
-	pseudo_offset = pseudo_start - n_bytes_to_skip;
+	G_pseudo_offset = pseudo_start - n_bytes_to_skip;
	}
	}
	/* else: od --traditional (without args) */
@@ -1320,45 +1334,45 @@ int od_main(int argc UNUSED_PARAM, char **argv)
	bb_error_msg_and_die("SKIP + SIZE is too large");
	}

-	if (n_specs == 0) {
+	if (G.n_specs == 0) {
	decode_format_string("o2");
-	/n_specs = 1; - done by decode_format_string /
+	/G.n_specs = 1; - done by decode_format_string /
	}

	/* If no files were listed on the command line,
	set the global pointer FILE_LIST so that it
	references the null-terminated list of one name: "-". */
-	file_list = bb_argv_dash;
+	G.file_list = bb_argv_dash;
	if (argv[0]) {
	/* Set the global pointer FILE_LIST so that it
	references the first file-argument on the command-line. */
-	file_list = (char const const ) argv;
+	G.file_list = (char const const ) argv;
	}

	/* Open the first input file */
	open_next_file();
	/* Skip over any unwanted header bytes */
	skip(n_bytes_to_skip);
-	if (!in_stream)
+	if (!G.in_stream)
	return EXIT_FAILURE;

	/* Compute output block length */
	l_c_m = get_lcm();

	if (opt & OPT_w) { /* -w: width */
-	if (!bytes_per_block \|\| bytes_per_block % l_c_m != 0) {
+	if (!G.bytes_per_block \|\| G.bytes_per_block % l_c_m != 0) {
	bb_error_msg("warning: invalid width %u; using %d instead",
-	(unsigned)bytes_per_block, l_c_m);
-	bytes_per_block = l_c_m;
+	(unsigned)G.bytes_per_block, l_c_m);
+	G.bytes_per_block = l_c_m;
	}
	} else {
-	bytes_per_block = l_c_m;
+	G.bytes_per_block = l_c_m;
	if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
-	bytes_per_block *= DEFAULT_BYTES_PER_BLOCK / l_c_m;
+	G.bytes_per_block *= DEFAULT_BYTES_PER_BLOCK / l_c_m;
	}

	#ifdef DEBUG
-	for (i = 0; i < n_specs; i++) {
+	for (i = 0; i < G.n_specs; i++) {
	printf("%d: fmt=\"%s\" width=%d\n",
	i, spec[i].fmt_string, width_bytes[spec[i].size]);
	}
@@ -1372,5 +1386,5 @@ int od_main(int argc UNUSED_PARAM, char **argv)
	if (fclose(stdin))
	bb_perror_msg_and_die(bb_msg_standard_input);

-	return exit_code;
+	return G.exit_code;
	}