src/seq.c

   1 /* seq - print sequence of numbers to standard output.
   2    Copyright (C) 1994-2023 Free Software Foundation, Inc.
   3
   4    This program is free software: you can redistribute it and/or modify
   5    it under the terms of the GNU General Public License as published by
   6    the Free Software Foundation, either version 3 of the License, or
   7    (at your option) any later version.
   8
   9    This program is distributed in the hope that it will be useful,
  10    but WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Ulrich Drepper.  */
  18
  19 #include <config.h>
  20 #include <ctype.h>
  21 #include <getopt.h>
  22 #include <stdio.h>
  23 #include <sys/types.h>
  24
  25 #include "system.h"
  26 #include "cl-strtod.h"
  27 #include "quote.h"
  28 #include "xstrtod.h"
  29
  30 /* Roll our own isfinite/isnan rather than using <math.h>, so that we don't
  31    have to worry about linking -lm just for isfinite.  */
  32 #ifndef isfinite
  33 # define isfinite(x) ((x) * 0 == 0)
  34 #endif
  35 #ifndef isnan
  36 # define isnan(x) ((x) != (x))
  37 #endif
  38
  39 /* Limit below which seq_fast has more throughput.
  40    Determined with: seq 0 200 inf | pv > /dev/null  */
  41 #define SEQ_FAST_STEP_LIMIT 200  /* Keep in sync with texinfo description.  */
  42 #define SEQ_FAST_STEP_LIMIT_DIGITS 3
  43
  44 /* The official name of this program (e.g., no 'g' prefix).  */
  45 #define PROGRAM_NAME "seq"
  46
  47 #define AUTHORS proper_name ("Ulrich Drepper")
  48
  49 /* True if the locale settings were honored.  */
  50 static bool locale_ok;
  51
  52 /* If true print all number with equal width.  */
  53 static bool equal_width;
  54
  55 /* The string used to separate two numbers.  */
  56 static char const *separator;
  57
  58 /* The string output after all numbers have been output.
  59    Usually "\n" or "\0".  */
  60 static char const terminator[] = "\n";
  61
  62 static struct option const long_options[] =
  63 {
  64   { "equal-width", no_argument, nullptr, 'w'},
  65   { "format", required_argument, nullptr, 'f'},
  66   { "separator", required_argument, nullptr, 's'},
  67   {GETOPT_HELP_OPTION_DECL},
  68   {GETOPT_VERSION_OPTION_DECL},
  69   { nullptr, 0, nullptr, 0}
  70 };
  71
  72 void
  73 usage (int status)
  74 {
  75   if (status != EXIT_SUCCESS)
  76     emit_try_help ();
  77   else
  78     {
  79       printf (_("\
  80 Usage: %s [OPTION]... LAST\n\
  81   or:  %s [OPTION]... FIRST LAST\n\
  82   or:  %s [OPTION]... FIRST INCREMENT LAST\n\
  83 "), program_name, program_name, program_name);
  84       fputs (_("\
  85 Print numbers from FIRST to LAST, in steps of INCREMENT.\n\
  86 "), stdout);
  87
  88       emit_mandatory_arg_note ();
  89
  90       fputs (_("\
  91   -f, --format=FORMAT      use printf style floating-point FORMAT\n\
  92   -s, --separator=STRING   use STRING to separate numbers (default: \\n)\n\
  93   -w, --equal-width        equalize width by padding with leading zeroes\n\
  94 "), stdout);
  95       fputs (HELP_OPTION_DESCRIPTION, stdout);
  96       fputs (VERSION_OPTION_DESCRIPTION, stdout);
  97       fputs (_("\
  98 \n\
  99 If FIRST or INCREMENT is omitted, it defaults to 1.  That is, an\n\
 100 omitted INCREMENT defaults to 1 even when LAST is smaller than FIRST.\n\
 101 The sequence of numbers ends when the sum of the current number and\n\
 102 INCREMENT would become greater than LAST.\n\
 103 FIRST, INCREMENT, and LAST are interpreted as floating point values.\n\
 104 INCREMENT is usually positive if FIRST is smaller than LAST, and\n\
 105 INCREMENT is usually negative if FIRST is greater than LAST.\n\
 106 INCREMENT must not be 0; none of FIRST, INCREMENT and LAST may be NaN.\n\
 107 "), stdout);
 108       fputs (_("\
 109 FORMAT must be suitable for printing one argument of type 'double';\n\
 110 it defaults to %.PRECf if FIRST, INCREMENT, and LAST are all fixed point\n\
 111 decimal numbers with maximum precision PREC, and to %g otherwise.\n\
 112 "), stdout);
 113       emit_ancillary_info (PROGRAM_NAME);
 114     }
 115   exit (status);
 116 }
 117
 118 /* A command-line operand.  */
 119 struct operand
 120 {
 121   /* Its value, converted to 'long double'.  */
 122   long double value;
 123
 124   /* Its print width, if it were printed out in a form similar to its
 125      input form.  An input like "-.1" is treated like "-0.1", and an
 126      input like "1." is treated like "1", but otherwise widths are
 127      left alone.  */
 128   size_t width;
 129
 130   /* Number of digits after the decimal point, or INT_MAX if the
 131      number can't easily be expressed as a fixed-point number.  */
 132   int precision;
 133 };
 134 typedef struct operand operand;
 135
 136 /* Description of what a number-generating format will generate.  */
 137 struct layout
 138 {
 139   /* Number of bytes before and after the number.  */
 140   size_t prefix_len;
 141   size_t suffix_len;
 142 };
 143
 144 /* Read a long double value from the command line.
 145    Return if the string is correct else signal error.  */
 146
 147 static operand
 148 scan_arg (char const *arg)
 149 {
 150   operand ret;
 151
 152   if (! xstrtold (arg, nullptr, &ret.value, cl_strtold))
 153     {
 154       error (0, 0, _("invalid floating point argument: %s"), quote (arg));
 155       usage (EXIT_FAILURE);
 156     }
 157
 158   if (isnan (ret.value))
 159     {
 160       error (0, 0, _("invalid %s argument: %s"), quote_n (0, "not-a-number"),
 161              quote_n (1, arg));
 162       usage (EXIT_FAILURE);
 163     }
 164
 165   /* We don't output spaces or '+' so don't include in width */
 166   while (isspace (to_uchar (*arg)) || *arg == '+')
 167     arg++;
 168
 169   /* Default to auto width and precision.  */
 170   ret.width = 0;
 171   ret.precision = INT_MAX;
 172
 173   /* Use no precision (and possibly fast generation) for integers.  */
 174   char const *decimal_point = strchr (arg, '.');
 175   if (! decimal_point && ! strchr (arg, 'p') /* not a hex float */)
 176     ret.precision = 0;
 177
 178   /* auto set width and precision for decimal inputs.  */
 179   if (! arg[strcspn (arg, "xX")] && isfinite (ret.value))
 180     {
 181       size_t fraction_len = 0;
 182       ret.width = strlen (arg);
 183
 184       if (decimal_point)
 185         {
 186           fraction_len = strcspn (decimal_point + 1, "eE");
 187           if (fraction_len <= INT_MAX)
 188             ret.precision = fraction_len;
 189           ret.width += (fraction_len == 0                      /* #.  -> #   */
 190                         ? -1
 191                         : (decimal_point == arg                /* .#  -> 0.# */
 192                            || ! ISDIGIT (decimal_point[-1]))); /* -.# -> 0.# */
 193         }
 194       char const *e = strchr (arg, 'e');
 195       if (! e)
 196         e = strchr (arg, 'E');
 197       if (e)
 198         {
 199           long exponent = MAX (strtol (e + 1, nullptr, 10), -LONG_MAX);
 200           ret.precision += exponent < 0 ? -exponent
 201                                         : - MIN (ret.precision, exponent);
 202           /* Don't account for e.... in the width since this is not output.  */
 203           ret.width -= strlen (arg) - (e - arg);
 204           /* Adjust the width as per the exponent.  */
 205           if (exponent < 0)
 206             {
 207               if (decimal_point)
 208                 {
 209                   if (e == decimal_point + 1) /* undo #. -> # above  */
 210                     ret.width++;
 211                 }
 212               else
 213                 ret.width++;
 214               exponent = -exponent;
 215             }
 216           else
 217             {
 218               if (decimal_point && ret.precision == 0 && fraction_len)
 219                 ret.width--; /* discount space for '.'  */
 220               exponent -= MIN (fraction_len, exponent);
 221             }
 222           ret.width += exponent;
 223         }
 224     }
 225
 226   return ret;
 227 }
 228
 229 /* If FORMAT is a valid printf format for a double argument, return
 230    its long double equivalent, allocated from dynamic storage, and
 231    store into *LAYOUT a description of the output layout; otherwise,
 232    report an error and exit.  */
 233
 234 static char const *
 235 long_double_format (char const *fmt, struct layout *layout)
 236 {
 237   size_t i;
 238   size_t prefix_len = 0;
 239   size_t suffix_len = 0;
 240   size_t length_modifier_offset;
 241   bool has_L;
 242
 243   for (i = 0; ! (fmt[i] == '%' && fmt[i + 1] != '%'); i += (fmt[i] == '%') + 1)
 244     {
 245       if (!fmt[i])
 246         error (EXIT_FAILURE, 0,
 247                _("format %s has no %% directive"), quote (fmt));
 248       prefix_len++;
 249     }
 250
 251   i++;
 252   i += strspn (fmt + i, "-+#0 '");
 253   i += strspn (fmt + i, "0123456789");
 254   if (fmt[i] == '.')
 255     {
 256       i++;
 257       i += strspn (fmt + i, "0123456789");
 258     }
 259
 260   length_modifier_offset = i;
 261   has_L = (fmt[i] == 'L');
 262   i += has_L;
 263   if (fmt[i] == '\0')
 264     error (EXIT_FAILURE, 0, _("format %s ends in %%"), quote (fmt));
 265   if (! strchr ("efgaEFGA", fmt[i]))
 266     error (EXIT_FAILURE, 0,
 267            _("format %s has unknown %%%c directive"), quote (fmt), fmt[i]);
 268
 269   for (i++; ; i += (fmt[i] == '%') + 1)
 270     if (fmt[i] == '%' && fmt[i + 1] != '%')
 271       error (EXIT_FAILURE, 0, _("format %s has too many %% directives"),
 272              quote (fmt));
 273     else if (fmt[i])
 274       suffix_len++;
 275     else
 276       {
 277         size_t format_size = i + 1;
 278         char *ldfmt = xmalloc (format_size + 1);
 279         memcpy (ldfmt, fmt, length_modifier_offset);
 280         ldfmt[length_modifier_offset] = 'L';
 281         strcpy (ldfmt + length_modifier_offset + 1,
 282                 fmt + length_modifier_offset + has_L);
 283         layout->prefix_len = prefix_len;
 284         layout->suffix_len = suffix_len;
 285         return ldfmt;
 286       }
 287 }
 288
 289 /* Actually print the sequence of numbers in the specified range, with the
 290    given or default stepping and format.  */
 291
 292 static void
 293 print_numbers (char const *fmt, struct layout layout,
 294                long double first, long double step, long double last)
 295 {
 296   bool out_of_range = (step < 0 ? first < last : last < first);
 297
 298   if (! out_of_range)
 299     {
 300       long double x = first;
 301       long double i;
 302
 303       for (i = 1; ; i++)
 304         {
 305           long double x0 = x;
 306           if (printf (fmt, x) < 0)
 307             write_error ();
 308           if (out_of_range)
 309             break;
 310           x = first + i * step;
 311           out_of_range = (step < 0 ? x < last : last < x);
 312
 313           if (out_of_range)
 314             {
 315               /* If the number just past LAST prints as a value equal
 316                  to LAST, and prints differently from the previous
 317                  number, then print the number.  This avoids problems
 318                  with rounding.  For example, with the x86 it causes
 319                  "seq 0 0.000001 0.000003" to print 0.000003 instead
 320                  of stopping at 0.000002.  */
 321
 322               bool print_extra_number = false;
 323               long double x_val;
 324               char *x_str;
 325               int x_strlen;
 326               if (locale_ok)
 327                 setlocale (LC_NUMERIC, "C");
 328               x_strlen = asprintf (&x_str, fmt, x);
 329               if (locale_ok)
 330                 setlocale (LC_NUMERIC, "");
 331               if (x_strlen < 0)
 332                 xalloc_die ();
 333               x_str[x_strlen - layout.suffix_len] = '\0';
 334
 335               if (xstrtold (x_str + layout.prefix_len, nullptr,
 336                             &x_val, cl_strtold)
 337                   && x_val == last)
 338                 {
 339                   char *x0_str = nullptr;
 340                   int x0_strlen = asprintf (&x0_str, fmt, x0);
 341                   if (x0_strlen < 0)
 342                     xalloc_die ();
 343                   x0_str[x0_strlen - layout.suffix_len] = '\0';
 344                   print_extra_number = !STREQ (x0_str, x_str);
 345                   free (x0_str);
 346                 }
 347
 348               free (x_str);
 349               if (! print_extra_number)
 350                 break;
 351             }
 352
 353           if (fputs (separator, stdout) == EOF)
 354             write_error ();
 355         }
 356
 357       if (fputs (terminator, stdout) == EOF)
 358         write_error ();
 359     }
 360 }
 361
 362 /* Return the default format given FIRST, STEP, and LAST.  */
 363 static char const *
 364 get_default_format (operand first, operand step, operand last)
 365 {
 366   static char format_buf[sizeof "%0.Lf" + 2 * INT_STRLEN_BOUND (int)];
 367
 368   int prec = MAX (first.precision, step.precision);
 369
 370   if (prec != INT_MAX && last.precision != INT_MAX)
 371     {
 372       if (equal_width)
 373         {
 374           /* increase first_width by any increased precision in step */
 375           size_t first_width = first.width + (prec - first.precision);
 376           /* adjust last_width to use precision from first/step */
 377           size_t last_width = last.width + (prec - last.precision);
 378           if (last.precision && prec == 0)
 379             last_width--;  /* don't include space for '.' */
 380           if (last.precision == 0 && prec)
 381             last_width++;  /* include space for '.' */
 382           if (first.precision == 0 && prec)
 383             first_width++;  /* include space for '.' */
 384           size_t width = MAX (first_width, last_width);
 385           if (width <= INT_MAX)
 386             {
 387               int w = width;
 388               sprintf (format_buf, "%%0%d.%dLf", w, prec);
 389               return format_buf;
 390             }
 391         }
 392       else
 393         {
 394           sprintf (format_buf, "%%.%dLf", prec);
 395           return format_buf;
 396         }
 397     }
 398
 399   return "%Lg";
 400 }
 401
 402 /* The NUL-terminated string S0 of length S_LEN represents a valid
 403    non-negative decimal integer.  Adjust the string and length so
 404    that the pair describe the next-larger value.  */
 405 static void
 406 incr (char **s0, size_t *s_len)
 407 {
 408   char *s = *s0;
 409   char *endp = s + *s_len - 1;
 410
 411   do
 412     {
 413       if ((*endp)++ < '9')
 414         return;
 415       *endp-- = '0';
 416     }
 417   while (endp >= s);
 418   *--(*s0) = '1';
 419   ++*s_len;
 420 }
 421
 422 /* Compare A and B (each a NUL-terminated digit string), with lengths
 423    given by A_LEN and B_LEN.  Return +1 if A < B, -1 if B < A, else 0.  */
 424 static int
 425 cmp (char const *a, size_t a_len, char const *b, size_t b_len)
 426 {
 427   if (a_len < b_len)
 428     return -1;
 429   if (b_len < a_len)
 430     return 1;
 431   return (memcmp (a, b, a_len));
 432 }
 433
 434 /* Trim leading 0's from S, but if S is all 0's, leave one.
 435    Return a pointer to the trimmed string.  */
 436 ATTRIBUTE_PURE
 437 static char const *
 438 trim_leading_zeros (char const *s)
 439 {
 440   char const *p = s;
 441   while (*s == '0')
 442     ++s;
 443
 444   /* If there were only 0's, back up, to leave one.  */
 445   if (!*s && s != p)
 446     --s;
 447   return s;
 448 }
 449
 450 /* Print all whole numbers from A to B, inclusive -- to stdout, each
 451    followed by a newline.  If B < A, return and print nothing.
 452    Otherwise, do all the work and exit.  */
 453 static void
 454 seq_fast (char const *a, char const *b, uintmax_t step)
 455 {
 456   bool inf = STREQ (b, "inf");
 457
 458   /* Skip past any leading 0's.  Without this, our naive cmp
 459      function would declare 000 to be larger than 99.  */
 460   a = trim_leading_zeros (a);
 461   b = trim_leading_zeros (b);
 462
 463   size_t p_len = strlen (a);
 464   size_t q_len = inf ? 0 : strlen (b);
 465
 466   /* Allow for at least 31 digits without realloc.
 467      1 more than p_len is needed for the inf case.  */
 468 #define INITIAL_ALLOC_DIGITS 31
 469   size_t inc_size = MAX (MAX (p_len + 1, q_len), INITIAL_ALLOC_DIGITS);
 470   /* Ensure we only increase by at most 1 digit at buffer boundaries.  */
 471   static_assert (SEQ_FAST_STEP_LIMIT_DIGITS < INITIAL_ALLOC_DIGITS - 1);
 472
 473   /* Copy input strings (incl NUL) to end of new buffers.  */
 474   char *p0 = xmalloc (inc_size + 1);
 475   char *p = memcpy (p0 + inc_size - p_len, a, p_len + 1);
 476   char *q;
 477   char *q0;
 478   if (! inf)
 479     {
 480       q0 = xmalloc (inc_size + 1);
 481       q = memcpy (q0 + inc_size - q_len, b, q_len + 1);
 482     }
 483   else
 484     q = q0 = nullptr;
 485
 486   bool ok = inf || cmp (p, p_len, q, q_len) <= 0;
 487   if (ok)
 488     {
 489       /* Reduce number of fwrite calls which is seen to
 490          give a speed-up of more than 2x over the unbuffered code
 491          when printing the first 10^9 integers.  */
 492       size_t buf_size = MAX (BUFSIZ, (inc_size + 1) * 2);
 493       char *buf = xmalloc (buf_size);
 494       char const *buf_end = buf + buf_size;
 495
 496       char *bufp = buf;
 497
 498       /* Write first number to buffer.  */
 499       bufp = mempcpy (bufp, p, p_len);
 500
 501       /* Append separator then number.  */
 502       while (true)
 503         {
 504           for (uintmax_t n_incr = step; n_incr; n_incr--)
 505             incr (&p, &p_len);
 506
 507           if (! inf && 0 < cmp (p, p_len, q, q_len))
 508             break;
 509
 510           *bufp++ = *separator;
 511
 512           /* Double up the buffers when needed for the inf case.  */
 513           if (p_len == inc_size)
 514             {
 515               inc_size *= 2;
 516               p0 = xrealloc (p0, inc_size + 1);
 517               p = memmove (p0 + p_len, p0, p_len + 1);
 518
 519               if (buf_size < (inc_size + 1) * 2)
 520                 {
 521                   size_t buf_offset = bufp - buf;
 522                   buf_size = (inc_size + 1) * 2;
 523                   buf = xrealloc (buf, buf_size);
 524                   buf_end = buf + buf_size;
 525                   bufp = buf + buf_offset;
 526                 }
 527             }
 528
 529           bufp = mempcpy (bufp, p, p_len);
 530           /* If no place for another separator + number then
 531              output buffer so far, and reset to start of buffer.  */
 532           if (buf_end - (p_len + 1) < bufp)
 533             {
 534               if (fwrite (buf, bufp - buf, 1, stdout) != 1)
 535                 write_error ();
 536               bufp = buf;
 537             }
 538         }
 539
 540       /* Write any remaining buffered output, and the terminator.  */
 541       *bufp++ = *terminator;
 542       if (fwrite (buf, bufp - buf, 1, stdout) != 1)
 543         write_error ();
 544     }
 545
 546   if (ok)
 547     exit (EXIT_SUCCESS);
 548
 549   free (p0);
 550   free (q0);
 551 }
 552
 553 /* Return true if S consists of at least one digit and no non-digits.  */
 554 ATTRIBUTE_PURE
 555 static bool
 556 all_digits_p (char const *s)
 557 {
 558   size_t n = strlen (s);
 559   return ISDIGIT (s[0]) && n == strspn (s, "0123456789");
 560 }
 561
 562 int
 563 main (int argc, char **argv)
 564 {
 565   int optc;
 566   operand first = { 1, 1, 0 };
 567   operand step = { 1, 1, 0 };
 568   operand last;
 569   struct layout layout = { 0, 0 };
 570
 571   /* The printf(3) format used for output.  */
 572   char const *format_str = nullptr;
 573
 574   initialize_main (&argc, &argv);
 575   set_program_name (argv[0]);
 576   locale_ok = !!setlocale (LC_ALL, "");
 577   bindtextdomain (PACKAGE, LOCALEDIR);
 578   textdomain (PACKAGE);
 579
 580   atexit (close_stdout);
 581
 582   equal_width = false;
 583   separator = "\n";
 584
 585   /* We have to handle negative numbers in the command line but this
 586      conflicts with the command line arguments.  So explicitly check first
 587      whether the next argument looks like a negative number.  */
 588   while (optind < argc)
 589     {
 590       if (argv[optind][0] == '-'
 591           && ((optc = argv[optind][1]) == '.' || ISDIGIT (optc)))
 592         {
 593           /* means negative number */
 594           break;
 595         }
 596
 597       optc = getopt_long (argc, argv, "+f:s:w", long_options, nullptr);
 598       if (optc == -1)
 599         break;
 600
 601       switch (optc)
 602         {
 603         case 'f':
 604           format_str = optarg;
 605           break;
 606
 607         case 's':
 608           separator = optarg;
 609           break;
 610
 611         case 'w':
 612           equal_width = true;
 613           break;
 614
 615         case_GETOPT_HELP_CHAR;
 616
 617         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 618
 619         default:
 620           usage (EXIT_FAILURE);
 621         }
 622     }
 623
 624   int n_args = argc - optind;
 625   if (n_args < 1)
 626     {
 627       error (0, 0, _("missing operand"));
 628       usage (EXIT_FAILURE);
 629     }
 630
 631   if (3 < n_args)
 632     {
 633       error (0, 0, _("extra operand %s"), quote (argv[optind + 3]));
 634       usage (EXIT_FAILURE);
 635     }
 636
 637   if (format_str)
 638     format_str = long_double_format (format_str, &layout);
 639
 640   if (format_str != nullptr && equal_width)
 641     {
 642       error (0, 0, _("format string may not be specified"
 643                      " when printing equal width strings"));
 644       usage (EXIT_FAILURE);
 645     }
 646
 647   /* If the following hold:
 648      - no format string, [FIXME: relax this, eventually]
 649      - integer start (or no start)
 650      - integer end
 651      - integer increment <= SEQ_FAST_STEP_LIMIT
 652      then use the much more efficient integer-only code,
 653      operating on arbitrarily large numbers.  */
 654   bool fast_step_ok = false;
 655   if (n_args != 3
 656       || (all_digits_p (argv[optind + 1])
 657           && xstrtold (argv[optind + 1], nullptr, &step.value, cl_strtold)
 658           && 0 < step.value && step.value <= SEQ_FAST_STEP_LIMIT))
 659     fast_step_ok = true;
 660
 661   if (all_digits_p (argv[optind])
 662       && (n_args == 1 || all_digits_p (argv[optind + 1]))
 663       && (n_args < 3 || (fast_step_ok
 664                          && all_digits_p (argv[optind + 2])))
 665       && !equal_width && !format_str && strlen (separator) == 1)
 666     {
 667       char const *s1 = n_args == 1 ? "1" : argv[optind];
 668       char const *s2 = argv[optind + (n_args - 1)];
 669       seq_fast (s1, s2, step.value);
 670
 671       /* Upon any failure, let the more general code deal with it.  */
 672     }
 673
 674   last = scan_arg (argv[optind++]);
 675
 676   if (optind < argc)
 677     {
 678       first = last;
 679       last = scan_arg (argv[optind++]);
 680
 681       if (optind < argc)
 682         {
 683           step = last;
 684           if (step.value == 0)
 685             {
 686               error (0, 0, _("invalid Zero increment value: %s"),
 687                      quote (argv[optind - 1]));
 688               usage (EXIT_FAILURE);
 689             }
 690
 691           last = scan_arg (argv[optind++]);
 692         }
 693     }
 694
 695   /* Try the fast method again, for integers of the form 1e1 etc.,
 696      or "inf" end value.  */
 697   if (first.precision == 0 && step.precision == 0 && last.precision == 0
 698       && isfinite (first.value) && 0 <= first.value && 0 <= last.value
 699       && 0 < step.value && step.value <= SEQ_FAST_STEP_LIMIT
 700       && !equal_width && !format_str && strlen (separator) == 1)
 701     {
 702       char *s1;
 703       char *s2;
 704       if (asprintf (&s1, "%0.Lf", first.value) < 0)
 705         xalloc_die ();
 706       if (! isfinite (last.value))
 707         s2 = xstrdup ("inf"); /* Ensure "inf" is used.  */
 708       else if (asprintf (&s2, "%0.Lf", last.value) < 0)
 709         xalloc_die ();
 710
 711       if (*s1 != '-' && *s2 != '-')
 712         seq_fast (s1, s2, step.value);
 713
 714       free (s1);
 715       free (s2);
 716       /* Upon any failure, let the more general code deal with it.  */
 717     }
 718
 719   if (format_str == nullptr)
 720     format_str = get_default_format (first, step, last);
 721
 722   print_numbers (format_str, layout, first.value, step.value, last.value);
 723
 724   main_exit (EXIT_SUCCESS);
 725 }