1 /* seq - print sequence of numbers to standard output.
2 Copyright (C) 1994-2012 Free Software Foundation, Inc.
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.
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.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
17 /* Written by Ulrich Drepper. */
22 #include <sys/types.h>
30 /* Roll our own isfinite rather than using <math.h>, so that we don't
31 have to worry about linking -lm just for isfinite. */
33 # define isfinite(x) ((x) * 0 == 0)
36 /* The official name of this program (e.g., no 'g' prefix). */
37 #define PROGRAM_NAME "seq"
39 #define AUTHORS proper_name ("Ulrich Drepper")
41 /* If true print all number with equal width. */
42 static bool equal_width
;
44 /* The string used to separate two numbers. */
45 static char const *separator
;
47 /* The string output after all numbers have been output.
48 Usually "\n" or "\0". */
49 static char const terminator
[] = "\n";
51 static struct option
const long_options
[] =
53 { "equal-width", no_argument
, NULL
, 'w'},
54 { "format", required_argument
, NULL
, 'f'},
55 { "separator", required_argument
, NULL
, 's'},
56 {GETOPT_HELP_OPTION_DECL
},
57 {GETOPT_VERSION_OPTION_DECL
},
64 if (status
!= EXIT_SUCCESS
)
69 Usage: %s [OPTION]... LAST\n\
70 or: %s [OPTION]... FIRST LAST\n\
71 or: %s [OPTION]... FIRST INCREMENT LAST\n\
72 "), program_name
, program_name
, program_name
);
74 Print numbers from FIRST to LAST, in steps of INCREMENT.\n\
76 -f, --format=FORMAT use printf style floating-point FORMAT\n\
77 -s, --separator=STRING use STRING to separate numbers (default: \\n)\n\
78 -w, --equal-width equalize width by padding with leading zeroes\n\
80 fputs (HELP_OPTION_DESCRIPTION
, stdout
);
81 fputs (VERSION_OPTION_DESCRIPTION
, stdout
);
84 If FIRST or INCREMENT is omitted, it defaults to 1. That is, an\n\
85 omitted INCREMENT defaults to 1 even when LAST is smaller than FIRST.\n\
86 FIRST, INCREMENT, and LAST are interpreted as floating point values.\n\
87 INCREMENT is usually positive if FIRST is smaller than LAST, and\n\
88 INCREMENT is usually negative if FIRST is greater than LAST.\n\
91 FORMAT must be suitable for printing one argument of type 'double';\n\
92 it defaults to %.PRECf if FIRST, INCREMENT, and LAST are all fixed point\n\
93 decimal numbers with maximum precision PREC, and to %g otherwise.\n\
95 emit_ancillary_info ();
100 /* A command-line operand. */
103 /* Its value, converted to 'long double'. */
106 /* Its print width, if it were printed out in a form similar to its
107 input form. An input like "-.1" is treated like "-0.1", and an
108 input like "1." is treated like "1", but otherwise widths are
112 /* Number of digits after the decimal point, or INT_MAX if the
113 number can't easily be expressed as a fixed-point number. */
116 typedef struct operand operand
;
118 /* Description of what a number-generating format will generate. */
121 /* Number of bytes before and after the number. */
126 /* Read a long double value from the command line.
127 Return if the string is correct else signal error. */
130 scan_arg (const char *arg
)
134 if (! xstrtold (arg
, NULL
, &ret
.value
, c_strtold
))
136 error (0, 0, _("invalid floating point argument: %s"), arg
);
137 usage (EXIT_FAILURE
);
140 /* We don't output spaces or '+' so don't include in width */
141 while (isspace (to_uchar (*arg
)) || *arg
== '+')
144 ret
.width
= strlen (arg
);
145 ret
.precision
= INT_MAX
;
147 if (! arg
[strcspn (arg
, "xX")] && isfinite (ret
.value
))
149 char const *decimal_point
= strchr (arg
, '.');
154 size_t fraction_len
= strcspn (decimal_point
+ 1, "eE");
155 if (fraction_len
<= INT_MAX
)
156 ret
.precision
= fraction_len
;
157 ret
.width
+= (fraction_len
== 0 /* #. -> # */
159 : (decimal_point
== arg
/* .# -> 0.# */
160 || ! ISDIGIT (decimal_point
[-1]))); /* -.# -> 0.# */
162 char const *e
= strchr (arg
, 'e');
164 e
= strchr (arg
, 'E');
167 long exponent
= strtol (e
+ 1, NULL
, 10);
168 ret
.precision
+= exponent
< 0 ? -exponent
: 0;
175 /* If FORMAT is a valid printf format for a double argument, return
176 its long double equivalent, allocated from dynamic storage, and
177 store into *LAYOUT a description of the output layout; otherwise,
178 report an error and exit. */
181 long_double_format (char const *fmt
, struct layout
*layout
)
184 size_t prefix_len
= 0;
185 size_t suffix_len
= 0;
186 size_t length_modifier_offset
;
189 for (i
= 0; ! (fmt
[i
] == '%' && fmt
[i
+ 1] != '%'); i
+= (fmt
[i
] == '%') + 1)
192 error (EXIT_FAILURE
, 0,
193 _("format %s has no %% directive"), quote (fmt
));
198 i
+= strspn (fmt
+ i
, "-+#0 '");
199 i
+= strspn (fmt
+ i
, "0123456789");
203 i
+= strspn (fmt
+ i
, "0123456789");
206 length_modifier_offset
= i
;
207 has_L
= (fmt
[i
] == 'L');
210 error (EXIT_FAILURE
, 0, _("format %s ends in %%"), quote (fmt
));
211 if (! strchr ("efgaEFGA", fmt
[i
]))
212 error (EXIT_FAILURE
, 0,
213 _("format %s has unknown %%%c directive"), quote (fmt
), fmt
[i
]);
215 for (i
++; ; i
+= (fmt
[i
] == '%') + 1)
216 if (fmt
[i
] == '%' && fmt
[i
+ 1] != '%')
217 error (EXIT_FAILURE
, 0, _("format %s has too many %% directives"),
223 size_t format_size
= i
+ 1;
224 char *ldfmt
= xmalloc (format_size
+ 1);
225 memcpy (ldfmt
, fmt
, length_modifier_offset
);
226 ldfmt
[length_modifier_offset
] = 'L';
227 strcpy (ldfmt
+ length_modifier_offset
+ 1,
228 fmt
+ length_modifier_offset
+ has_L
);
229 layout
->prefix_len
= prefix_len
;
230 layout
->suffix_len
= suffix_len
;
235 /* Actually print the sequence of numbers in the specified range, with the
236 given or default stepping and format. */
239 print_numbers (char const *fmt
, struct layout layout
,
240 long double first
, long double step
, long double last
)
242 bool out_of_range
= (step
< 0 ? first
< last
: last
< first
);
246 long double x
= first
;
255 x
= first
+ i
* step
;
256 out_of_range
= (step
< 0 ? x
< last
: last
< x
);
260 /* If the number just past LAST prints as a value equal
261 to LAST, and prints differently from the previous
262 number, then print the number. This avoids problems
263 with rounding. For example, with the x86 it causes
264 "seq 0 0.000001 0.000003" to print 0.000003 instead
265 of stopping at 0.000002. */
267 bool print_extra_number
= false;
271 setlocale (LC_NUMERIC
, "C");
272 x_strlen
= asprintf (&x_str
, fmt
, x
);
273 setlocale (LC_NUMERIC
, "");
276 x_str
[x_strlen
- layout
.suffix_len
] = '\0';
278 if (xstrtold (x_str
+ layout
.prefix_len
, NULL
, &x_val
, c_strtold
)
282 if (asprintf (&x0_str
, fmt
, x0
) < 0)
284 print_extra_number
= !STREQ (x0_str
, x_str
);
289 if (! print_extra_number
)
293 fputs (separator
, stdout
);
296 fputs (terminator
, stdout
);
300 /* Return the default format given FIRST, STEP, and LAST. */
302 get_default_format (operand first
, operand step
, operand last
)
304 static char format_buf
[sizeof "%0.Lf" + 2 * INT_STRLEN_BOUND (int)];
306 int prec
= MAX (first
.precision
, step
.precision
);
308 if (prec
!= INT_MAX
&& last
.precision
!= INT_MAX
)
312 /* increase first_width by any increased precision in step */
313 size_t first_width
= first
.width
+ (prec
- first
.precision
);
314 /* adjust last_width to use precision from first/step */
315 size_t last_width
= last
.width
+ (prec
- last
.precision
);
316 if (last
.precision
&& prec
== 0)
317 last_width
--; /* don't include space for '.' */
318 if (last
.precision
== 0 && prec
)
319 last_width
++; /* include space for '.' */
320 size_t width
= MAX (first_width
, last_width
);
321 if (width
<= INT_MAX
)
324 sprintf (format_buf
, "%%0%d.%dLf", w
, prec
);
330 sprintf (format_buf
, "%%.%dLf", prec
);
338 /* The NUL-terminated string S0 of length S_LEN represents a valid
339 non-negative decimal integer. Adjust the string and length so
340 that the pair describe the next-larger value. */
342 incr (char **s0
, size_t *s_len
)
345 char *endp
= s
+ *s_len
- 1;
358 /* Compare A and B (each a NUL-terminated digit string), with lengths
359 given by A_LEN and B_LEN. Return +1 if A < B, -1 if B < A, else 0. */
361 cmp (char const *a
, size_t a_len
, char const *b
, size_t b_len
)
367 return (strcmp (a
, b
));
370 /* Trim leading 0's from S, but if S is all 0's, leave one.
371 Return a pointer to the trimmed string. */
372 static char const * _GL_ATTRIBUTE_PURE
373 trim_leading_zeros (char const *s
)
379 /* If there were only 0's, back up, to leave one. */
385 /* Print all whole numbers from A to B, inclusive -- to stdout, each
386 followed by a newline. If B < A, return false and print nothing.
387 Otherwise, return true. */
389 seq_fast (char const *a
, char const *b
)
391 /* Skip past any leading 0's. Without this, our naive cmp
392 function would declare 000 to be larger than 99. */
393 a
= trim_leading_zeros (a
);
394 b
= trim_leading_zeros (b
);
396 size_t p_len
= strlen (a
);
397 size_t q_len
= strlen (b
);
398 size_t n
= MAX (p_len
, q_len
);
399 char *p0
= xmalloc (n
+ 1);
400 char *p
= memcpy (p0
+ n
- p_len
, a
, p_len
+ 1);
401 char *q0
= xmalloc (n
+ 1);
402 char *q
= memcpy (q0
+ n
- q_len
, b
, q_len
+ 1);
404 bool ok
= cmp (p
, p_len
, q
, q_len
) <= 0;
407 /* Buffer at least this many output lines per fwrite call.
408 This gives a speed-up of more than 2x over the unbuffered code
409 when printing the first 10^9 integers. */
411 char *buf
= xmalloc (N
* (n
+ 1));
412 char const *buf_end
= buf
+ N
* (n
+ 1);
416 while (cmp (p
, p_len
, q
, q_len
) < 0)
419 z
= mempcpy (z
, p
, p_len
);
421 if (buf_end
- n
- 1 < z
)
423 fwrite (buf
, z
- buf
, 1, stdout
);
428 /* Write any remaining, buffered output. */
430 fwrite (buf
, z
- buf
, 1, stdout
);
432 IF_LINT (free (buf
));
440 /* Return true if S consists of at least one digit and no non-digits. */
441 static bool _GL_ATTRIBUTE_PURE
442 all_digits_p (char const *s
)
444 size_t n
= strlen (s
);
445 return ISDIGIT (s
[0]) && n
== strspn (s
, "0123456789");
449 main (int argc
, char **argv
)
452 operand first
= { 1, 1, 0 };
453 operand step
= { 1, 1, 0 };
455 struct layout layout
= { 0, 0 };
457 /* The printf(3) format used for output. */
458 char const *format_str
= NULL
;
460 initialize_main (&argc
, &argv
);
461 set_program_name (argv
[0]);
462 setlocale (LC_ALL
, "");
463 bindtextdomain (PACKAGE
, LOCALEDIR
);
464 textdomain (PACKAGE
);
466 atexit (close_stdout
);
471 /* We have to handle negative numbers in the command line but this
472 conflicts with the command line arguments. So explicitly check first
473 whether the next argument looks like a negative number. */
474 while (optind
< argc
)
476 if (argv
[optind
][0] == '-'
477 && ((optc
= argv
[optind
][1]) == '.' || ISDIGIT (optc
)))
479 /* means negative number */
483 optc
= getopt_long (argc
, argv
, "+f:s:w", long_options
, NULL
);
501 case_GETOPT_HELP_CHAR
;
503 case_GETOPT_VERSION_CHAR (PROGRAM_NAME
, AUTHORS
);
506 usage (EXIT_FAILURE
);
510 unsigned int n_args
= argc
- optind
;
513 error (0, 0, _("missing operand"));
514 usage (EXIT_FAILURE
);
519 error (0, 0, _("extra operand %s"), quote (argv
[optind
+ 3]));
520 usage (EXIT_FAILURE
);
524 format_str
= long_double_format (format_str
, &layout
);
526 if (format_str
!= NULL
&& equal_width
)
528 error (0, 0, _("format string may not be specified"
529 " when printing equal width strings"));
530 usage (EXIT_FAILURE
);
533 /* If the following hold:
534 - no format string, [FIXME: relax this, eventually]
535 - integer start (or no start)
537 - increment == 1 or not specified [FIXME: relax this, eventually]
538 then use the much more efficient integer-only code. */
539 if (all_digits_p (argv
[optind
])
540 && (n_args
== 1 || all_digits_p (argv
[optind
+ 1]))
541 && (n_args
< 3 || STREQ ("1", argv
[optind
+ 2]))
542 && !equal_width
&& !format_str
&& strlen (separator
) == 1)
544 char const *s1
= n_args
== 1 ? "1" : argv
[optind
];
545 char const *s2
= n_args
== 1 ? argv
[optind
] : argv
[optind
+ 1];
546 if (seq_fast (s1
, s2
))
549 /* Upon any failure, let the more general code deal with it. */
552 last
= scan_arg (argv
[optind
++]);
557 last
= scan_arg (argv
[optind
++]);
562 last
= scan_arg (argv
[optind
++]);
566 if (first
.precision
== 0 && step
.precision
== 0 && last
.precision
== 0
567 && 0 <= first
.value
&& step
.value
== 1 && 0 <= last
.value
568 && !equal_width
&& !format_str
&& strlen (separator
) == 1)
572 if (asprintf (&s1
, "%0.Lf", first
.value
) < 0)
574 if (asprintf (&s2
, "%0.Lf", last
.value
) < 0)
577 if (seq_fast (s1
, s2
))
586 /* Upon any failure, let the more general code deal with it. */
589 if (format_str
== NULL
)
590 format_str
= get_default_format (first
, step
, last
);
592 print_numbers (format_str
, layout
, first
.value
, step
.value
, last
.value
);