/* od -- dump files in octal and other formats
- Copyright (C) 92, 1995-2008 Free Software Foundation, Inc.
+ Copyright (C) 1992-2013 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include <sys/types.h>
#include "system.h"
#include "error.h"
+#include "ftoastr.h"
#include "quote.h"
+#include "xfreopen.h"
#include "xprintf.h"
#include "xstrtol.h"
-/* The official name of this program (e.g., no `g' prefix). */
+/* The official name of this program (e.g., no 'g' prefix). */
#define PROGRAM_NAME "od"
#define AUTHORS proper_name ("Jim Meyering")
-#include <float.h>
-
/* The default number of input bytes per output line. */
#define DEFAULT_BYTES_PER_BLOCK 16
-/* The number of decimal digits of precision in a float. */
-#ifndef FLT_DIG
-# define FLT_DIG 7
-#endif
-
-/* The number of decimal digits of precision in a double. */
-#ifndef DBL_DIG
-# define DBL_DIG 15
-#endif
-
#if HAVE_UNSIGNED_LONG_LONG_INT
typedef unsigned long long int unsigned_long_long_int;
#else
-/* This is just a place-holder to avoid a few `#if' directives.
+/* This is just a place-holder to avoid a few '#if' directives.
In this case, the type isn't actually used. */
typedef unsigned long int unsigned_long_long_int;
#endif
enum
{
FMT_BYTES_ALLOCATED =
- MAX ((sizeof "%*.99" - 1
- + MAX (sizeof "ld",
- MAX (sizeof PRIdMAX,
- MAX (sizeof PRIoMAX,
- MAX (sizeof PRIuMAX,
- sizeof PRIxMAX))))),
- sizeof "%*.99Le")
+ (sizeof "%*.99" - 1
+ + MAX (sizeof "ld",
+ MAX (sizeof PRIdMAX,
+ MAX (sizeof PRIoMAX,
+ MAX (sizeof PRIuMAX,
+ sizeof PRIxMAX)))))
};
/* Ensure that our choice for FMT_BYTES_ALLOCATED is reasonable. */
-verify (LDBL_DIG <= 99);
verify (MAX_INTEGRAL_TYPE_SIZE * CHAR_BIT / 3 <= 99);
-/* Each output format specification (from `-t spec' or from
+/* Each output format specification (from '-t spec' or from
old-style options) is represented by one of these structures. */
struct tspec
{
leading space, and PAD is total pad to divide among FIELDS.
PAD is at least as large as FIELDS. */
void (*print_function) (size_t fields, size_t blank, void const *data,
- char const *fmt, int width, int pad);
+ char const *fmt, int width, int pad);
char fmt_string[FMT_BYTES_ALLOCATED]; /* Of the style "%*d". */
bool hexl_mode_trailer;
int field_width; /* Minimum width of a field, excluding leading space. */
/* It'll be a while before we see integral types wider than 16 bytes,
but if/when it happens, this check will catch it. Without this check,
a wider type would provoke a buffer overrun. */
-verify (MAX_INTEGRAL_TYPE_SIZE
- < sizeof bytes_to_hex_digits / sizeof *bytes_to_hex_digits);
+verify (MAX_INTEGRAL_TYPE_SIZE < ARRAY_CARDINALITY (bytes_to_hex_digits));
/* Make sure the other arrays have the same length. */
verify (sizeof bytes_to_oct_digits == sizeof bytes_to_signed_dec_digits);
sizeof (long double)
};
-/* Ensure that for each member of `enum size_spec' there is an
+/* Ensure that for each member of 'enum size_spec' there is an
initializer in the width_bytes array. */
-verify (sizeof width_bytes / sizeof width_bytes[0] == N_SIZE_SPECS);
+verify (ARRAY_CARDINALITY (width_bytes) == N_SIZE_SPECS);
/* Names for some non-printing characters. */
static char const charname[33][4] =
offset and pseudo-start address. */
static bool traditional;
-/* True if an old-style `pseudo-address' was specified. */
+/* True if an old-style 'pseudo-address' was specified. */
static bool flag_pseudo_start;
/* The difference between the old-style pseudo starting address and
usage (int status)
{
if (status != EXIT_SUCCESS)
- fprintf (stderr, _("Try `%s --help' for more information.\n"),
- program_name);
+ emit_try_help ();
else
{
printf (_("\
or: %s [-abcdfilosx]... [FILE] [[+]OFFSET[.][b]]\n\
or: %s --traditional [OPTION]... [FILE] [[+]OFFSET[.][b] [+][LABEL][.][b]]\n\
"),
- program_name, program_name, program_name);
+ program_name, program_name, program_name);
fputs (_("\n\
Write an unambiguous representation, octal bytes by default,\n\
of FILE to standard output. With more than one FILE argument,\n\
\n\
"), stdout);
fputs (_("\
-All arguments to long options are mandatory for short options.\n\
+If first and second call formats both apply, the second format is assumed\n\
+if the last operand begins with + or (if there are 2 operands) a digit.\n\
+An OFFSET operand means -j OFFSET. LABEL is the pseudo-address\n\
+at first byte printed, incremented when dump is progressing.\n\
+For OFFSET and LABEL, a 0x or 0X prefix indicates hexadecimal;\n\
+suffixes may be . for octal and b for multiply by 512.\n\
+\n\
"), stdout);
fputs (_("\
- -A, --address-radix=RADIX decide how file offsets are printed\n\
+Mandatory arguments to long options are mandatory for short options too.\n\
+"), stdout);
+ fputs (_("\
+ -A, --address-radix=RADIX output format for file offsets. RADIX is one\n\
+ of [doxn], for Decimal, Octal, Hex or None\n\
-j, --skip-bytes=BYTES skip BYTES input bytes first\n\
"), stdout);
fputs (_("\
-N, --read-bytes=BYTES limit dump to BYTES input bytes\n\
- -S, --strings[=BYTES] output strings of at least BYTES graphic chars\n\
+ -S BYTES, --strings[=BYTES] output strings of at least BYTES graphic chars.\
+\n\
+ 3 is implied when BYTES is not specified\n\
-t, --format=TYPE select output format or formats\n\
-v, --output-duplicates do not use * to mark line suppression\n\
- -w, --width[=BYTES] output BYTES bytes per output line\n\
- --traditional accept arguments in traditional form\n\
+ -w[BYTES], --width[=BYTES] output BYTES bytes per output line.\n\
+ 32 is implied when BYTES is not specified\n\
+ --traditional accept arguments in third form above\n\
"), stdout);
fputs (HELP_OPTION_DESCRIPTION, stdout);
fputs (VERSION_OPTION_DESCRIPTION, stdout);
fputs (_("\
\n\
+\n\
Traditional format specifications may be intermixed; they accumulate:\n\
-a same as -t a, select named characters, ignoring high-order bit\n\
-b same as -t o1, select octal bytes\n\
"), stdout);
fputs (_("\
\n\
-If first and second call formats both apply, the second format is assumed\n\
-if the last operand begins with + or (if there are 2 operands) a digit.\n\
-An OFFSET operand means -j OFFSET. LABEL is the pseudo-address\n\
-at first byte printed, incremented when dump is progressing.\n\
-For OFFSET and LABEL, a 0x or 0X prefix indicates hexadecimal;\n\
-suffixes may be . for octal and b for multiply by 512.\n\
-"), stdout);
- fputs (_("\
\n\
TYPE is made up of one or more of these specifications:\n\
-\n\
a named character, ignoring high-order bit\n\
c ASCII character or backslash escape\n\
"), stdout);
"), stdout);
fputs (_("\
\n\
-SIZE is a number. For TYPE in doux, SIZE may also be C for\n\
+SIZE is a number. For TYPE in [doux], SIZE may also be C for\n\
sizeof(char), S for sizeof(short), I for sizeof(int) or L for\n\
sizeof(long). If TYPE is f, SIZE may also be F for sizeof(float), D\n\
for sizeof(double) or L for sizeof(long double).\n\
"), stdout);
fputs (_("\
\n\
-RADIX is d for decimal, o for octal, x for hexadecimal or n for none.\n\
-BYTES is hexadecimal with 0x or 0X prefix, and may have a multiplier suffix:\n\
-b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,\n\
-GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.\n\
-Adding a z suffix to any type displays printable characters at the end of each\n\
-output line.\n\
+Adding a z suffix to any type displays printable characters at the end of\n\
+each output line.\n\
"), stdout);
fputs (_("\
-Option --string without a number implies 3; option --width without a number\n\
-implies 32. By default, od uses -A o -t oS -w16.\n\
+\n\
+\n\
+BYTES is hex with 0x or 0X prefix, and may have a multiplier suffix:\n\
+ b 512\n\
+ KB 1000\n\
+ K 1024\n\
+ MB 1000*1000\n\
+ M 1024*1024\n\
+and so on for G, T, P, E, Z, Y.\n\
"), stdout);
- emit_bug_reporting_address ();
+ emit_ancillary_info ();
}
exit (status);
}
/* Define the print functions. */
-#define PRINT_TYPE(N, T) \
+#define PRINT_FIELDS(N, T, FMT_STRING, ACTION) \
static void \
N (size_t fields, size_t blank, void const *block, \
- char const *fmt_string, int width, int pad) \
+ char const *FMT_STRING, int width, int pad) \
{ \
T const *p = block; \
size_t i; \
for (i = fields; blank < i; i--) \
{ \
int next_pad = pad * (i - 1) / fields; \
- xprintf (fmt_string, pad_remaining - next_pad + width, *p++); \
+ int adjusted_width = pad_remaining - next_pad + width; \
+ T x = *p++; \
+ ACTION; \
pad_remaining = next_pad; \
} \
}
+#define PRINT_TYPE(N, T) \
+ PRINT_FIELDS (N, T, fmt_string, xprintf (fmt_string, adjusted_width, x))
+
+#define PRINT_FLOATTYPE(N, T, FTOASTR, BUFSIZE) \
+ PRINT_FIELDS (N, T, fmt_string ATTRIBUTE_UNUSED, \
+ char buf[BUFSIZE]; \
+ FTOASTR (buf, sizeof buf, 0, 0, x); \
+ xprintf ("%*s", adjusted_width, buf))
+
PRINT_TYPE (print_s_char, signed char)
PRINT_TYPE (print_char, unsigned char)
PRINT_TYPE (print_s_short, short int)
PRINT_TYPE (print_int, unsigned int)
PRINT_TYPE (print_long, unsigned long int)
PRINT_TYPE (print_long_long, unsigned_long_long_int)
-PRINT_TYPE (print_float, float)
-PRINT_TYPE (print_double, double)
-PRINT_TYPE (print_long_double, long double)
+
+PRINT_FLOATTYPE (print_float, float, ftoastr, FLT_BUFSIZE_BOUND)
+PRINT_FLOATTYPE (print_double, double, dtoastr, DBL_BUFSIZE_BOUND)
+PRINT_FLOATTYPE (print_long_double, long double, ldtoastr, LDBL_BUFSIZE_BOUND)
#undef PRINT_TYPE
+#undef PRINT_FLOATTYPE
static void
dump_hexl_mode_trailer (size_t n_bytes, const char *block)
static void
print_named_ascii (size_t fields, size_t blank, void const *block,
- const char *unused_fmt_string ATTRIBUTE_UNUSED,
- int width, int pad)
+ const char *unused_fmt_string ATTRIBUTE_UNUSED,
+ int width, int pad)
{
unsigned char const *p = block;
size_t i;
char buf[2];
if (masked_c == 127)
- s = "del";
+ s = "del";
else if (masked_c <= 040)
- s = charname[masked_c];
+ s = charname[masked_c];
else
- {
- buf[0] = masked_c;
- buf[1] = 0;
- s = buf;
- }
+ {
+ buf[0] = masked_c;
+ buf[1] = 0;
+ s = buf;
+ }
xprintf ("%*s", pad_remaining - next_pad + width, s);
pad_remaining = next_pad;
static void
print_ascii (size_t fields, size_t blank, void const *block,
- const char *unused_fmt_string ATTRIBUTE_UNUSED, int width,
- int pad)
+ const char *unused_fmt_string ATTRIBUTE_UNUSED, int width,
+ int pad)
{
unsigned char const *p = block;
size_t i;
char buf[4];
switch (c)
- {
- case '\0':
- s = "\\0";
- break;
+ {
+ case '\0':
+ s = "\\0";
+ break;
- case '\a':
- s = "\\a";
- break;
+ case '\a':
+ s = "\\a";
+ break;
- case '\b':
- s = "\\b";
- break;
+ case '\b':
+ s = "\\b";
+ break;
- case '\f':
- s = "\\f";
- break;
+ case '\f':
+ s = "\\f";
+ break;
- case '\n':
- s = "\\n";
- break;
+ case '\n':
+ s = "\\n";
+ break;
- case '\r':
- s = "\\r";
- break;
+ case '\r':
+ s = "\\r";
+ break;
- case '\t':
- s = "\\t";
- break;
+ case '\t':
+ s = "\\t";
+ break;
- case '\v':
- s = "\\v";
- break;
+ case '\v':
+ s = "\\v";
+ break;
- default:
- sprintf (buf, (isprint (c) ? "%c" : "%03o"), c);
- s = buf;
- }
+ default:
+ sprintf (buf, (isprint (c) ? "%c" : "%03o"), c);
+ s = buf;
+ }
xprintf ("%*s", pad_remaining - next_pad + width, s);
pad_remaining = next_pad;
{
int c = *s++ - '0';
if (sum > (ULONG_MAX - c) / 10)
- return false;
+ return false;
sum = sum * 10 + c;
}
*p = s;
static bool
decode_one_format (const char *s_orig, const char *s, const char **next,
- struct tspec *tspec)
+ struct tspec *tspec)
{
enum size_spec size_spec;
unsigned long int size;
enum output_format fmt;
- const char *pre_fmt_string;
void (*print_function) (size_t, size_t, void const *, char const *,
- int, int);
+ int, int);
const char *p;
char c;
int field_width;
- int precision;
assert (tspec != NULL);
c = *s;
++s;
switch (*s)
- {
- case 'C':
- ++s;
- size = sizeof (char);
- break;
-
- case 'S':
- ++s;
- size = sizeof (short int);
- break;
-
- case 'I':
- ++s;
- size = sizeof (int);
- break;
-
- case 'L':
- ++s;
- size = sizeof (long int);
- break;
-
- default:
- if (! simple_strtoul (s, &p, &size))
- {
- /* The integer at P in S would overflow an unsigned long int.
- A digit string that long is sufficiently odd looking
- that the following diagnostic is sufficient. */
- error (0, 0, _("invalid type string %s"), quote (s_orig));
- return false;
- }
- if (p == s)
- size = sizeof (int);
- else
- {
- if (MAX_INTEGRAL_TYPE_SIZE < size
- || integral_type_size[size] == NO_SIZE)
- {
- error (0, 0, _("invalid type string %s;\n\
-this system doesn't provide a %lu-byte integral type"), quote (s_orig), size);
- return false;
- }
- s = p;
- }
- break;
- }
+ {
+ case 'C':
+ ++s;
+ size = sizeof (char);
+ break;
+
+ case 'S':
+ ++s;
+ size = sizeof (short int);
+ break;
+
+ case 'I':
+ ++s;
+ size = sizeof (int);
+ break;
+
+ case 'L':
+ ++s;
+ size = sizeof (long int);
+ break;
+
+ default:
+ if (! simple_strtoul (s, &p, &size))
+ {
+ /* The integer at P in S would overflow an unsigned long int.
+ A digit string that long is sufficiently odd looking
+ that the following diagnostic is sufficient. */
+ error (0, 0, _("invalid type string %s"), quote (s_orig));
+ return false;
+ }
+ if (p == s)
+ size = sizeof (int);
+ else
+ {
+ if (MAX_INTEGRAL_TYPE_SIZE < size
+ || integral_type_size[size] == NO_SIZE)
+ {
+ error (0, 0, _("invalid type string %s;\nthis system"
+ " doesn't provide a %lu-byte integral type"),
+ quote (s_orig), size);
+ return false;
+ }
+ s = p;
+ }
+ break;
+ }
#define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \
((Spec) == LONG_LONG ? (Max_format) \
size_spec = integral_type_size[size];
switch (c)
- {
- case 'd':
- fmt = SIGNED_DECIMAL;
- field_width = bytes_to_signed_dec_digits[size];
- sprintf (tspec->fmt_string, "%%*%s",
- ISPEC_TO_FORMAT (size_spec, "d", "ld", PRIdMAX));
- break;
-
- case 'o':
- fmt = OCTAL;
- sprintf (tspec->fmt_string, "%%*.%d%s",
- (field_width = bytes_to_oct_digits[size]),
- ISPEC_TO_FORMAT (size_spec, "o", "lo", PRIoMAX));
- break;
-
- case 'u':
- fmt = UNSIGNED_DECIMAL;
- field_width = bytes_to_unsigned_dec_digits[size];
- sprintf (tspec->fmt_string, "%%*%s",
- ISPEC_TO_FORMAT (size_spec, "u", "lu", PRIuMAX));
- break;
-
- case 'x':
- fmt = HEXADECIMAL;
- sprintf (tspec->fmt_string, "%%*.%d%s",
- (field_width = bytes_to_hex_digits[size]),
- ISPEC_TO_FORMAT (size_spec, "x", "lx", PRIxMAX));
- break;
-
- default:
- abort ();
- }
+ {
+ case 'd':
+ fmt = SIGNED_DECIMAL;
+ field_width = bytes_to_signed_dec_digits[size];
+ sprintf (tspec->fmt_string, "%%*%s",
+ ISPEC_TO_FORMAT (size_spec, "d", "ld", PRIdMAX));
+ break;
+
+ case 'o':
+ fmt = OCTAL;
+ sprintf (tspec->fmt_string, "%%*.%d%s",
+ (field_width = bytes_to_oct_digits[size]),
+ ISPEC_TO_FORMAT (size_spec, "o", "lo", PRIoMAX));
+ break;
+
+ case 'u':
+ fmt = UNSIGNED_DECIMAL;
+ field_width = bytes_to_unsigned_dec_digits[size];
+ sprintf (tspec->fmt_string, "%%*%s",
+ ISPEC_TO_FORMAT (size_spec, "u", "lu", PRIuMAX));
+ break;
+
+ case 'x':
+ fmt = HEXADECIMAL;
+ sprintf (tspec->fmt_string, "%%*.%d%s",
+ (field_width = bytes_to_hex_digits[size]),
+ ISPEC_TO_FORMAT (size_spec, "x", "lx", PRIxMAX));
+ break;
+
+ default:
+ abort ();
+ }
assert (strlen (tspec->fmt_string) < FMT_BYTES_ALLOCATED);
switch (size_spec)
- {
- case CHAR:
- print_function = (fmt == SIGNED_DECIMAL
- ? print_s_char
- : print_char);
- break;
-
- case SHORT:
- print_function = (fmt == SIGNED_DECIMAL
- ? print_s_short
- : print_short);
- break;
-
- case INT:
- print_function = print_int;
- break;
-
- case LONG:
- print_function = print_long;
- break;
-
- case LONG_LONG:
- print_function = print_long_long;
- break;
-
- default:
- abort ();
- }
+ {
+ case CHAR:
+ print_function = (fmt == SIGNED_DECIMAL
+ ? print_s_char
+ : print_char);
+ break;
+
+ case SHORT:
+ print_function = (fmt == SIGNED_DECIMAL
+ ? print_s_short
+ : print_short);
+ break;
+
+ case INT:
+ print_function = print_int;
+ break;
+
+ case LONG:
+ print_function = print_long;
+ break;
+
+ case LONG_LONG:
+ print_function = print_long_long;
+ break;
+
+ default:
+ abort ();
+ }
break;
case 'f':
fmt = FLOATING_POINT;
++s;
switch (*s)
- {
- case 'F':
- ++s;
- size = sizeof (float);
- break;
-
- case 'D':
- ++s;
- size = sizeof (double);
- break;
-
- case 'L':
- ++s;
- size = sizeof (long double);
- break;
-
- default:
- if (! simple_strtoul (s, &p, &size))
- {
- /* The integer at P in S would overflow an unsigned long int.
- A digit string that long is sufficiently odd looking
- that the following diagnostic is sufficient. */
- error (0, 0, _("invalid type string %s"), quote (s_orig));
- return false;
- }
- if (p == s)
- size = sizeof (double);
- else
- {
- if (size > MAX_FP_TYPE_SIZE
- || fp_type_size[size] == NO_SIZE)
- {
- error (0, 0, _("invalid type string %s;\n\
-this system doesn't provide a %lu-byte floating point type"),
- quote (s_orig), size);
- return false;
- }
- s = p;
- }
- break;
- }
+ {
+ case 'F':
+ ++s;
+ size = sizeof (float);
+ break;
+
+ case 'D':
+ ++s;
+ size = sizeof (double);
+ break;
+
+ case 'L':
+ ++s;
+ size = sizeof (long double);
+ break;
+
+ default:
+ if (! simple_strtoul (s, &p, &size))
+ {
+ /* The integer at P in S would overflow an unsigned long int.
+ A digit string that long is sufficiently odd looking
+ that the following diagnostic is sufficient. */
+ error (0, 0, _("invalid type string %s"), quote (s_orig));
+ return false;
+ }
+ if (p == s)
+ size = sizeof (double);
+ else
+ {
+ if (size > MAX_FP_TYPE_SIZE
+ || fp_type_size[size] == NO_SIZE)
+ {
+ error (0, 0,
+ _("invalid type string %s;\n"
+ "this system doesn't provide a %lu-byte"
+ " floating point type"),
+ quote (s_orig), size);
+ return false;
+ }
+ s = p;
+ }
+ break;
+ }
size_spec = fp_type_size[size];
- switch (size_spec)
- {
- case FLOAT_SINGLE:
- print_function = print_float;
- /* FIXME - should we use %g instead of %e? */
- pre_fmt_string = "%%*.%de";
- precision = FLT_DIG;
- break;
-
- case FLOAT_DOUBLE:
- print_function = print_double;
- pre_fmt_string = "%%*.%de";
- precision = DBL_DIG;
- break;
-
- case FLOAT_LONG_DOUBLE:
- print_function = print_long_double;
- pre_fmt_string = "%%*.%dLe";
- precision = LDBL_DIG;
- break;
-
- default:
- abort ();
- }
-
- field_width = precision + 8;
- sprintf (tspec->fmt_string, pre_fmt_string, precision);
- assert (strlen (tspec->fmt_string) < FMT_BYTES_ALLOCATED);
- break;
+ {
+ struct lconv const *locale = localeconv ();
+ size_t decimal_point_len =
+ (locale->decimal_point[0] ? strlen (locale->decimal_point) : 1);
+
+ switch (size_spec)
+ {
+ case FLOAT_SINGLE:
+ print_function = print_float;
+ field_width = FLT_STRLEN_BOUND_L (decimal_point_len);
+ break;
+
+ case FLOAT_DOUBLE:
+ print_function = print_double;
+ field_width = DBL_STRLEN_BOUND_L (decimal_point_len);
+ break;
+
+ case FLOAT_LONG_DOUBLE:
+ print_function = print_long_double;
+ field_width = LDBL_STRLEN_BOUND_L (decimal_point_len);
+ break;
+
+ default:
+ abort ();
+ }
+
+ break;
+ }
case 'a':
++s;
break;
default:
- error (0, 0, _("invalid character `%c' in type string %s"),
- *s, quote (s_orig));
+ error (0, 0, _("invalid character '%c' in type string %s"),
+ *s, quote (s_orig));
return false;
}
{
input_filename = *file_list;
if (input_filename == NULL)
- return ok;
+ return ok;
++file_list;
if (STREQ (input_filename, "-"))
- {
- input_filename = _("standard input");
- in_stream = stdin;
- have_read_stdin = true;
- if (O_BINARY && ! isatty (STDIN_FILENO))
- freopen (NULL, "rb", stdin);
- }
+ {
+ input_filename = _("standard input");
+ in_stream = stdin;
+ have_read_stdin = true;
+ if (O_BINARY && ! isatty (STDIN_FILENO))
+ xfreopen (NULL, "rb", stdin);
+ }
else
- {
- in_stream = fopen (input_filename, (O_BINARY ? "rb" : "r"));
- if (in_stream == NULL)
- {
- error (0, errno, "%s", input_filename);
- ok = false;
- }
- }
+ {
+ in_stream = fopen (input_filename, (O_BINARY ? "rb" : "r"));
+ if (in_stream == NULL)
+ {
+ error (0, errno, "%s", input_filename);
+ ok = false;
+ }
+ }
}
while (in_stream == NULL);
- if (limit_bytes_to_format & !flag_dump_strings)
+ if (limit_bytes_to_format && !flag_dump_strings)
setvbuf (in_stream, NULL, _IONBF, 0);
return ok;
if (in_stream != NULL)
{
if (ferror (in_stream))
- {
- error (0, in_errno, _("%s: read error"), input_filename);
- if (! STREQ (file_list[-1], "-"))
- fclose (in_stream);
- ok = false;
- }
+ {
+ error (0, in_errno, _("%s: read error"), input_filename);
+ if (! STREQ (file_list[-1], "-"))
+ fclose (in_stream);
+ ok = false;
+ }
else if (! STREQ (file_list[-1], "-") && fclose (in_stream) != 0)
- {
- error (0, errno, "%s", input_filename);
- ok = false;
- }
+ {
+ error (0, errno, "%s", input_filename);
+ ok = false;
+ }
in_stream = NULL;
}
const char *next;
if (n_specs_allocated <= n_specs)
- spec = X2NREALLOC (spec, &n_specs_allocated);
+ spec = X2NREALLOC (spec, &n_specs_allocated);
if (! decode_one_format (s_orig, s, &next, &spec[n_specs]))
- return false;
+ return false;
assert (s != next);
s = next;
struct stat file_stats;
/* First try seeking. For large offsets, this extra work is
- worthwhile. If the offset is below some threshold it may be
- more efficient to move the pointer by reading. There are two
- issues when trying to seek:
- - the file must be seekable.
- - before seeking to the specified position, make sure
- that the new position is in the current file.
- Try to do that by getting file's size using fstat.
- But that will work only for regular files. */
+ worthwhile. If the offset is below some threshold it may be
+ more efficient to move the pointer by reading. There are two
+ issues when trying to seek:
+ - the file must be seekable.
+ - before seeking to the specified position, make sure
+ that the new position is in the current file.
+ Try to do that by getting file's size using fstat.
+ But that will work only for regular files. */
if (fstat (fileno (in_stream), &file_stats) == 0)
- {
- /* The st_size field is valid only for regular files
- (and for symbolic links, which cannot occur here).
- If the number of bytes left to skip is larger than
- the size of the current file, we can decrement n_skip
- and go on to the next file. Skip this optimization also
- when st_size is 0, because some kernels report that
- nonempty files in /proc have st_size == 0. */
- if (S_ISREG (file_stats.st_mode) && 0 < file_stats.st_size)
- {
- if ((uintmax_t) file_stats.st_size < n_skip)
- n_skip -= file_stats.st_size;
- else
- {
- if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
- {
- in_errno = errno;
- ok = false;
- }
- n_skip = 0;
- }
- }
-
- /* If it's not a regular file with nonnegative size,
- position the file pointer by reading. */
-
- else
- {
- char buf[BUFSIZ];
- size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
-
- while (0 < n_skip)
- {
- 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_skip -= n_bytes_read;
- if (n_bytes_read != n_bytes_to_read)
- {
- in_errno = errno;
- ok = false;
- n_skip = 0;
- break;
- }
- }
- }
-
- if (n_skip == 0)
- break;
- }
+ {
+ /* The st_size field is valid for regular files.
+ If the number of bytes left to skip is larger than
+ the size of the current file, we can decrement n_skip
+ and go on to the next file. Skip this optimization also
+ when st_size is 0, because some kernels report that
+ nonempty files in /proc have st_size == 0. */
+ if (S_ISREG (file_stats.st_mode) && 0 < file_stats.st_size)
+ {
+ if ((uintmax_t) file_stats.st_size < n_skip)
+ n_skip -= file_stats.st_size;
+ else
+ {
+ if (fseeko (in_stream, n_skip, SEEK_CUR) != 0)
+ {
+ in_errno = errno;
+ ok = false;
+ }
+ n_skip = 0;
+ }
+ }
+
+ /* If it's not a regular file with nonnegative size,
+ position the file pointer by reading. */
+
+ else
+ {
+ char buf[BUFSIZ];
+ size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
+
+ while (0 < n_skip)
+ {
+ 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_skip -= n_bytes_read;
+ if (n_bytes_read != n_bytes_to_read)
+ {
+ in_errno = errno;
+ ok = false;
+ n_skip = 0;
+ break;
+ }
+ }
+ }
+
+ if (n_skip == 0)
+ break;
+ }
else /* cannot fstat() file */
- {
- error (0, errno, "%s", input_filename);
- ok = false;
- }
+ {
+ error (0, errno, "%s", input_filename);
+ ok = false;
+ }
ok &= check_and_close (in_errno);
}
static void
-format_address_none (uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
+format_address_none (uintmax_t address ATTRIBUTE_UNUSED,
+ char c ATTRIBUTE_UNUSED)
{
}
{
case 8:
do
- *--p = '0' + (address & 7);
+ *--p = '0' + (address & 7);
while ((address >>= 3) != 0);
break;
case 10:
do
- *--p = '0' + (address % 10);
+ *--p = '0' + (address % 10);
while ((address /= 10) != 0);
break;
case 16:
do
- *--p = "0123456789abcdef"[address & 15];
+ *--p = "0123456789abcdef"[address & 15];
while ((address >>= 4) != 0);
break;
}
static void
write_block (uintmax_t current_offset, size_t n_bytes,
- const char *prev_block, const char *curr_block)
+ const char *prev_block, const char *curr_block)
{
static bool first = true;
static bool prev_pair_equal = false;
&& EQUAL_BLOCKS (prev_block, curr_block))
{
if (prev_pair_equal)
- {
- /* The two preceding blocks were equal, and the current
- block is the same as the last one, so print nothing. */
- }
+ {
+ /* The two preceding blocks were equal, and the current
+ block is the same as the last one, so print nothing. */
+ }
else
- {
- printf ("*\n");
- prev_pair_equal = true;
- }
+ {
+ printf ("*\n");
+ prev_pair_equal = true;
+ }
}
else
{
prev_pair_equal = false;
for (i = 0; i < n_specs; i++)
- {
- int datum_width = width_bytes[spec[i].size];
- int fields_per_block = bytes_per_block / datum_width;
- int blank_fields = (bytes_per_block - n_bytes) / datum_width;
- if (i == 0)
- format_address (current_offset, '\0');
- else
- printf ("%*s", address_pad_len, "");
- (*spec[i].print_function) (fields_per_block, blank_fields,
- curr_block, spec[i].fmt_string,
- spec[i].field_width, spec[i].pad_width);
- if (spec[i].hexl_mode_trailer)
- {
- /* space-pad out to full line width, then dump the trailer */
- int field_width = spec[i].field_width;
- int pad_width = (spec[i].pad_width * blank_fields
- / fields_per_block);
- printf ("%*s", blank_fields * field_width + pad_width, "");
- dump_hexl_mode_trailer (n_bytes, curr_block);
- }
- putchar ('\n');
- }
+ {
+ int datum_width = width_bytes[spec[i].size];
+ int fields_per_block = bytes_per_block / datum_width;
+ int blank_fields = (bytes_per_block - n_bytes) / datum_width;
+ if (i == 0)
+ format_address (current_offset, '\0');
+ else
+ printf ("%*s", address_pad_len, "");
+ (*spec[i].print_function) (fields_per_block, blank_fields,
+ curr_block, spec[i].fmt_string,
+ spec[i].field_width, spec[i].pad_width);
+ if (spec[i].hexl_mode_trailer)
+ {
+ /* space-pad out to full line width, then dump the trailer */
+ int field_width = spec[i].field_width;
+ int pad_width = (spec[i].pad_width * blank_fields
+ / fields_per_block);
+ printf ("%*s", blank_fields * field_width + pad_width, "");
+ dump_hexl_mode_trailer (n_bytes, curr_block);
+ }
+ putchar ('\n');
+ }
}
first = false;
}
*c = fgetc (in_stream);
if (*c != EOF)
- break;
+ break;
ok &= check_and_close (errno);
*n_bytes_in_buffer += n_read;
if (n_read == n_needed)
- break;
+ break;
ok &= check_and_close (errno);
/* Return the least common multiple of the sizes associated
with the format specs. */
-static int
+static int _GL_ATTRIBUTE_PURE
get_lcm (void)
{
size_t i;
if (s[0] == '+')
++s;
- /* Determine the radix we'll use to interpret S. If there is a `.',
- it's decimal, otherwise, if the string begins with `0X'or `0x',
+ /* Determine the radix we'll use to interpret S. If there is a '.',
+ it's decimal, otherwise, if the string begins with '0X'or '0x',
it's hexadecimal, else octal. */
if (strchr (s, '.') != NULL)
radix = 10;
else
{
if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
- radix = 16;
+ radix = 16;
else
- radix = 8;
+ radix = 8;
}
return xstrtoumax (s, NULL, radix, offset, "Bb") == LONGINT_OK;
if (limit_bytes_to_format)
{
while (1)
- {
- size_t n_needed;
- if (current_offset >= end_offset)
- {
- n_bytes_read = 0;
- break;
- }
- n_needed = MIN (end_offset - current_offset,
- (uintmax_t) bytes_per_block);
- ok &= read_block (n_needed, block[idx], &n_bytes_read);
- if (n_bytes_read < bytes_per_block)
- break;
- assert (n_bytes_read == bytes_per_block);
- write_block (current_offset, n_bytes_read,
- block[!idx], block[idx]);
- current_offset += n_bytes_read;
- idx = !idx;
- }
+ {
+ size_t n_needed;
+ if (current_offset >= end_offset)
+ {
+ n_bytes_read = 0;
+ break;
+ }
+ n_needed = MIN (end_offset - current_offset,
+ (uintmax_t) bytes_per_block);
+ ok &= read_block (n_needed, block[idx], &n_bytes_read);
+ if (n_bytes_read < bytes_per_block)
+ break;
+ assert (n_bytes_read == bytes_per_block);
+ write_block (current_offset, n_bytes_read,
+ block[!idx], block[idx]);
+ current_offset += n_bytes_read;
+ idx = !idx;
+ }
}
else
{
while (1)
- {
- ok &= read_block (bytes_per_block, block[idx], &n_bytes_read);
- if (n_bytes_read < bytes_per_block)
- break;
- assert (n_bytes_read == bytes_per_block);
- write_block (current_offset, n_bytes_read,
- block[!idx], block[idx]);
- current_offset += n_bytes_read;
- idx = !idx;
- }
+ {
+ ok &= read_block (bytes_per_block, block[idx], &n_bytes_read);
+ if (n_bytes_read < bytes_per_block)
+ break;
+ assert (n_bytes_read == bytes_per_block);
+ write_block (current_offset, n_bytes_read,
+ block[!idx], block[idx]);
+ current_offset += n_bytes_read;
+ idx = !idx;
+ }
}
if (n_bytes_read > 0)
l_c_m = get_lcm ();
/* Ensure zero-byte padding up to the smallest multiple of l_c_m that
- is at least as large as n_bytes_read. */
+ is at least as large as n_bytes_read. */
bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
memset (block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
}
/* STRINGS mode. Find each "string constant" in the input.
- A string constant is a run of at least `string_min' ASCII
+ A string constant is a run of at least 'string_min' ASCII
graphic (or formatting) characters terminated by a null.
Based on a function written by Richard Stallman for a
traditional version of od. Return true if successful. */
size_t i;
int c;
- /* See if the next `string_min' chars are all printing chars. */
+ /* See if the next 'string_min' chars are all printing chars. */
tryline:
if (limit_bytes_to_format
- && (end_offset < string_min || end_offset - string_min <= address))
- break;
+ && (end_offset < string_min || end_offset - string_min <= address))
+ break;
for (i = 0; i < string_min; i++)
- {
- ok &= read_char (&c);
- address++;
- if (c < 0)
- {
- free (buf);
- return ok;
- }
- if (! isprint (c))
- /* Found a non-printing. Try again starting with next char. */
- goto tryline;
- buf[i] = c;
- }
-
- /* We found a run of `string_min' printable characters.
- Now see if it is terminated with a null byte. */
+ {
+ ok &= read_char (&c);
+ address++;
+ if (c < 0)
+ {
+ free (buf);
+ return ok;
+ }
+ if (! isprint (c))
+ /* Found a non-printing. Try again starting with next char. */
+ goto tryline;
+ buf[i] = c;
+ }
+
+ /* We found a run of 'string_min' printable characters.
+ Now see if it is terminated with a null byte. */
while (!limit_bytes_to_format || address < end_offset)
- {
- if (i == bufsize)
- {
- buf = X2REALLOC (buf, &bufsize);
- }
- ok &= read_char (&c);
- address++;
- if (c < 0)
- {
- free (buf);
- return ok;
- }
- if (c == '\0')
- break; /* It is; print this string. */
- if (! isprint (c))
- goto tryline; /* It isn't; give up on this string. */
- buf[i++] = c; /* String continues; store it all. */
- }
+ {
+ if (i == bufsize)
+ {
+ buf = X2REALLOC (buf, &bufsize);
+ }
+ ok &= read_char (&c);
+ address++;
+ if (c < 0)
+ {
+ free (buf);
+ return ok;
+ }
+ if (c == '\0')
+ break; /* It is; print this string. */
+ if (! isprint (c))
+ goto tryline; /* It isn't; give up on this string. */
+ buf[i++] = c; /* String continues; store it all. */
+ }
/* If we get here, the string is all printable and null-terminated,
- so print it. It is all in `buf' and `i' is its length. */
+ so print it. It is all in 'buf' and 'i' is its length. */
buf[i] = 0;
format_address (address - i - 1, ' ');
for (i = 0; (c = buf[i]); i++)
- {
- switch (c)
- {
- case '\a':
- fputs ("\\a", stdout);
- break;
-
- case '\b':
- fputs ("\\b", stdout);
- break;
-
- case '\f':
- fputs ("\\f", stdout);
- break;
-
- case '\n':
- fputs ("\\n", stdout);
- break;
-
- case '\r':
- fputs ("\\r", stdout);
- break;
-
- case '\t':
- fputs ("\\t", stdout);
- break;
-
- case '\v':
- fputs ("\\v", stdout);
- break;
-
- default:
- putc (c, stdout);
- }
- }
+ {
+ switch (c)
+ {
+ case '\a':
+ fputs ("\\a", stdout);
+ break;
+
+ case '\b':
+ fputs ("\\b", stdout);
+ break;
+
+ case '\f':
+ fputs ("\\f", stdout);
+ break;
+
+ case '\n':
+ fputs ("\\n", stdout);
+ break;
+
+ case '\r':
+ fputs ("\\r", stdout);
+ break;
+
+ case '\t':
+ fputs ("\\t", stdout);
+ break;
+
+ case '\v':
+ fputs ("\\v", stdout);
+ break;
+
+ default:
+ putc (c, stdout);
+ }
+ }
putchar ('\n');
}
int n_files;
size_t i;
int l_c_m;
- size_t desired_width IF_LINT (= 0);
+ size_t desired_width IF_LINT ( = 0);
bool modern = false;
bool width_specified = false;
bool ok = true;
size_t width_per_block = 0;
static char const multipliers[] = "bEGKkMmPTYZ0";
- /* The old-style `pseudo starting address' to be printed in parentheses
+ /* The old-style 'pseudo starting address' to be printed in parentheses
after any true address. */
- uintmax_t pseudo_start IF_LINT (= 0);
+ uintmax_t pseudo_start IF_LINT ( = 0);
initialize_main (&argc, &argv);
set_program_name (argv[0]);
integral_type_size[sizeof (int)] = INT;
integral_type_size[sizeof (long int)] = LONG;
#if HAVE_UNSIGNED_LONG_LONG_INT
- /* If `long int' and `long long int' have the same size, it's fine
- to overwrite the entry for `long' with this one. */
+ /* If 'long int' and 'long long int' have the same size, it's fine
+ to overwrite the entry for 'long' with this one. */
integral_type_size[sizeof (unsigned_long_long_int)] = LONG_LONG;
#endif
fp_type_size[i] = NO_SIZE;
fp_type_size[sizeof (float)] = FLOAT_SINGLE;
- /* The array entry for `double' is filled in after that for `long double'
+ /* The array entry for 'double' is filled in after that for 'long double'
so that if they are the same size, we avoid any overhead of
long double computation in libc. */
fp_type_size[sizeof (long double)] = FLOAT_LONG_DOUBLE;
address_pad_len = 7;
flag_dump_strings = false;
- for (;;)
+ while (true)
{
uintmax_t tmp;
enum strtol_error s_err;
break;
switch (c)
- {
- case 'A':
- modern = true;
- switch (optarg[0])
- {
- case 'd':
- format_address = format_address_std;
- address_base = 10;
- address_pad_len = 7;
- break;
- case 'o':
- format_address = format_address_std;
- address_base = 8;
- address_pad_len = 7;
- break;
- case 'x':
- format_address = format_address_std;
- address_base = 16;
- address_pad_len = 6;
- break;
- case 'n':
- format_address = format_address_none;
- address_pad_len = 0;
- break;
- default:
- error (EXIT_FAILURE, 0,
- _("invalid output address radix `%c'; \
-it must be one character from [doxn]"),
- optarg[0]);
- break;
- }
- break;
-
- case 'j':
- modern = true;
- s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, multipliers);
- if (s_err != LONGINT_OK)
- xstrtol_fatal (s_err, oi, c, long_options, optarg);
- break;
-
- case 'N':
- modern = true;
- limit_bytes_to_format = true;
-
- s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format,
- multipliers);
- if (s_err != LONGINT_OK)
- xstrtol_fatal (s_err, oi, c, long_options, optarg);
- break;
-
- case 'S':
- modern = true;
- if (optarg == NULL)
- string_min = 3;
- else
- {
- s_err = xstrtoumax (optarg, NULL, 0, &tmp, multipliers);
- if (s_err != LONGINT_OK)
- xstrtol_fatal (s_err, oi, c, long_options, optarg);
-
- /* The minimum string length may be no larger than SIZE_MAX,
- since we may allocate a buffer of this size. */
- if (SIZE_MAX < tmp)
- error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
-
- string_min = tmp;
- }
- flag_dump_strings = true;
- break;
-
- case 't':
- modern = true;
- ok &= decode_format_string (optarg);
- break;
-
- case 'v':
- modern = true;
- abbreviate_duplicate_blocks = false;
- break;
-
- case TRADITIONAL_OPTION:
- traditional = true;
- break;
-
- /* The next several cases map the traditional format
- specification options to the corresponding modern format
- specs. GNU od accepts any combination of old- and
- new-style options. Format specification options accumulate.
- The obsolescent and undocumented formats are compatible
- with FreeBSD 4.10 od. */
+ {
+ case 'A':
+ modern = true;
+ switch (optarg[0])
+ {
+ case 'd':
+ format_address = format_address_std;
+ address_base = 10;
+ address_pad_len = 7;
+ break;
+ case 'o':
+ format_address = format_address_std;
+ address_base = 8;
+ address_pad_len = 7;
+ break;
+ case 'x':
+ format_address = format_address_std;
+ address_base = 16;
+ address_pad_len = 6;
+ break;
+ case 'n':
+ format_address = format_address_none;
+ address_pad_len = 0;
+ break;
+ default:
+ error (EXIT_FAILURE, 0,
+ _("invalid output address radix '%c';\
+ it must be one character from [doxn]"),
+ optarg[0]);
+ break;
+ }
+ break;
+
+ case 'j':
+ modern = true;
+ s_err = xstrtoumax (optarg, NULL, 0, &n_bytes_to_skip, multipliers);
+ if (s_err != LONGINT_OK)
+ xstrtol_fatal (s_err, oi, c, long_options, optarg);
+ break;
+
+ case 'N':
+ modern = true;
+ limit_bytes_to_format = true;
+
+ s_err = xstrtoumax (optarg, NULL, 0, &max_bytes_to_format,
+ multipliers);
+ if (s_err != LONGINT_OK)
+ xstrtol_fatal (s_err, oi, c, long_options, optarg);
+ break;
+
+ case 'S':
+ modern = true;
+ if (optarg == NULL)
+ string_min = 3;
+ else
+ {
+ s_err = xstrtoumax (optarg, NULL, 0, &tmp, multipliers);
+ if (s_err != LONGINT_OK)
+ xstrtol_fatal (s_err, oi, c, long_options, optarg);
+
+ /* The minimum string length may be no larger than SIZE_MAX,
+ since we may allocate a buffer of this size. */
+ if (SIZE_MAX < tmp)
+ error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
+
+ string_min = tmp;
+ }
+ flag_dump_strings = true;
+ break;
+
+ case 't':
+ modern = true;
+ ok &= decode_format_string (optarg);
+ break;
+
+ case 'v':
+ modern = true;
+ abbreviate_duplicate_blocks = false;
+ break;
+
+ case TRADITIONAL_OPTION:
+ traditional = true;
+ break;
+
+ /* The next several cases map the traditional format
+ specification options to the corresponding modern format
+ specs. GNU od accepts any combination of old- and
+ new-style options. Format specification options accumulate.
+ The obsolescent and undocumented formats are compatible
+ with FreeBSD 4.10 od. */
#define CASE_OLD_ARG(old_char,new_string) \
- case old_char: \
- ok &= decode_format_string (new_string); \
- break
-
- CASE_OLD_ARG ('a', "a");
- CASE_OLD_ARG ('b', "o1");
- CASE_OLD_ARG ('c', "c");
- CASE_OLD_ARG ('D', "u4"); /* obsolescent and undocumented */
- CASE_OLD_ARG ('d', "u2");
- case 'F': /* obsolescent and undocumented alias */
- CASE_OLD_ARG ('e', "fD"); /* obsolescent and undocumented */
- CASE_OLD_ARG ('f', "fF");
- case 'X': /* obsolescent and undocumented alias */
- CASE_OLD_ARG ('H', "x4"); /* obsolescent and undocumented */
- CASE_OLD_ARG ('i', "dI");
- case 'I': case 'L': /* obsolescent and undocumented aliases */
- CASE_OLD_ARG ('l', "dL");
- CASE_OLD_ARG ('O', "o4"); /* obsolesent and undocumented */
- case 'B': /* obsolescent and undocumented alias */
- CASE_OLD_ARG ('o', "o2");
- CASE_OLD_ARG ('s', "d2");
- case 'h': /* obsolescent and undocumented alias */
- CASE_OLD_ARG ('x', "x2");
+ case old_char: \
+ ok &= decode_format_string (new_string); \
+ break
+
+ CASE_OLD_ARG ('a', "a");
+ CASE_OLD_ARG ('b', "o1");
+ CASE_OLD_ARG ('c', "c");
+ CASE_OLD_ARG ('D', "u4"); /* obsolescent and undocumented */
+ CASE_OLD_ARG ('d', "u2");
+ case 'F': /* obsolescent and undocumented alias */
+ CASE_OLD_ARG ('e', "fD"); /* obsolescent and undocumented */
+ CASE_OLD_ARG ('f', "fF");
+ case 'X': /* obsolescent and undocumented alias */
+ CASE_OLD_ARG ('H', "x4"); /* obsolescent and undocumented */
+ CASE_OLD_ARG ('i', "dI");
+ case 'I': case 'L': /* obsolescent and undocumented aliases */
+ CASE_OLD_ARG ('l', "dL");
+ CASE_OLD_ARG ('O', "o4"); /* obsolesent and undocumented */
+ case 'B': /* obsolescent and undocumented alias */
+ CASE_OLD_ARG ('o', "o2");
+ CASE_OLD_ARG ('s', "d2");
+ case 'h': /* obsolescent and undocumented alias */
+ CASE_OLD_ARG ('x', "x2");
#undef CASE_OLD_ARG
- case 'w':
- modern = true;
- width_specified = true;
- if (optarg == NULL)
- {
- desired_width = 32;
- }
- else
- {
- uintmax_t w_tmp;
- s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
- if (s_err != LONGINT_OK)
- xstrtol_fatal (s_err, oi, c, long_options, optarg);
- if (SIZE_MAX < w_tmp)
- error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
- desired_width = w_tmp;
- }
- break;
-
- case_GETOPT_HELP_CHAR;
-
- case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
-
- default:
- usage (EXIT_FAILURE);
- break;
- }
+ case 'w':
+ modern = true;
+ width_specified = true;
+ if (optarg == NULL)
+ {
+ desired_width = 32;
+ }
+ else
+ {
+ uintmax_t w_tmp;
+ s_err = xstrtoumax (optarg, NULL, 10, &w_tmp, "");
+ if (s_err != LONGINT_OK)
+ xstrtol_fatal (s_err, oi, c, long_options, optarg);
+ if (SIZE_MAX < w_tmp)
+ error (EXIT_FAILURE, 0, _("%s is too large"), optarg);
+ desired_width = w_tmp;
+ }
+ break;
+
+ case_GETOPT_HELP_CHAR;
+
+ case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
+
+ default:
+ usage (EXIT_FAILURE);
+ break;
+ }
}
if (!ok)
if (flag_dump_strings && n_specs > 0)
error (EXIT_FAILURE, 0,
- _("no type may be specified when dumping strings"));
+ _("no type may be specified when dumping strings"));
n_files = argc - optind;
/* If the --traditional option is used, there may be from
0 to 3 remaining command line arguments; handle each case
separately.
- od [file] [[+]offset[.][b] [[+]label[.][b]]]
+ od [file] [[+]offset[.][b] [[+]label[.][b]]]
The offset and label have the same syntax.
If --traditional is not given, and if no modern options are
given, and if the offset begins with + or (if there are two
operands) a digit, accept only this form, as per POSIX:
- od [file] [[+]offset[.][b]]
+ od [file] [[+]offset[.][b]]
*/
- if (!modern | traditional)
+ if (!modern || traditional)
{
uintmax_t o1;
uintmax_t o2;
switch (n_files)
- {
- case 1:
- if ((traditional || argv[optind][0] == '+')
- && parse_old_offset (argv[optind], &o1))
- {
- n_bytes_to_skip = o1;
- --n_files;
- ++argv;
- }
- break;
-
- case 2:
- if ((traditional || argv[optind + 1][0] == '+'
- || ISDIGIT (argv[optind + 1][0]))
- && parse_old_offset (argv[optind + 1], &o2))
- {
- if (traditional && parse_old_offset (argv[optind], &o1))
- {
- n_bytes_to_skip = o1;
- flag_pseudo_start = true;
- pseudo_start = o2;
- argv += 2;
- n_files -= 2;
- }
- else
- {
- n_bytes_to_skip = o2;
- --n_files;
- argv[optind + 1] = argv[optind];
- ++argv;
- }
- }
- break;
-
- case 3:
- if (traditional
- && parse_old_offset (argv[optind + 1], &o1)
- && parse_old_offset (argv[optind + 2], &o2))
- {
- n_bytes_to_skip = o1;
- flag_pseudo_start = true;
- pseudo_start = o2;
- argv[optind + 2] = argv[optind];
- argv += 2;
- n_files -= 2;
- }
- break;
- }
+ {
+ case 1:
+ if ((traditional || argv[optind][0] == '+')
+ && parse_old_offset (argv[optind], &o1))
+ {
+ n_bytes_to_skip = o1;
+ --n_files;
+ ++argv;
+ }
+ break;
+
+ case 2:
+ if ((traditional || argv[optind + 1][0] == '+'
+ || ISDIGIT (argv[optind + 1][0]))
+ && parse_old_offset (argv[optind + 1], &o2))
+ {
+ if (traditional && parse_old_offset (argv[optind], &o1))
+ {
+ n_bytes_to_skip = o1;
+ flag_pseudo_start = true;
+ pseudo_start = o2;
+ argv += 2;
+ n_files -= 2;
+ }
+ else
+ {
+ n_bytes_to_skip = o2;
+ --n_files;
+ argv[optind + 1] = argv[optind];
+ ++argv;
+ }
+ }
+ break;
+
+ case 3:
+ if (traditional
+ && parse_old_offset (argv[optind + 1], &o1)
+ && parse_old_offset (argv[optind + 2], &o2))
+ {
+ n_bytes_to_skip = o1;
+ flag_pseudo_start = true;
+ pseudo_start = o2;
+ argv[optind + 2] = argv[optind];
+ argv += 2;
+ n_files -= 2;
+ }
+ break;
+ }
if (traditional && 1 < n_files)
- {
- error (0, 0, _("extra operand %s"), quote (argv[optind + 1]));
- error (0, 0, "%s\n",
- _("compatibility mode supports at most one file"));
- usage (EXIT_FAILURE);
- }
+ {
+ error (0, 0, _("extra operand %s"), quote (argv[optind + 1]));
+ error (0, 0, "%s",
+ _("compatibility mode supports at most one file"));
+ usage (EXIT_FAILURE);
+ }
}
if (flag_pseudo_start)
{
if (format_address == format_address_none)
- {
- address_base = 8;
- address_pad_len = 7;
- format_address = format_address_paren;
- }
+ {
+ address_base = 8;
+ address_pad_len = 7;
+ format_address = format_address_paren;
+ }
else
- format_address = format_address_label;
+ format_address = format_address_label;
}
if (limit_bytes_to_format)
{
end_offset = n_bytes_to_skip + max_bytes_to_format;
if (end_offset < n_bytes_to_skip)
- error (EXIT_FAILURE, 0, _("skip-bytes + read-bytes is too large"));
+ error (EXIT_FAILURE, 0, _("skip-bytes + read-bytes is too large"));
}
if (n_specs == 0)
if (n_files > 0)
{
/* Set the global pointer FILE_LIST so that it
- references the first file-argument on the command-line. */
+ references the first file-argument on the command-line. */
file_list = (char const *const *) &argv[optind];
}
else
{
/* 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: "-". */
+ Set the global pointer FILE_LIST so that it
+ references the null-terminated list of one name: "-". */
file_list = default_file_list;
}
if (width_specified)
{
if (desired_width != 0 && desired_width % l_c_m == 0)
- bytes_per_block = desired_width;
+ bytes_per_block = desired_width;
else
- {
- error (0, 0, _("warning: invalid width %lu; using %d instead"),
- (unsigned long int) desired_width, l_c_m);
- bytes_per_block = l_c_m;
- }
+ {
+ error (0, 0, _("warning: invalid width %lu; using %d instead"),
+ (unsigned long int) desired_width, l_c_m);
+ bytes_per_block = l_c_m;
+ }
}
else
{
if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
- bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
+ bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
else
- bytes_per_block = l_c_m;
+ bytes_per_block = l_c_m;
}
/* Compute padding necessary to align output block. */
int fields_per_block = bytes_per_block / width_bytes[spec[i].size];
int block_width = (spec[i].field_width + 1) * fields_per_block;
if (width_per_block < block_width)
- width_per_block = block_width;
+ width_per_block = block_width;
}
for (i = 0; i < n_specs; i++)
{
}
#ifdef DEBUG
- printf (_("lcm=%d, width_per_block=%zu\n"), l_c_m, width_per_block);
+ printf ("lcm=%d, width_per_block=%zu\n", l_c_m, width_per_block);
for (i = 0; i < n_specs; i++)
{
int fields_per_block = bytes_per_block / width_bytes[spec[i].size];
assert (bytes_per_block % width_bytes[spec[i].size] == 0);
assert (1 <= spec[i].pad_width / fields_per_block);
- printf (_("%d: fmt=\"%s\" in_width=%d out_width=%d pad=%d\n"),
- i, spec[i].fmt_string, width_bytes[spec[i].size],
- spec[i].field_width, spec[i].pad_width);
+ printf ("%d: fmt=\"%s\" in_width=%d out_width=%d pad=%d\n",
+ i, spec[i].fmt_string, width_bytes[spec[i].size],
+ spec[i].field_width, spec[i].pad_width);
}
#endif
ok &= (flag_dump_strings ? dump_strings () : dump ());
-cleanup:;
+cleanup:
if (have_read_stdin && fclose (stdin) == EOF)
error (EXIT_FAILURE, errno, _("standard input"));
projects / platform / upstream / coreutils.git / blobdiff