src/dircolors.c

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