diff options
Diffstat (limited to 'src/seq.c')
| -rw-r--r-- | src/seq.c | 551 |
1 files changed, 425 insertions, 126 deletions
@@ -1,10 +1,10 @@ /* seq - print sequence of numbers to standard output. - Copyright (C) 1994-2006 Free Software Foundation, Inc. + Copyright (C) 1994-2016 Free Software Foundation, Inc. - This program is free software; you can redistribute it and/or modify + 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 - the Free Software Foundation; either version 2, or (at your option) - any later version. + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -12,8 +12,7 @@ GNU General Public License for more details. You should have received a copy of the GNU General Public License - along with this program; if not, write to the Free Software Foundation, - Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ + along with this program. If not, see <http://www.gnu.org/licenses/>. */ /* Written by Ulrich Drepper. */ @@ -34,23 +33,19 @@ # define isfinite(x) ((x) * 0 == 0) #endif -/* 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 "seq" -#define AUTHORS "Ulrich Drepper" +#define AUTHORS proper_name ("Ulrich Drepper") /* If true print all number with equal width. */ static bool equal_width; -/* The name that this program was run with. */ -char *program_name; - /* The string used to separate two numbers. */ static char const *separator; /* The string output after all numbers have been output. Usually "\n" or "\0". */ -/* FIXME: make this an option. */ static char const terminator[] = "\n"; static struct option const long_options[] = @@ -67,8 +62,7 @@ void usage (int status) { if (status != EXIT_SUCCESS) - fprintf (stderr, _("Try `%s --help' for more information.\n"), - program_name); + emit_try_help (); else { printf (_("\ @@ -78,7 +72,11 @@ Usage: %s [OPTION]... LAST\n\ "), program_name, program_name, program_name); fputs (_("\ Print numbers from FIRST to LAST, in steps of INCREMENT.\n\ -\n\ +"), stdout); + + emit_mandatory_arg_note (); + + fputs (_("\ -f, --format=FORMAT use printf style floating-point FORMAT\n\ -s, --separator=STRING use STRING to separate numbers (default: \\n)\n\ -w, --equal-width equalize width by padding with leading zeroes\n\ @@ -89,16 +87,18 @@ Print numbers from FIRST to LAST, in steps of INCREMENT.\n\ \n\ If FIRST or INCREMENT is omitted, it defaults to 1. That is, an\n\ omitted INCREMENT defaults to 1 even when LAST is smaller than FIRST.\n\ +The sequence of numbers ends when the sum of the current number and\n\ +INCREMENT would become greater than LAST.\n\ FIRST, INCREMENT, and LAST are interpreted as floating point values.\n\ INCREMENT is usually positive if FIRST is smaller than LAST, and\n\ INCREMENT is usually negative if FIRST is greater than LAST.\n\ "), stdout); fputs (_("\ -FORMAT must be suitable for printing one argument of type `double';\n\ +FORMAT must be suitable for printing one argument of type 'double';\n\ it defaults to %.PRECf if FIRST, INCREMENT, and LAST are all fixed point\n\ decimal numbers with maximum precision PREC, and to %g otherwise.\n\ "), stdout); - printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT); + emit_ancillary_info (PROGRAM_NAME); } exit (status); } @@ -121,6 +121,14 @@ struct operand }; typedef struct operand operand; +/* Description of what a number-generating format will generate. */ +struct layout +{ + /* Number of bytes before and after the number. */ + size_t prefix_len; + size_t suffix_len; +}; + /* Read a long double value from the command line. Return if the string is correct else signal error. */ @@ -131,47 +139,95 @@ scan_arg (const char *arg) if (! xstrtold (arg, NULL, &ret.value, c_strtold)) { - error (0, 0, _("invalid floating point argument: %s"), arg); + error (0, 0, _("invalid floating point argument: %s"), quote (arg)); usage (EXIT_FAILURE); } - ret.width = strlen (arg); + /* We don't output spaces or '+' so don't include in width */ + while (isspace (to_uchar (*arg)) || *arg == '+') + arg++; + + /* Default to auto width and precision. */ + ret.width = 0; ret.precision = INT_MAX; - if (! arg[strcspn (arg, "eExX")] && isfinite (ret.value)) + /* Use no precision (and possibly fast generation) for integers. */ + char const *decimal_point = strchr (arg, '.'); + if (! decimal_point && ! strchr (arg, 'p') /* not a hex float */) + ret.precision = 0; + + /* auto set width and precision for decimal inputs. */ + if (! arg[strcspn (arg, "xX")] && isfinite (ret.value)) { - char const *decimal_point = strchr (arg, '.'); - if (! decimal_point) - ret.precision = 0; - else - { - size_t fraction_len = strlen (decimal_point + 1); - if (fraction_len <= INT_MAX) - ret.precision = fraction_len; - ret.width += (fraction_len == 0 - ? -1 - : (decimal_point == arg - || ! ISDIGIT (decimal_point[-1]))); - } + size_t fraction_len = 0; + ret.width = strlen (arg); + + if (decimal_point) + { + fraction_len = strcspn (decimal_point + 1, "eE"); + if (fraction_len <= INT_MAX) + ret.precision = fraction_len; + ret.width += (fraction_len == 0 /* #. -> # */ + ? -1 + : (decimal_point == arg /* .# -> 0.# */ + || ! ISDIGIT (decimal_point[-1]))); /* -.# -> 0.# */ + } + char const *e = strchr (arg, 'e'); + if (! e) + e = strchr (arg, 'E'); + if (e) + { + long exponent = strtol (e + 1, NULL, 10); + ret.precision += exponent < 0 ? -exponent + : - MIN (ret.precision, exponent); + /* Don't account for e.... in the width since this is not output. */ + ret.width -= strlen (arg) - (e - arg); + /* Adjust the width as per the exponent. */ + if (exponent < 0) + { + if (decimal_point) + { + if (e == decimal_point + 1) /* undo #. -> # above */ + ret.width++; + } + else + ret.width++; + exponent = -exponent; + } + else + { + if (decimal_point && ret.precision == 0 && fraction_len) + ret.width--; /* discount space for '.' */ + exponent -= MIN (fraction_len, exponent); + } + ret.width += exponent; + } } return ret; } /* If FORMAT is a valid printf format for a double argument, return - its long double equivalent, possibly allocated from dynamic - storage; otherwise, return NULL. */ + its long double equivalent, allocated from dynamic storage, and + store into *LAYOUT a description of the output layout; otherwise, + report an error and exit. */ static char const * -long_double_format (char const *fmt) +long_double_format (char const *fmt, struct layout *layout) { size_t i; - size_t prefix_len; + size_t prefix_len = 0; + size_t suffix_len = 0; + size_t length_modifier_offset; bool has_L; - for (i = 0; ! (fmt[i] == '%' && fmt[i + 1] != '%'); i++) - if (! fmt[i]) - return NULL; + for (i = 0; ! (fmt[i] == '%' && fmt[i + 1] != '%'); i += (fmt[i] == '%') + 1) + { + if (!fmt[i]) + error (EXIT_FAILURE, 0, + _("format %s has no %% directive"), quote (fmt)); + prefix_len++; + } i++; i += strspn (fmt + i, "-+#0 '"); @@ -182,47 +238,98 @@ long_double_format (char const *fmt) i += strspn (fmt + i, "0123456789"); } - prefix_len = i; + length_modifier_offset = i; has_L = (fmt[i] == 'L'); i += has_L; + if (fmt[i] == '\0') + error (EXIT_FAILURE, 0, _("format %s ends in %%"), quote (fmt)); if (! strchr ("efgaEFGA", fmt[i])) - return NULL; - - for (i++; ! (fmt[i] == '%' && fmt[i + 1] != '%'); i++) - if (! fmt[i]) + error (EXIT_FAILURE, 0, + _("format %s has unknown %%%c directive"), quote (fmt), fmt[i]); + + for (i++; ; i += (fmt[i] == '%') + 1) + if (fmt[i] == '%' && fmt[i + 1] != '%') + error (EXIT_FAILURE, 0, _("format %s has too many %% directives"), + quote (fmt)); + else if (fmt[i]) + suffix_len++; + else { - size_t format_size = i + 1; - char *ldfmt = xmalloc (format_size + 1); - memcpy (ldfmt, fmt, prefix_len); - ldfmt[prefix_len] = 'L'; - strcpy (ldfmt + prefix_len + 1, fmt + prefix_len + has_L); - return ldfmt; + size_t format_size = i + 1; + char *ldfmt = xmalloc (format_size + 1); + memcpy (ldfmt, fmt, length_modifier_offset); + ldfmt[length_modifier_offset] = 'L'; + strcpy (ldfmt + length_modifier_offset + 1, + fmt + length_modifier_offset + has_L); + layout->prefix_len = prefix_len; + layout->suffix_len = suffix_len; + return ldfmt; } - - return NULL; } /* Actually print the sequence of numbers in the specified range, with the given or default stepping and format. */ static void -print_numbers (char const *fmt, - long double first, long double step, long double last) +print_numbers (char const *fmt, struct layout layout, + long double first, long double step, long double last) { - long double i; + bool out_of_range = (step < 0 ? first < last : last < first); - for (i = 0; /* empty */; i++) + if (! out_of_range) { - long double x = first + i * step; - if (step < 0 ? x < last : last < x) - break; - if (i) - fputs (separator, stdout); - printf (fmt, x); + long double x = first; + long double i; + + for (i = 1; ; i++) + { + long double x0 = x; + printf (fmt, x); + if (out_of_range) + break; + x = first + i * step; + out_of_range = (step < 0 ? x < last : last < x); + + if (out_of_range) + { + /* If the number just past LAST prints as a value equal + to LAST, and prints differently from the previous + number, then print the number. This avoids problems + with rounding. For example, with the x86 it causes + "seq 0 0.000001 0.000003" to print 0.000003 instead + of stopping at 0.000002. */ + + bool print_extra_number = false; + long double x_val; + char *x_str; + int x_strlen; + setlocale (LC_NUMERIC, "C"); + x_strlen = asprintf (&x_str, fmt, x); + setlocale (LC_NUMERIC, ""); + if (x_strlen < 0) + xalloc_die (); + x_str[x_strlen - layout.suffix_len] = '\0'; + + if (xstrtold (x_str + layout.prefix_len, NULL, &x_val, c_strtold) + && x_val == last) + { + char *x0_str = NULL; + if (asprintf (&x0_str, fmt, x0) < 0) + xalloc_die (); + print_extra_number = !STREQ (x0_str, x_str); + free (x0_str); + } + + free (x_str); + if (! print_extra_number) + break; + } + + fputs (separator, stdout); + } + + fputs (terminator, stdout); } - - if (i) - fputs (terminator, stdout); } /* Return the default format given FIRST, STEP, and LAST. */ @@ -236,31 +343,183 @@ get_default_format (operand first, operand step, operand last) if (prec != INT_MAX && last.precision != INT_MAX) { if (equal_width) - { - size_t first_width = first.width + (prec - first.precision); - size_t last_width = last.width + (prec - last.precision); - if (first.width <= first_width - && (last.width < last_width) == (prec < last.precision)) - { - size_t width = MAX (first_width, last_width); - if (width <= INT_MAX) - { - int w = width; - sprintf (format_buf, "%%0%d.%dLf", w, prec); - return format_buf; - } - } - } + { + /* increase first_width by any increased precision in step */ + size_t first_width = first.width + (prec - first.precision); + /* adjust last_width to use precision from first/step */ + size_t last_width = last.width + (prec - last.precision); + if (last.precision && prec == 0) + last_width--; /* don't include space for '.' */ + if (last.precision == 0 && prec) + last_width++; /* include space for '.' */ + if (first.precision == 0 && prec) + first_width++; /* include space for '.' */ + size_t width = MAX (first_width, last_width); + if (width <= INT_MAX) + { + int w = width; + sprintf (format_buf, "%%0%d.%dLf", w, prec); + return format_buf; + } + } else - { - sprintf (format_buf, "%%.%dLf", prec); - return format_buf; - } + { + sprintf (format_buf, "%%.%dLf", prec); + return format_buf; + } } return "%Lg"; } +/* The NUL-terminated string S0 of length S_LEN represents a valid + non-negative decimal integer. Adjust the string and length so + that the pair describe the next-larger value. */ +static void +incr (char **s0, size_t *s_len) +{ + char *s = *s0; + char *endp = s + *s_len - 1; + + do + { + if ((*endp)++ < '9') + return; + *endp-- = '0'; + } + while (endp >= s); + *--(*s0) = '1'; + ++*s_len; +} + +/* Compare A and B (each a NUL-terminated digit string), with lengths + given by A_LEN and B_LEN. Return +1 if A < B, -1 if B < A, else 0. */ +static int +cmp (char const *a, size_t a_len, char const *b, size_t b_len) +{ + if (a_len < b_len) + return -1; + if (b_len < a_len) + return 1; + return (strcmp (a, b)); +} + +/* Trim leading 0's from S, but if S is all 0's, leave one. + Return a pointer to the trimmed string. */ +static char const * _GL_ATTRIBUTE_PURE +trim_leading_zeros (char const *s) +{ + char const *p = s; + while (*s == '0') + ++s; + + /* If there were only 0's, back up, to leave one. */ + if (!*s && s != p) + --s; + return s; +} + +/* Print all whole numbers from A to B, inclusive -- to stdout, each + followed by a newline. If B < A, return false and print nothing. + Otherwise, return true. */ +static bool +seq_fast (char const *a, char const *b) +{ + bool inf = STREQ (b, "inf"); + + /* Skip past any leading 0's. Without this, our naive cmp + function would declare 000 to be larger than 99. */ + a = trim_leading_zeros (a); + b = trim_leading_zeros (b); + + size_t p_len = strlen (a); + size_t q_len = inf ? 0 : strlen (b); + + /* Allow for at least 31 digits without realloc. + 1 more than p_len is needed for the inf case. */ + size_t inc_size = MAX (MAX (p_len + 1, q_len), 31); + + /* Copy input strings (incl NUL) to end of new buffers. */ + char *p0 = xmalloc (inc_size + 1); + char *p = memcpy (p0 + inc_size - p_len, a, p_len + 1); + char *q; + char *q0; + if (! inf) + { + q0 = xmalloc (inc_size + 1); + q = memcpy (q0 + inc_size - q_len, b, q_len + 1); + } + else + q = q0 = NULL; + + bool ok = inf || cmp (p, p_len, q, q_len) <= 0; + if (ok) + { + /* Reduce number of fwrite calls which is seen to + give a speed-up of more than 2x over the unbuffered code + when printing the first 10^9 integers. */ + size_t buf_size = MAX (BUFSIZ, (inc_size + 1) * 2); + char *buf = xmalloc (buf_size); + char const *buf_end = buf + buf_size; + + char *bufp = buf; + + /* Write first number to buffer. */ + bufp = mempcpy (bufp, p, p_len); + + /* Append separator then number. */ + while (inf || cmp (p, p_len, q, q_len) < 0) + { + *bufp++ = *separator; + incr (&p, &p_len); + + /* Double up the buffers when needed for the inf case. */ + if (p_len == inc_size) + { + inc_size *= 2; + p0 = xrealloc (p0, inc_size + 1); + p = memmove (p0 + p_len, p0, p_len + 1); + + if (buf_size < (inc_size + 1) * 2) + { + size_t buf_offset = bufp - buf; + buf_size = (inc_size + 1) * 2; + buf = xrealloc (buf, buf_size); + buf_end = buf + buf_size; + bufp = buf + buf_offset; + } + } + + bufp = mempcpy (bufp, p, p_len); + /* If no place for another separator + number then + output buffer so far, and reset to start of buffer. */ + if (buf_end - (p_len + 1) < bufp) + { + fwrite (buf, bufp - buf, 1, stdout); + bufp = buf; + } + } + + /* Write any remaining buffered output, and the terminator. */ + *bufp++ = *terminator; + fwrite (buf, bufp - buf, 1, stdout); + + IF_LINT (free (buf)); + } + + free (p0); + free (q0); + return ok; +} + +/* Return true if S consists of at least one digit and no non-digits. */ +static bool _GL_ATTRIBUTE_PURE +all_digits_p (char const *s) +{ + size_t n = strlen (s); + return ISDIGIT (s[0]) && n == strspn (s, "0123456789"); +} + int main (int argc, char **argv) { @@ -268,12 +527,13 @@ main (int argc, char **argv) operand first = { 1, 1, 0 }; operand step = { 1, 1, 0 }; operand last; + struct layout layout = { 0, 0 }; /* The printf(3) format used for output. */ char const *format_str = NULL; initialize_main (&argc, &argv); - program_name = argv[0]; + set_program_name (argv[0]); setlocale (LC_ALL, ""); bindtextdomain (PACKAGE, LOCALEDIR); textdomain (PACKAGE); @@ -289,60 +549,80 @@ main (int argc, char **argv) while (optind < argc) { if (argv[optind][0] == '-' - && ((optc = argv[optind][1]) == '.' || ISDIGIT (optc))) - { - /* means negative number */ - break; - } + && ((optc = argv[optind][1]) == '.' || ISDIGIT (optc))) + { + /* means negative number */ + break; + } optc = getopt_long (argc, argv, "+f:s:w", long_options, NULL); if (optc == -1) - break; + break; switch (optc) - { - case 'f': - format_str = optarg; - break; + { + case 'f': + format_str = optarg; + break; - case 's': - separator = optarg; - break; + case 's': + separator = optarg; + break; - case 'w': - equal_width = true; - break; + case 'w': + equal_width = true; + break; - case_GETOPT_HELP_CHAR; + case_GETOPT_HELP_CHAR; - case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS); + case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS); - default: - usage (EXIT_FAILURE); - } + default: + usage (EXIT_FAILURE); + } } - if (argc - optind < 1) + unsigned int n_args = argc - optind; + if (n_args < 1) { error (0, 0, _("missing operand")); usage (EXIT_FAILURE); } - if (3 < argc - optind) + if (3 < n_args) { error (0, 0, _("extra operand %s"), quote (argv[optind + 3])); usage (EXIT_FAILURE); } if (format_str) + format_str = long_double_format (format_str, &layout); + + if (format_str != NULL && equal_width) { - char const *f = long_double_format (format_str); - if (! f) - { - error (0, 0, _("invalid format string: %s"), quote (format_str)); - usage (EXIT_FAILURE); - } - format_str = f; + error (0, 0, _("format string may not be specified" + " when printing equal width strings")); + usage (EXIT_FAILURE); + } + + /* If the following hold: + - no format string, [FIXME: relax this, eventually] + - integer start (or no start) + - integer end + - increment == 1 or not specified [FIXME: relax this, eventually] + then use the much more efficient integer-only code. */ + if (all_digits_p (argv[optind]) + && (n_args == 1 || all_digits_p (argv[optind + 1])) + && (n_args < 3 || (STREQ ("1", argv[optind + 1]) + && all_digits_p (argv[optind + 2]))) + && !equal_width && !format_str && strlen (separator) == 1) + { + char const *s1 = n_args == 1 ? "1" : argv[optind]; + char const *s2 = argv[optind + (n_args - 1)]; + if (seq_fast (s1, s2)) + return EXIT_SUCCESS; + + /* Upon any failure, let the more general code deal with it. */ } last = scan_arg (argv[optind++]); @@ -353,23 +633,42 @@ main (int argc, char **argv) last = scan_arg (argv[optind++]); if (optind < argc) - { - step = last; - last = scan_arg (argv[optind++]); - } + { + step = last; + last = scan_arg (argv[optind++]); + } } - if (format_str != NULL && equal_width) + if ((isfinite (first.value) && first.precision == 0) + && step.precision == 0 && last.precision == 0 + && 0 <= first.value && step.value == 1 && 0 <= last.value + && !equal_width && !format_str && strlen (separator) == 1) { - error (0, 0, _("\ -format string may not be specified when printing equal width strings")); - usage (EXIT_FAILURE); + char *s1; + char *s2; + if (asprintf (&s1, "%0.Lf", first.value) < 0) + xalloc_die (); + if (! isfinite (last.value)) + s2 = xstrdup ("inf"); /* Ensure "inf" is used. */ + else if (asprintf (&s2, "%0.Lf", last.value) < 0) + xalloc_die (); + + if (*s1 != '-' && *s2 != '-' && seq_fast (s1, s2)) + { + IF_LINT (free (s1)); + IF_LINT (free (s2)); + return EXIT_SUCCESS; + } + + free (s1); + free (s2); + /* Upon any failure, let the more general code deal with it. */ } if (format_str == NULL) format_str = get_default_format (first, step, last); - print_numbers (format_str, first.value, step.value, last.value); + print_numbers (format_str, layout, first.value, step.value, last.value); - exit (EXIT_SUCCESS); + return EXIT_SUCCESS; } |