src/seq.c

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