src/dircolors.c

   1 /* dircolors - output commands to set the LS_COLOR environment variable
   2    Copyright (C) 1994, 1995, 1997, 1998 H. Peter Anvin
   3    Copyright (C) 96, 97, 1998 Free Software Foundation, Inc.
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2, or (at your option)
   8 any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  18
  19 #if HAVE_CONFIG_H
  20 # include <config.h>
  21 #endif
  22
  23 #include <sys/types.h>
  24 #include <ctype.h>
  25 #include <getopt.h>
  26 #include <stdio.h>
  27
  28 #include "system.h"
  29 #include "getline.h"
  30 #include "long-options.h"
  31 #include "closeout.h"
  32 #include "error.h"
  33 #include "obstack.h"
  34 #include "dircolors.h"
  35
  36 #define obstack_chunk_alloc malloc
  37 #define obstack_chunk_free free
  38
  39 char *base_name ();
  40 char *strndup();
  41
  42 enum Shell_syntax
  43 {
  44   SHELL_SYNTAX_BOURNE,
  45   SHELL_SYNTAX_C,
  46   SHELL_SYNTAX_UNKNOWN
  47 };
  48
  49 #define APPEND_CHAR(C) obstack_1grow (&lsc_obstack, C)
  50 #define APPEND_TWO_CHAR_STRING(S)                                       \
  51   do                                                                    \
  52     {                                                                   \
  53       APPEND_CHAR (S[0]);                                               \
  54       APPEND_CHAR (S[1]);                                               \
  55     }                                                                   \
  56   while (0)
  57
  58 /* Accumulate in this obstack the value for the LS_COLORS environment
  59    variable.  */
  60 static struct obstack lsc_obstack;
  61
  62 /* Nonzero if the input file was the standard input. */
  63 static int have_read_stdin;
  64
  65 /* FIXME: associate with ls_codes? */
  66 static const char *const slack_codes[] =
  67 {
  68   "NORMAL", "NORM", "FILE", "DIR", "LNK", "LINK",
  69   "SYMLINK", "ORPHAN", "MISSING", "FIFO", "PIPE", "SOCK", "BLK", "BLOCK",
  70   "CHR", "CHAR", "EXEC", "LEFT", "LEFTCODE", "RIGHT", "RIGHTCODE", "END",
  71   "ENDCODE", NULL
  72 };
  73
  74 static const char *const ls_codes[] =
  75 {
  76   "no", "no", "fi", "di", "ln", "ln", "ln", "or", "mi", "pi", "pi",
  77   "so", "bd", "bd", "cd", "cd", "ex", "lc", "lc", "rc", "rc", "ec", "ec"
  78 };
  79
  80 static struct option const long_options[] =
  81   {
  82     {"bourne-shell", no_argument, NULL, 'b'},
  83     {"sh", no_argument, NULL, 'b'},
  84     {"csh", no_argument, NULL, 'c'},
  85     {"c-shell", no_argument, NULL, 'c'},
  86     {"help", no_argument, NULL, 'h'},
  87     {"print-database", no_argument, NULL, 'p'},
  88     {"version", no_argument, NULL, 'v'},
  89     {NULL, 0, NULL, 0}
  90   };
  91
  92 char *program_name;
  93
  94 static void
  95 usage (int status)
  96 {
  97   if (status != 0)
  98     fprintf (stderr, _("Try `%s --help' for more information.\n"),
  99              program_name);
 100   else
 101     {
 102       printf (_("Usage: %s [OPTION]... [FILE]\n"), program_name);
 103       printf (_("\
 104 Output commands to set the LS_COLORS environment variable.\n\
 105 \n\
 106 Determine format of output:\n\
 107   -b, --sh, --bourne-shell    output Bourne shell code to set LS_COLORS\n\
 108   -c, --csh, --c-shell        output C shell code to set LS_COLORS\n\
 109   -p, --print-database        output defaults\n\
 110       --help                  display this help and exit\n\
 111       --version               output version information and exit\n\
 112 \n\
 113 If FILE is specified, read it to determine which colors to use for which\n\
 114 file types and extensions.  Otherwise, a precompiled database is used.\n\
 115 For details on the format of these files, run `dircolors --print-database'.\n\
 116 "));
 117       puts (_("\nReport bugs to <fileutils-bugs@gnu.org>."));
 118       close_stdout ();
 119     }
 120
 121   exit (status == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 122 }
 123
 124 static void *
 125 xstrndup (const char *s, size_t n)
 126 {
 127   char *new = strndup (s, n);
 128   if (new == NULL)
 129     error (EXIT_FAILURE, 0, _("virtual memory exhausted"));
 130   return new;
 131 }
 132
 133 /* If the SHELL environment variable is set to `csh' or `tcsh,'
 134    assume C shell.  Else Bourne shell.  */
 135
 136 static enum Shell_syntax
 137 guess_shell_syntax (void)
 138 {
 139   char *shell;
 140
 141   shell = getenv ("SHELL");
 142   if (shell == NULL || *shell == '\0')
 143     return SHELL_SYNTAX_UNKNOWN;
 144
 145   shell = base_name (shell);
 146
 147   if (STREQ (shell, "csh") || STREQ (shell, "tcsh"))
 148     return SHELL_SYNTAX_C;
 149
 150   return SHELL_SYNTAX_BOURNE;
 151 }
 152
 153 static void
 154 parse_line (unsigned char const *line, char **keyword, char **arg)
 155 {
 156   unsigned char const *p;
 157   unsigned char const *keyword_start;
 158   unsigned char const *arg_start;
 159
 160   *keyword = NULL;
 161   *arg = NULL;
 162
 163   for (p = line; ISSPACE (*p); ++p)
 164     ;
 165
 166   /* Ignore blank lines and shell-style comments.  */
 167   if (*p == '\0' || *p == '#')
 168     return;
 169
 170   keyword_start = p;
 171
 172   while (!ISSPACE (*p) && *p != '\0')
 173     {
 174       ++p;
 175     }
 176
 177   *keyword = xstrndup ((const char *) keyword_start, p - keyword_start);
 178   if (*p  == '\0')
 179     return;
 180
 181   do
 182     {
 183       ++p;
 184     }
 185   while (ISSPACE (*p));
 186
 187   if (*p == '\0' || *p == '#')
 188     return;
 189
 190   arg_start = p;
 191
 192   while (*p != '\0' && *p != '#')
 193     ++p;
 194
 195   for (--p; ISSPACE (*p); --p)
 196     {
 197       /* empty */
 198     }
 199   ++p;
 200
 201   *arg = xstrndup ((const char *) arg_start, p - arg_start);
 202 }
 203
 204 /* FIXME: Write a string to standard out, while watching for "dangerous"
 205    sequences like unescaped : and = characters.  */
 206
 207 static void
 208 append_quoted (const char *str)
 209 {
 210   int need_backslash = 1;
 211
 212   while (*str != '\0')
 213     {
 214       switch (*str)
 215         {
 216         case '\\':
 217         case '^':
 218           need_backslash = !need_backslash;
 219           break;
 220
 221         case ':':
 222         case '=':
 223           if (need_backslash)
 224             APPEND_CHAR ('\\');
 225           /* Fall through */
 226
 227         default:
 228           need_backslash = 1;
 229           break;
 230         }
 231
 232       APPEND_CHAR (*str);
 233       ++str;
 234     }
 235 }
 236
 237 /* Read the file open on FP (with name FILENAME).  First, look for a
 238    `TERM name' directive where name matches the current terminal type.
 239    Once found, translate and accumulate the associated directives onto
 240    the global obstack LSC_OBSTACK.  Give a diagnostic and return nonzero
 241    upon failure (unrecognized keyword is the only way to fail here).
 242    Return zero otherwise.  */
 243
 244 static int
 245 dc_parse_stream (FILE *fp, const char *filename)
 246 {
 247   size_t line_number = 0;
 248   char *line = NULL;
 249   size_t line_chars_allocated = 0;
 250   int state;
 251   char *term;
 252   int err = 0;
 253
 254   /* State for the parser.  */
 255   enum states { ST_TERMNO, ST_TERMYES, ST_TERMSURE, ST_GLOBAL };
 256
 257   state = ST_GLOBAL;
 258
 259   /* Get terminal type */
 260   term = getenv ("TERM");
 261   if (term == NULL || *term == '\0')
 262     term = "none";
 263
 264   while (1)
 265     {
 266       int line_length;
 267       char *keywd, *arg;
 268       int unrecognized;
 269
 270       ++line_number;
 271
 272       if (fp)
 273         {
 274           line_length = getline (&line, &line_chars_allocated, fp);
 275           if (line_length <= 0)
 276             {
 277               if (line)
 278                 free (line);
 279               break;
 280             }
 281         }
 282       else
 283         {
 284           line = (char *) (G_line[line_number - 1]);
 285           line_length = G_line_length[line_number - 1];
 286           if (line_number > G_N_LINES)
 287             break;
 288         }
 289
 290       parse_line ((unsigned char *) line, &keywd, &arg);
 291
 292       if (keywd == NULL)
 293         continue;
 294
 295       unrecognized = 0;
 296       if (strcasecmp (keywd, "TERM") == 0)
 297         {
 298           if (STREQ (arg, term))
 299             state = ST_TERMSURE;
 300           else if (state != ST_TERMSURE)
 301             state = ST_TERMNO;
 302         }
 303       else
 304         {
 305           if (state == ST_TERMSURE)
 306             state = ST_TERMYES; /* Another TERM can cancel */
 307
 308           if (state != ST_TERMNO)
 309             {
 310               if (keywd[0] == '.')
 311                 {
 312                   APPEND_CHAR ('*');
 313                   append_quoted (keywd);
 314                   APPEND_CHAR ('=');
 315                   append_quoted (arg);
 316                   APPEND_CHAR (':');
 317                 }
 318               else if (keywd[0] == '*')
 319                 {
 320                   append_quoted (keywd);
 321                   APPEND_CHAR ('=');
 322                   append_quoted (arg);
 323                   APPEND_CHAR (':');
 324                 }
 325               else if (strcasecmp (keywd, "OPTIONS") == 0
 326                        || strcasecmp (keywd, "COLOR") == 0
 327                        || strcasecmp (keywd, "EIGHTBIT") == 0)
 328                 {
 329                   /* Ignore.  */
 330                 }
 331               else
 332                 {
 333                   int i;
 334
 335                   for (i = 0; slack_codes[i] != NULL; ++i)
 336                     if (strcasecmp (keywd, slack_codes[i]) == 0)
 337                       break;
 338
 339                   if (slack_codes[i] != NULL)
 340                     {
 341                       APPEND_TWO_CHAR_STRING (ls_codes[i]);
 342                       APPEND_CHAR ('=');
 343                       append_quoted (arg);
 344                       APPEND_CHAR (':');
 345                     }
 346                   else
 347                     {
 348                       unrecognized = 1;
 349                     }
 350                 }
 351             }
 352           else
 353             {
 354               unrecognized = 1;
 355             }
 356         }
 357
 358       if (unrecognized && (state == ST_TERMSURE || state == ST_TERMYES))
 359         {
 360           error (0, 0, _("%s:%lu: unrecognized keyword `%s'"),
 361                  filename, (long unsigned) line_number, keywd);
 362           err = 1;
 363         }
 364
 365       free (keywd);
 366       if (arg)
 367         free (arg);
 368     }
 369
 370   return err;
 371 }
 372
 373 static int
 374 dc_parse_file (const char *filename)
 375 {
 376   FILE *fp;
 377   int err;
 378
 379   if (STREQ (filename, "-"))
 380     {
 381       have_read_stdin = 1;
 382       fp = stdin;
 383     }
 384   else
 385     {
 386       /* OPENOPTS is a macro.  It varies with the system.
 387          Some systems distinguish between internal and
 388          external text representations.  */
 389
 390       fp = fopen (filename, "r");
 391       if (fp == NULL)
 392         {
 393           error (0, errno, "%s", filename);
 394           return 1;
 395         }
 396     }
 397
 398   err = dc_parse_stream (fp, filename);
 399
 400   if (fp != stdin && fclose (fp) == EOF)
 401     {
 402       error (0, errno, "%s", filename);
 403       return 1;
 404     }
 405
 406   return err;
 407 }
 408
 409 int
 410 main (int argc, char **argv)
 411 {
 412   int err = 0;
 413   int optc;
 414   enum Shell_syntax syntax = SHELL_SYNTAX_UNKNOWN;
 415   int print_database = 0;
 416
 417   program_name = argv[0];
 418   setlocale (LC_ALL, "");
 419   bindtextdomain (PACKAGE, LOCALEDIR);
 420   textdomain (PACKAGE);
 421
 422   parse_long_options (argc, argv, "dircolors", GNU_PACKAGE, VERSION, usage);
 423
 424   while ((optc = getopt_long (argc, argv, "bcp", long_options, NULL)) != -1)
 425     switch (optc)
 426       {
 427       case 'b': /* Bourne shell syntax.  */
 428         syntax = SHELL_SYNTAX_BOURNE;
 429         break;
 430
 431       case 'c': /* C shell syntax.  */
 432         syntax = SHELL_SYNTAX_C;
 433         break;
 434
 435       case 'p':
 436         print_database = 1;
 437         break;
 438
 439       default:
 440         usage (1);
 441       }
 442
 443   argc -= optind;
 444   argv += optind;
 445
 446   /* It doesn't make sense to use --print with either of
 447      --bourne or --c-shell.  */
 448   if (print_database && syntax != SHELL_SYNTAX_UNKNOWN)
 449     {
 450       error (0, 0,
 451              _("the options to output dircolors' internal database and\n\
 452 to select a shell syntax are mutually exclusive"));
 453       usage (1);
 454     }
 455
 456   if (print_database && argc > 0)
 457     {
 458       error (0, 0,
 459              _("no FILE arguments may be used with the option to output\n\
 460 dircolors' internal database"));
 461       usage (1);
 462     }
 463
 464   if (!print_database && argc > 1)
 465     {
 466       error (0, 0, _("too many arguments"));
 467       usage (1);
 468     }
 469
 470   if (print_database)
 471     {
 472       int i;
 473       for (i = 0; i < G_N_LINES; i++)
 474         {
 475           fwrite (G_line[i], 1, G_line_length[i], stdout);
 476           fputc ('\n', stdout);
 477         }
 478     }
 479   else
 480     {
 481       /* If shell syntax was not explicitly specified, try to guess it. */
 482       if (syntax == SHELL_SYNTAX_UNKNOWN)
 483         {
 484           syntax = guess_shell_syntax ();
 485           if (syntax == SHELL_SYNTAX_UNKNOWN)
 486             {
 487               error (EXIT_FAILURE, 0,
 488          _("no SHELL environment variable, and no shell type option given"));
 489             }
 490         }
 491
 492       obstack_init (&lsc_obstack);
 493       if (argc == 0)
 494         err = dc_parse_stream (NULL, NULL);
 495       else
 496         err = dc_parse_file (argv[0]);
 497
 498       if (!err)
 499         {
 500           size_t len = obstack_object_size (&lsc_obstack);
 501           char *s = obstack_finish (&lsc_obstack);
 502           const char *prefix;
 503           const char *suffix;
 504
 505           if (syntax == SHELL_SYNTAX_BOURNE)
 506             {
 507               prefix = "LS_COLORS='";
 508               suffix = "';\nexport LS_COLORS\n";
 509             }
 510           else
 511             {
 512               prefix = "setenv LS_COLORS '";
 513               suffix = "'\n";
 514             }
 515           fputs (prefix, stdout);
 516           fwrite (s, 1, len, stdout);
 517           fputs (suffix, stdout);
 518         }
 519     }
 520
 521   close_stdout ();
 522
 523   if (have_read_stdin && fclose (stdin) == EOF)
 524     error (EXIT_FAILURE, errno, _("standard input"));
 525
 526   exit (err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
 527 }