src/nl.c

   1 /* nl -- number lines of files
   2    Copyright (C) 1989-2016 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 <http://www.gnu.org/licenses/>.  */
  16
  17 /* Written by Scott Bartram (nancy!scott@uunet.uu.net)
  18    Revised by David MacKenzie (djm@gnu.ai.mit.edu) */
  19
  20 #include <config.h>
  21
  22 #include <stdio.h>
  23 #include <sys/types.h>
  24 #include <getopt.h>
  25
  26 #include "system.h"
  27
  28 #include <regex.h>
  29
  30 #include "die.h"
  31 #include "error.h"
  32 #include "fadvise.h"
  33 #include "linebuffer.h"
  34 #include "quote.h"
  35 #include "xdectoint.h"
  36
  37 /* The official name of this program (e.g., no 'g' prefix).  */
  38 #define PROGRAM_NAME "nl"
  39
  40 #define AUTHORS \
  41   proper_name ("Scott Bartram"), \
  42   proper_name ("David MacKenzie")
  43
  44 /* Line-number formats.  They are given an int width, an intmax_t
  45    value, and a string separator.  */
  46
  47 /* Right justified, no leading zeroes.  */
  48 static char const FORMAT_RIGHT_NOLZ[] = "%*" PRIdMAX "%s";
  49
  50 /* Right justified, leading zeroes.  */
  51 static char const FORMAT_RIGHT_LZ[] = "%0*" PRIdMAX "%s";
  52
  53 /* Left justified, no leading zeroes.  */
  54 static char const FORMAT_LEFT[] = "%-*" PRIdMAX "%s";
  55
  56 /* Default section delimiter characters.  */
  57 static char const DEFAULT_SECTION_DELIMITERS[] = "\\:";
  58
  59 /* Types of input lines: either one of the section delimiters,
  60    or text to output. */
  61 enum section
  62 {
  63   Header, Body, Footer, Text
  64 };
  65
  66 /* Format of body lines (-b).  */
  67 static char const *body_type = "t";
  68
  69 /* Format of header lines (-h).  */
  70 static char const *header_type = "n";
  71
  72 /* Format of footer lines (-f).  */
  73 static char const *footer_type = "n";
  74
  75 /* Format currently being used (body, header, or footer).  */
  76 static char const *current_type;
  77
  78 /* Regex for body lines to number (-bp).  */
  79 static struct re_pattern_buffer body_regex;
  80
  81 /* Regex for header lines to number (-hp).  */
  82 static struct re_pattern_buffer header_regex;
  83
  84 /* Regex for footer lines to number (-fp).  */
  85 static struct re_pattern_buffer footer_regex;
  86
  87 /* Fastmaps for the above.  */
  88 static char body_fastmap[UCHAR_MAX + 1];
  89 static char header_fastmap[UCHAR_MAX + 1];
  90 static char footer_fastmap[UCHAR_MAX + 1];
  91
  92 /* Pointer to current regex, if any.  */
  93 static struct re_pattern_buffer *current_regex = NULL;
  94
  95 /* Separator string to print after line number (-s).  */
  96 static char const *separator_str = "\t";
  97
  98 /* Input section delimiter string (-d).  */
  99 static char const *section_del = DEFAULT_SECTION_DELIMITERS;
 100
 101 /* Header delimiter string.  */
 102 static char *header_del = NULL;
 103
 104 /* Header section delimiter length.  */
 105 static size_t header_del_len;
 106
 107 /* Body delimiter string.  */
 108 static char *body_del = NULL;
 109
 110 /* Body section delimiter length.  */
 111 static size_t body_del_len;
 112
 113 /* Footer delimiter string.  */
 114 static char *footer_del = NULL;
 115
 116 /* Footer section delimiter length.  */
 117 static size_t footer_del_len;
 118
 119 /* Input buffer.  */
 120 static struct linebuffer line_buf;
 121
 122 /* printf format string for unnumbered lines.  */
 123 static char *print_no_line_fmt = NULL;
 124
 125 /* Starting line number on each page (-v).  */
 126 static intmax_t starting_line_number = 1;
 127
 128 /* Line number increment (-i).  */
 129 static intmax_t page_incr = 1;
 130
 131 /* If true, reset line number at start of each page (-p).  */
 132 static bool reset_numbers = true;
 133
 134 /* Number of blank lines to consider to be one line for numbering (-l).  */
 135 static intmax_t blank_join = 1;
 136
 137 /* Width of line numbers (-w).  */
 138 static int lineno_width = 6;
 139
 140 /* Line number format (-n).  */
 141 static char const *lineno_format = FORMAT_RIGHT_NOLZ;
 142
 143 /* Current print line number.  */
 144 static intmax_t line_no;
 145
 146 /* True if we have ever read standard input.  */
 147 static bool have_read_stdin;
 148
 149 static struct option const longopts[] =
 150 {
 151   {"header-numbering", required_argument, NULL, 'h'},
 152   {"body-numbering", required_argument, NULL, 'b'},
 153   {"footer-numbering", required_argument, NULL, 'f'},
 154   {"starting-line-number", required_argument, NULL, 'v'},
 155   {"line-increment", required_argument, NULL, 'i'},
 156   {"no-renumber", no_argument, NULL, 'p'},
 157   {"join-blank-lines", required_argument, NULL, 'l'},
 158   {"number-separator", required_argument, NULL, 's'},
 159   {"number-width", required_argument, NULL, 'w'},
 160   {"number-format", required_argument, NULL, 'n'},
 161   {"section-delimiter", required_argument, NULL, 'd'},
 162   {GETOPT_HELP_OPTION_DECL},
 163   {GETOPT_VERSION_OPTION_DECL},
 164   {NULL, 0, NULL, 0}
 165 };
 166
 167 /* Print a usage message and quit. */
 168
 169 void
 170 usage (int status)
 171 {
 172   if (status != EXIT_SUCCESS)
 173     emit_try_help ();
 174   else
 175     {
 176       printf (_("\
 177 Usage: %s [OPTION]... [FILE]...\n\
 178 "),
 179               program_name);
 180       fputs (_("\
 181 Write each FILE to standard output, with line numbers added.\n\
 182 "), stdout);
 183
 184       emit_stdin_note ();
 185       emit_mandatory_arg_note ();
 186
 187       fputs (_("\
 188   -b, --body-numbering=STYLE      use STYLE for numbering body lines\n\
 189   -d, --section-delimiter=CC      use CC for logical page delimiters\n\
 190   -f, --footer-numbering=STYLE    use STYLE for numbering footer lines\n\
 191 "), stdout);
 192       fputs (_("\
 193   -h, --header-numbering=STYLE    use STYLE for numbering header lines\n\
 194   -i, --line-increment=NUMBER     line number increment at each line\n\
 195   -l, --join-blank-lines=NUMBER   group of NUMBER empty lines counted as one\n\
 196   -n, --number-format=FORMAT      insert line numbers according to FORMAT\n\
 197   -p, --no-renumber               do not reset line numbers for each section\n\
 198   -s, --number-separator=STRING   add STRING after (possible) line number\n\
 199 "), stdout);
 200       fputs (_("\
 201   -v, --starting-line-number=NUMBER  first line number for each section\n\
 202   -w, --number-width=NUMBER       use NUMBER columns for line numbers\n\
 203 "), stdout);
 204       fputs (HELP_OPTION_DESCRIPTION, stdout);
 205       fputs (VERSION_OPTION_DESCRIPTION, stdout);
 206       fputs (_("\
 207 \n\
 208 By default, selects -v1 -i1 -l1 -sTAB -w6 -nrn -hn -bt -fn.\n\
 209 CC are two delimiter characters used to construct logical page delimiters,\n\
 210 a missing second character implies :.  Type \\\\ for \\.  STYLE is one of:\n\
 211 "), stdout);
 212       fputs (_("\
 213 \n\
 214   a         number all lines\n\
 215   t         number only nonempty lines\n\
 216   n         number no lines\n\
 217   pBRE      number only lines that contain a match for the basic regular\n\
 218             expression, BRE\n\
 219 \n\
 220 FORMAT is one of:\n\
 221 \n\
 222   ln   left justified, no leading zeros\n\
 223   rn   right justified, no leading zeros\n\
 224   rz   right justified, leading zeros\n\
 225 \n\
 226 "), stdout);
 227       emit_ancillary_info (PROGRAM_NAME);
 228     }
 229   exit (status);
 230 }
 231
 232 /* Set the command line flag TYPEP and possibly the regex pointer REGEXP,
 233    according to 'optarg'.  */
 234
 235 static bool
 236 build_type_arg (char const **typep,
 237                 struct re_pattern_buffer *regexp, char *fastmap)
 238 {
 239   char const *errmsg;
 240   bool rval = true;
 241
 242   switch (*optarg)
 243     {
 244     case 'a':
 245     case 't':
 246     case 'n':
 247       *typep = optarg;
 248       break;
 249     case 'p':
 250       *typep = optarg++;
 251       regexp->buffer = NULL;
 252       regexp->allocated = 0;
 253       regexp->fastmap = fastmap;
 254       regexp->translate = NULL;
 255       re_syntax_options =
 256         RE_SYNTAX_POSIX_BASIC & ~RE_CONTEXT_INVALID_DUP & ~RE_NO_EMPTY_RANGES;
 257       errmsg = re_compile_pattern (optarg, strlen (optarg), regexp);
 258       if (errmsg)
 259         die (EXIT_FAILURE, 0, "%s", (errmsg));
 260       break;
 261     default:
 262       rval = false;
 263       break;
 264     }
 265   return rval;
 266 }
 267
 268 /* Print the line number and separator; increment the line number. */
 269
 270 static void
 271 print_lineno (void)
 272 {
 273   intmax_t next_line_no;
 274
 275   printf (lineno_format, lineno_width, line_no, separator_str);
 276
 277   next_line_no = line_no + page_incr;
 278   if (next_line_no < line_no)
 279     die (EXIT_FAILURE, 0, _("line number overflow"));
 280   line_no = next_line_no;
 281 }
 282
 283 /* Switch to a header section. */
 284
 285 static void
 286 proc_header (void)
 287 {
 288   current_type = header_type;
 289   current_regex = &header_regex;
 290   if (reset_numbers)
 291     line_no = starting_line_number;
 292   putchar ('\n');
 293 }
 294
 295 /* Switch to a body section. */
 296
 297 static void
 298 proc_body (void)
 299 {
 300   current_type = body_type;
 301   current_regex = &body_regex;
 302   if (reset_numbers)
 303     line_no = starting_line_number;
 304   putchar ('\n');
 305 }
 306
 307 /* Switch to a footer section. */
 308
 309 static void
 310 proc_footer (void)
 311 {
 312   current_type = footer_type;
 313   current_regex = &footer_regex;
 314   if (reset_numbers)
 315     line_no = starting_line_number;
 316   putchar ('\n');
 317 }
 318
 319 /* Process a regular text line in 'line_buf'. */
 320
 321 static void
 322 proc_text (void)
 323 {
 324   static intmax_t blank_lines = 0;      /* Consecutive blank lines so far. */
 325
 326   switch (*current_type)
 327     {
 328     case 'a':
 329       if (blank_join > 1)
 330         {
 331           if (1 < line_buf.length || ++blank_lines == blank_join)
 332             {
 333               print_lineno ();
 334               blank_lines = 0;
 335             }
 336           else
 337             fputs (print_no_line_fmt, stdout);
 338         }
 339       else
 340         print_lineno ();
 341       break;
 342     case 't':
 343       if (1 < line_buf.length)
 344         print_lineno ();
 345       else
 346         fputs (print_no_line_fmt, stdout);
 347       break;
 348     case 'n':
 349       fputs (print_no_line_fmt, stdout);
 350       break;
 351     case 'p':
 352       switch (re_search (current_regex, line_buf.buffer, line_buf.length - 1,
 353                          0, line_buf.length - 1, NULL))
 354         {
 355         case -2:
 356           die (EXIT_FAILURE, errno, _("error in regular expression search"));
 357
 358         case -1:
 359           fputs (print_no_line_fmt, stdout);
 360           break;
 361
 362         default:
 363           print_lineno ();
 364           break;
 365         }
 366     }
 367   fwrite (line_buf.buffer, sizeof (char), line_buf.length, stdout);
 368 }
 369
 370 /* Return the type of line in 'line_buf'. */
 371
 372 static enum section
 373 check_section (void)
 374 {
 375   size_t len = line_buf.length - 1;
 376
 377   if (len < 2 || memcmp (line_buf.buffer, section_del, 2))
 378     return Text;
 379   if (len == header_del_len
 380       && !memcmp (line_buf.buffer, header_del, header_del_len))
 381     return Header;
 382   if (len == body_del_len
 383       && !memcmp (line_buf.buffer, body_del, body_del_len))
 384     return Body;
 385   if (len == footer_del_len
 386       && !memcmp (line_buf.buffer, footer_del, footer_del_len))
 387     return Footer;
 388   return Text;
 389 }
 390
 391 /* Read and process the file pointed to by FP. */
 392
 393 static void
 394 process_file (FILE *fp)
 395 {
 396   while (readlinebuffer (&line_buf, fp))
 397     {
 398       switch (check_section ())
 399         {
 400         case Header:
 401           proc_header ();
 402           break;
 403         case Body:
 404           proc_body ();
 405           break;
 406         case Footer:
 407           proc_footer ();
 408           break;
 409         case Text:
 410           proc_text ();
 411           break;
 412         }
 413     }
 414 }
 415
 416 /* Process file FILE to standard output.
 417    Return true if successful.  */
 418
 419 static bool
 420 nl_file (char const *file)
 421 {
 422   FILE *stream;
 423
 424   if (STREQ (file, "-"))
 425     {
 426       have_read_stdin = true;
 427       stream = stdin;
 428     }
 429   else
 430     {
 431       stream = fopen (file, "r");
 432       if (stream == NULL)
 433         {
 434           error (0, errno, "%s", quotef (file));
 435           return false;
 436         }
 437     }
 438
 439   fadvise (stream, FADVISE_SEQUENTIAL);
 440
 441   process_file (stream);
 442
 443   if (ferror (stream))
 444     {
 445       error (0, errno, "%s", quotef (file));
 446       return false;
 447     }
 448   if (STREQ (file, "-"))
 449     clearerr (stream);          /* Also clear EOF. */
 450   else if (fclose (stream) == EOF)
 451     {
 452       error (0, errno, "%s", quotef (file));
 453       return false;
 454     }
 455   return true;
 456 }
 457
 458 int
 459 main (int argc, char **argv)
 460 {
 461   int c;
 462   size_t len;
 463   bool ok = true;
 464
 465   initialize_main (&argc, &argv);
 466   set_program_name (argv[0]);
 467   setlocale (LC_ALL, "");
 468   bindtextdomain (PACKAGE, LOCALEDIR);
 469   textdomain (PACKAGE);
 470
 471   atexit (close_stdout);
 472
 473   have_read_stdin = false;
 474
 475   while ((c = getopt_long (argc, argv, "h:b:f:v:i:pl:s:w:n:d:", longopts,
 476                            NULL)) != -1)
 477     {
 478       switch (c)
 479         {
 480         case 'h':
 481           if (! build_type_arg (&header_type, &header_regex, header_fastmap))
 482             {
 483               error (0, 0, _("invalid header numbering style: %s"),
 484                      quote (optarg));
 485               ok = false;
 486             }
 487           break;
 488         case 'b':
 489           if (! build_type_arg (&body_type, &body_regex, body_fastmap))
 490             {
 491               error (0, 0, _("invalid body numbering style: %s"),
 492                      quote (optarg));
 493               ok = false;
 494             }
 495           break;
 496         case 'f':
 497           if (! build_type_arg (&footer_type, &footer_regex, footer_fastmap))
 498             {
 499               error (0, 0, _("invalid footer numbering style: %s"),
 500                      quote (optarg));
 501               ok = false;
 502             }
 503           break;
 504         case 'v':
 505           starting_line_number = xdectoimax (optarg, INTMAX_MIN, INTMAX_MAX, "",
 506                                              _("invalid starting line number"),
 507                                              0);
 508           break;
 509         case 'i':
 510           page_incr = xdectoimax (optarg, 1, INTMAX_MAX, "",
 511                                   _("invalid line number increment"), 0);
 512           break;
 513         case 'p':
 514           reset_numbers = false;
 515           break;
 516         case 'l':
 517           blank_join = xdectoimax (optarg, 1, INTMAX_MAX, "",
 518                                    _("invalid line number of blank lines"), 0);
 519           break;
 520         case 's':
 521           separator_str = optarg;
 522           break;
 523         case 'w':
 524           lineno_width = xdectoimax (optarg, 1, INT_MAX, "",
 525                                      _("invalid line number field width"), 0);
 526           break;
 527         case 'n':
 528           if (STREQ (optarg, "ln"))
 529             lineno_format = FORMAT_LEFT;
 530           else if (STREQ (optarg, "rn"))
 531             lineno_format = FORMAT_RIGHT_NOLZ;
 532           else if (STREQ (optarg, "rz"))
 533             lineno_format = FORMAT_RIGHT_LZ;
 534           else
 535             {
 536               error (0, 0, _("invalid line numbering format: %s"),
 537                      quote (optarg));
 538               ok = false;
 539             }
 540           break;
 541         case 'd':
 542           section_del = optarg;
 543           break;
 544         case_GETOPT_HELP_CHAR;
 545         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
 546         default:
 547           ok = false;
 548           break;
 549         }
 550     }
 551
 552   if (!ok)
 553     usage (EXIT_FAILURE);
 554
 555   /* Initialize the section delimiters.  */
 556   len = strlen (section_del);
 557
 558   header_del_len = len * 3;
 559   header_del = xmalloc (header_del_len + 1);
 560   stpcpy (stpcpy (stpcpy (header_del, section_del), section_del), section_del);
 561
 562   body_del_len = len * 2;
 563   body_del = xmalloc (body_del_len + 1);
 564   stpcpy (stpcpy (body_del, section_del), section_del);
 565
 566   footer_del_len = len;
 567   footer_del = xmalloc (footer_del_len + 1);
 568   stpcpy (footer_del, section_del);
 569
 570   /* Initialize the input buffer.  */
 571   initbuffer (&line_buf);
 572
 573   /* Initialize the printf format for unnumbered lines. */
 574   len = strlen (separator_str);
 575   print_no_line_fmt = xmalloc (lineno_width + len + 1);
 576   memset (print_no_line_fmt, ' ', lineno_width + len);
 577   print_no_line_fmt[lineno_width + len] = '\0';
 578
 579   line_no = starting_line_number;
 580   current_type = body_type;
 581   current_regex = &body_regex;
 582
 583   /* Main processing. */
 584
 585   if (optind == argc)
 586     ok = nl_file ("-");
 587   else
 588     for (; optind < argc; optind++)
 589       ok &= nl_file (argv[optind]);
 590
 591   if (have_read_stdin && fclose (stdin) == EOF)
 592     die (EXIT_FAILURE, errno, "-");
 593
 594   return ok ? EXIT_SUCCESS : EXIT_FAILURE;
 595 }