src/ls.c

   1 /* `dir', `vdir' and `ls' directory listing programs for GNU.
   2    Copyright (C) 85, 88, 90, 91, 1995-2006 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 2, or (at your option)
   7    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, write to the Free Software Foundation,
  16    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  17
  18 /* If ls_mode is LS_MULTI_COL,
  19    the multi-column format is the default regardless
  20    of the type of output device.
  21    This is for the `dir' program.
  22
  23    If ls_mode is LS_LONG_FORMAT,
  24    the long format is the default regardless of the
  25    type of output device.
  26    This is for the `vdir' program.
  27
  28    If ls_mode is LS_LS,
  29    the output format depends on whether the output
  30    device is a terminal.
  31    This is for the `ls' program.  */
  32
  33 /* Written by Richard Stallman and David MacKenzie.  */
  34
  35 /* Color support by Peter Anvin <Peter.Anvin@linux.org> and Dennis
  36    Flaherty <dennisf@denix.elk.miles.com> based on original patches by
  37    Greg Lee <lee@uhunix.uhcc.hawaii.edu>.  */
  38
  39 #include <config.h>
  40 #include <sys/types.h>
  41
  42 #if HAVE_TERMIOS_H
  43 # include <termios.h>
  44 #endif
  45 #if HAVE_STROPTS_H
  46 # include <stropts.h>
  47 #endif
  48 #if HAVE_SYS_IOCTL_H
  49 # include <sys/ioctl.h>
  50 #endif
  51
  52 #ifdef WINSIZE_IN_PTEM
  53 # include <sys/stream.h>
  54 # include <sys/ptem.h>
  55 #endif
  56
  57 #include <stdio.h>
  58 #include <assert.h>
  59 #include <setjmp.h>
  60 #include <grp.h>
  61 #include <pwd.h>
  62 #include <getopt.h>
  63 #include <signal.h>
  64
  65 /* Use SA_NOCLDSTOP as a proxy for whether the sigaction machinery is
  66    present.  */
  67 #ifndef SA_NOCLDSTOP
  68 # define SA_NOCLDSTOP 0
  69 # define sigprocmask(How, Set, Oset) /* empty */
  70 # define sigset_t int
  71 # if ! HAVE_SIGINTERRUPT
  72 #  define siginterrupt(sig, flag) /* empty */
  73 # endif
  74 #endif
  75 #ifndef SA_RESTART
  76 # define SA_RESTART 0
  77 #endif
  78
  79 #include "system.h"
  80 #include <fnmatch.h>
  81
  82 #include "acl.h"
  83 #include "argmatch.h"
  84 #include "dev-ino.h"
  85 #include "dirfd.h"
  86 #include "error.h"
  87 #include "filenamecat.h"
  88 #include "hard-locale.h"
  89 #include "hash.h"
  90 #include "human.h"
  91 #include "filemode.h"
  92 #include "inttostr.h"
  93 #include "ls.h"
  94 #include "lstat.h"
  95 #include "mbswidth.h"
  96 #include "obstack.h"
  97 #include "quote.h"
  98 #include "quotearg.h"
  99 #include "same.h"
 100 #include "stat-time.h"
 101 #include "strftime.h"
 102 #include "strverscmp.h"
 103 #include "wcwidth.h"
 104 #include "xstrtol.h"
 105 #include "xreadlink.h"
 106
 107 #define PROGRAM_NAME (ls_mode == LS_LS ? "ls" \
 108                       : (ls_mode == LS_MULTI_COL \
 109                          ? "dir" : "vdir"))
 110
 111 #define AUTHORS "Richard Stallman", "David MacKenzie"
 112
 113 #define obstack_chunk_alloc malloc
 114 #define obstack_chunk_free free
 115
 116 /* Return an int indicating the result of comparing two integers.
 117    Subtracting doesn't always work, due to overflow.  */
 118 #define longdiff(a, b) ((a) < (b) ? -1 : (a) > (b))
 119
 120 #if ! HAVE_STRUCT_STAT_ST_AUTHOR
 121 # define st_author st_uid
 122 #endif
 123
 124 enum filetype
 125   {
 126     unknown,
 127     fifo,
 128     chardev,
 129     directory,
 130     blockdev,
 131     normal,
 132     symbolic_link,
 133     sock,
 134     whiteout,
 135     arg_directory
 136   };
 137
 138 /* Display letters and indicators for each filetype.
 139    Keep these in sync with enum filetype.  */
 140 static char const filetype_letter[] = "?pcdb-lswd";
 141
 142 /* Ensure that filetype and filetype_letter have the same
 143    number of elements.  */
 144 verify (sizeof filetype_letter - 1 == arg_directory + 1);
 145
 146 #define FILETYPE_INDICATORS                             \
 147   {                                                     \
 148     C_ORPHAN, C_FIFO, C_CHR, C_DIR, C_BLK, C_FILE,      \
 149     C_LINK, C_SOCK, C_FILE, C_DIR                       \
 150   }
 151
 152
 153 struct fileinfo
 154   {
 155     /* The file name.  */
 156     char *name;
 157
 158     struct stat stat;
 159     bool stat_ok;
 160
 161     /* For symbolic link, name of the file linked to, otherwise zero.  */
 162     char *linkname;
 163
 164     /* For symbolic link and long listing, st_mode of file linked to, otherwise
 165        zero.  */
 166     mode_t linkmode;
 167
 168     /* For symbolic link and color printing, true if linked-to file
 169        exists, otherwise false.  */
 170     bool linkok;
 171
 172     enum filetype filetype;
 173
 174 #if USE_ACL
 175     /* For long listings, true if the file has an access control list.  */
 176     bool have_acl;
 177 #endif
 178   };
 179
 180 #if USE_ACL
 181 # define FILE_HAS_ACL(F) ((F)->have_acl)
 182 #else
 183 # define FILE_HAS_ACL(F) 0
 184 #endif
 185
 186 #define LEN_STR_PAIR(s) sizeof (s) - 1, s
 187
 188 /* Null is a valid character in a color indicator (think about Epson
 189    printers, for example) so we have to use a length/buffer string
 190    type.  */
 191
 192 struct bin_str
 193   {
 194     size_t len;                 /* Number of bytes */
 195     const char *string;         /* Pointer to the same */
 196   };
 197
 198 char *getgroup ();
 199 char *getuser ();
 200
 201 #if ! HAVE_TCGETPGRP
 202 # define tcgetpgrp(Fd) 0
 203 #endif
 204
 205 static size_t quote_name (FILE *out, const char *name,
 206                           struct quoting_options const *options,
 207                           size_t *width);
 208 static char *make_link_name (char const *name, char const *linkname);
 209 static int decode_switches (int argc, char **argv);
 210 static bool file_ignored (char const *name);
 211 static uintmax_t gobble_file (char const *name, enum filetype type,
 212                               ino_t inode, bool command_line_arg,
 213                               char const *dirname);
 214 static void print_color_indicator (const char *name, mode_t mode, int linkok,
 215                                    bool stat_ok, enum filetype type);
 216 static void put_indicator (const struct bin_str *ind);
 217 static void add_ignore_pattern (const char *pattern);
 218 static void attach (char *dest, const char *dirname, const char *name);
 219 static void clear_files (void);
 220 static void extract_dirs_from_files (char const *dirname,
 221                                      bool command_line_arg);
 222 static void get_link_name (char const *filename, struct fileinfo *f,
 223                            bool command_line_arg);
 224 static void indent (size_t from, size_t to);
 225 static size_t calculate_columns (bool by_columns);
 226 static void print_current_files (void);
 227 static void print_dir (char const *name, char const *realname,
 228                        bool command_line_arg);
 229 static void print_file_name_and_frills (const struct fileinfo *f);
 230 static void print_horizontal (void);
 231 static int format_user_width (uid_t u);
 232 static int format_group_width (gid_t g);
 233 static void print_long_format (const struct fileinfo *f);
 234 static void print_many_per_line (void);
 235 static void print_name_with_quoting (const char *p, mode_t mode,
 236                                      int linkok, bool stat_ok,
 237                                      enum filetype type,
 238                                      struct obstack *stack);
 239 static void prep_non_filename_text (void);
 240 static void print_type_indicator (bool stat_ok, mode_t mode,
 241                                   enum filetype type);
 242 static void print_with_commas (void);
 243 static void queue_directory (char const *name, char const *realname,
 244                              bool command_line_arg);
 245 static void sort_files (void);
 246 static void parse_ls_color (void);
 247 void usage (int status);
 248
 249 /* The name this program was run with.  */
 250 char *program_name;
 251
 252 /* Initial size of hash table.
 253    Most hierarchies are likely to be shallower than this.  */
 254 #define INITIAL_TABLE_SIZE 30
 255
 256 /* The set of `active' directories, from the current command-line argument
 257    to the level in the hierarchy at which files are being listed.
 258    A directory is represented by its device and inode numbers (struct dev_ino).
 259    A directory is added to this set when ls begins listing it or its
 260    entries, and it is removed from the set just after ls has finished
 261    processing it.  This set is used solely to detect loops, e.g., with
 262    mkdir loop; cd loop; ln -s ../loop sub; ls -RL  */
 263 static Hash_table *active_dir_set;
 264
 265 #define LOOP_DETECT (!!active_dir_set)
 266
 267 /* The table of files in the current directory:
 268
 269    `files' points to a vector of `struct fileinfo', one per file.
 270    `nfiles' is the number of elements space has been allocated for.
 271    `files_index' is the number actually in use.  */
 272
 273 /* Address of block containing the files that are described.  */
 274 static struct fileinfo *files;  /* FIXME: rename this to e.g. cwd_file */
 275
 276 /* Length of block that `files' points to, measured in files.  */
 277 static size_t nfiles;  /* FIXME: rename this to e.g. cwd_n_alloc */
 278
 279 /* Index of first unused in `files'.  */
 280 static size_t files_index;  /* FIXME: rename this to e.g. cwd_n_used */
 281
 282 /* When true, in a color listing, color each symlink name according to the
 283    type of file it points to.  Otherwise, color them according to the `ln'
 284    directive in LS_COLORS.  Dangling (orphan) symlinks are treated specially,
 285    regardless.  This is set when `ln=target' appears in LS_COLORS.  */
 286
 287 static bool color_symlink_as_referent;
 288
 289 /* mode of appropriate file for colorization */
 290 #define FILE_OR_LINK_MODE(File) \
 291     ((color_symlink_as_referent & (File)->linkok) \
 292      ? (File)->linkmode : (File)->stat.st_mode)
 293
 294
 295 /* Record of one pending directory waiting to be listed.  */
 296
 297 struct pending
 298   {
 299     char *name;
 300     /* If the directory is actually the file pointed to by a symbolic link we
 301        were told to list, `realname' will contain the name of the symbolic
 302        link, otherwise zero.  */
 303     char *realname;
 304     bool command_line_arg;
 305     struct pending *next;
 306   };
 307
 308 static struct pending *pending_dirs;
 309
 310 /* Current time in seconds and nanoseconds since 1970, updated as
 311    needed when deciding whether a file is recent.  */
 312
 313 static time_t current_time = TYPE_MINIMUM (time_t);
 314 static int current_time_ns = -1;
 315
 316 /* Whether any of the files has an ACL.  This affects the width of the
 317    mode column.  */
 318
 319 #if USE_ACL
 320 static bool any_has_acl;
 321 #else
 322 enum { any_has_acl = false };
 323 #endif
 324
 325 /* The number of columns to use for columns containing inode numbers,
 326    block sizes, link counts, owners, groups, authors, major device
 327    numbers, minor device numbers, and file sizes, respectively.  */
 328
 329 static int inode_number_width;
 330 static int block_size_width;
 331 static int nlink_width;
 332 static int owner_width;
 333 static int group_width;
 334 static int author_width;
 335 static int major_device_number_width;
 336 static int minor_device_number_width;
 337 static int file_size_width;
 338
 339 /* Option flags */
 340
 341 /* long_format for lots of info, one per line.
 342    one_per_line for just names, one per line.
 343    many_per_line for just names, many per line, sorted vertically.
 344    horizontal for just names, many per line, sorted horizontally.
 345    with_commas for just names, many per line, separated by commas.
 346
 347    -l (and other options that imply -l), -1, -C, -x and -m control
 348    this parameter.  */
 349
 350 enum format
 351   {
 352     long_format,                /* -l and other options that imply -l */
 353     one_per_line,               /* -1 */
 354     many_per_line,              /* -C */
 355     horizontal,                 /* -x */
 356     with_commas                 /* -m */
 357   };
 358
 359 static enum format format;
 360
 361 /* `full-iso' uses full ISO-style dates and times.  `long-iso' uses longer
 362    ISO-style time stamps, though shorter than `full-iso'.  `iso' uses shorter
 363    ISO-style time stamps.  `locale' uses locale-dependent time stamps.  */
 364 enum time_style
 365   {
 366     full_iso_time_style,        /* --time-style=full-iso */
 367     long_iso_time_style,        /* --time-style=long-iso */
 368     iso_time_style,             /* --time-style=iso */
 369     locale_time_style           /* --time-style=locale */
 370   };
 371
 372 static char const *const time_style_args[] =
 373 {
 374   "full-iso", "long-iso", "iso", "locale", NULL
 375 };
 376 static enum time_style const time_style_types[] =
 377 {
 378   full_iso_time_style, long_iso_time_style, iso_time_style,
 379   locale_time_style
 380 };
 381 ARGMATCH_VERIFY (time_style_args, time_style_types);
 382
 383 /* Type of time to print or sort by.  Controlled by -c and -u.
 384    The values of each item of this enum are important since they are
 385    used as indices in the sort functions array (see sort_files()).  */
 386
 387 enum time_type
 388   {
 389     time_mtime,                 /* default */
 390     time_ctime,                 /* -c */
 391     time_atime,                 /* -u */
 392     time_numtypes               /* the number of elements of this enum */
 393   };
 394
 395 static enum time_type time_type;
 396
 397 /* The file characteristic to sort by.  Controlled by -t, -S, -U, -X, -v.
 398    The values of each item of this enum are important since they are
 399    used as indices in the sort functions array (see sort_files()).  */
 400
 401 enum sort_type
 402   {
 403     sort_none = -1,             /* -U */
 404     sort_name,                  /* default */
 405     sort_extension,             /* -X */
 406     sort_size,                  /* -S */
 407     sort_version,               /* -v */
 408     sort_time,                  /* -t */
 409     sort_numtypes               /* the number of elements of this enum */
 410   };
 411
 412 static enum sort_type sort_type;
 413
 414 /* Direction of sort.
 415    false means highest first if numeric,
 416    lowest first if alphabetic;
 417    these are the defaults.
 418    true means the opposite order in each case.  -r  */
 419
 420 static bool sort_reverse;
 421
 422 /* True means to display owner information.  -g turns this off.  */
 423
 424 static bool print_owner = true;
 425
 426 /* True means to display author information.  */
 427
 428 static bool print_author;
 429
 430 /* True means to display group information.  -G and -o turn this off.  */
 431
 432 static bool print_group = true;
 433
 434 /* True means print the user and group id's as numbers rather
 435    than as names.  -n  */
 436
 437 static bool numeric_ids;
 438
 439 /* True means mention the size in blocks of each file.  -s  */
 440
 441 static bool print_block_size;
 442
 443 /* Human-readable options for output.  */
 444 static int human_output_opts;
 445
 446 /* The units to use when printing sizes other than file sizes.  */
 447 static uintmax_t output_block_size;
 448
 449 /* Likewise, but for file sizes.  */
 450 static uintmax_t file_output_block_size = 1;
 451
 452 /* Follow the output with a special string.  Using this format,
 453    Emacs' dired mode starts up twice as fast, and can handle all
 454    strange characters in file names.  */
 455 static bool dired;
 456
 457 /* `none' means don't mention the type of files.
 458    `slash' means mention directories only, with a '/'.
 459    `file_type' means mention file types.
 460    `classify' means mention file types and mark executables.
 461
 462    Controlled by -F, -p, and --indicator-style.  */
 463
 464 enum indicator_style
 465   {
 466     none,       /*     --indicator-style=none */
 467     slash,      /* -p, --indicator-style=slash */
 468     file_type,  /*     --indicator-style=file-type */
 469     classify    /* -F, --indicator-style=classify */
 470   };
 471
 472 static enum indicator_style indicator_style;
 473
 474 /* Names of indicator styles.  */
 475 static char const *const indicator_style_args[] =
 476 {
 477   "none", "slash", "file-type", "classify", NULL
 478 };
 479 static enum indicator_style const indicator_style_types[] =
 480 {
 481   none, slash, file_type, classify
 482 };
 483 ARGMATCH_VERIFY (indicator_style_args, indicator_style_types);
 484
 485 /* True means use colors to mark types.  Also define the different
 486    colors as well as the stuff for the LS_COLORS environment variable.
 487    The LS_COLORS variable is now in a termcap-like format.  */
 488
 489 static bool print_with_color;
 490
 491 enum color_type
 492   {
 493     color_never,                /* 0: default or --color=never */
 494     color_always,               /* 1: --color=always */
 495     color_if_tty                /* 2: --color=tty */
 496   };
 497
 498 enum Dereference_symlink
 499   {
 500     DEREF_UNDEFINED = 1,
 501     DEREF_NEVER,
 502     DEREF_COMMAND_LINE_ARGUMENTS,       /* -H */
 503     DEREF_COMMAND_LINE_SYMLINK_TO_DIR,  /* the default, in certain cases */
 504     DEREF_ALWAYS                        /* -L */
 505   };
 506
 507 enum indicator_no
 508   {
 509     C_LEFT, C_RIGHT, C_END, C_NORM, C_FILE, C_DIR, C_LINK, C_FIFO, C_SOCK,
 510     C_BLK, C_CHR, C_MISSING, C_ORPHAN, C_EXEC, C_DOOR, C_SETUID, C_SETGID,
 511     C_STICKY, C_OTHER_WRITABLE, C_STICKY_OTHER_WRITABLE
 512   };
 513
 514 static const char *const indicator_name[]=
 515   {
 516     "lc", "rc", "ec", "no", "fi", "di", "ln", "pi", "so",
 517     "bd", "cd", "mi", "or", "ex", "do", "su", "sg", "st",
 518     "ow", "tw", NULL
 519   };
 520
 521 struct color_ext_type
 522   {
 523     struct bin_str ext;         /* The extension we're looking for */
 524     struct bin_str seq;         /* The sequence to output when we do */
 525     struct color_ext_type *next;        /* Next in list */
 526   };
 527
 528 static struct bin_str color_indicator[] =
 529   {
 530     { LEN_STR_PAIR ("\033[") },         /* lc: Left of color sequence */
 531     { LEN_STR_PAIR ("m") },             /* rc: Right of color sequence */
 532     { 0, NULL },                        /* ec: End color (replaces lc+no+rc) */
 533     { LEN_STR_PAIR ("0") },             /* no: Normal */
 534     { LEN_STR_PAIR ("0") },             /* fi: File: default */
 535     { LEN_STR_PAIR ("01;34") },         /* di: Directory: bright blue */
 536     { LEN_STR_PAIR ("01;36") },         /* ln: Symlink: bright cyan */
 537     { LEN_STR_PAIR ("33") },            /* pi: Pipe: yellow/brown */
 538     { LEN_STR_PAIR ("01;35") },         /* so: Socket: bright magenta */
 539     { LEN_STR_PAIR ("01;33") },         /* bd: Block device: bright yellow */
 540     { LEN_STR_PAIR ("01;33") },         /* cd: Char device: bright yellow */
 541     { 0, NULL },                        /* mi: Missing file: undefined */
 542     { 0, NULL },                        /* or: Orphaned symlink: undefined */
 543     { LEN_STR_PAIR ("01;32") },         /* ex: Executable: bright green */
 544     { LEN_STR_PAIR ("01;35") },         /* do: Door: bright magenta */
 545     { LEN_STR_PAIR ("37;41") },         /* su: setuid: white on red */
 546     { LEN_STR_PAIR ("30;43") },         /* sg: setgid: black on yellow */
 547     { LEN_STR_PAIR ("37;44") },         /* st: sticky: black on blue */
 548     { LEN_STR_PAIR ("34;42") },         /* ow: other-writable: blue on green */
 549     { LEN_STR_PAIR ("30;42") },         /* tw: ow w/ sticky: black on green */
 550   };
 551
 552 /* FIXME: comment  */
 553 static struct color_ext_type *color_ext_list = NULL;
 554
 555 /* Buffer for color sequences */
 556 static char *color_buf;
 557
 558 /* True means to check for orphaned symbolic link, for displaying
 559    colors.  */
 560
 561 static bool check_symlink_color;
 562
 563 /* True means mention the inode number of each file.  -i  */
 564
 565 static bool print_inode;
 566
 567 /* What to do with symbolic links.  Affected by -d, -F, -H, -l (and
 568    other options that imply -l), and -L.  */
 569
 570 static enum Dereference_symlink dereference;
 571
 572 /* True means when a directory is found, display info on its
 573    contents.  -R  */
 574
 575 static bool recursive;
 576
 577 /* True means when an argument is a directory name, display info
 578    on it itself.  -d  */
 579
 580 static bool immediate_dirs;
 581
 582 /* True means that directories are grouped before files. */
 583
 584 static bool directories_first;
 585
 586 /* Which files to ignore.  */
 587
 588 static enum
 589 {
 590   /* Ignore files whose names start with `.', and files specified by
 591      --hide and --ignore.  */
 592   IGNORE_DEFAULT,
 593
 594   /* Ignore `.', `..', and files specified by --ignore.  */
 595   IGNORE_DOT_AND_DOTDOT,
 596
 597   /* Ignore only files specified by --ignore.  */
 598   IGNORE_MINIMAL
 599 } ignore_mode;
 600
 601 /* A linked list of shell-style globbing patterns.  If a non-argument
 602    file name matches any of these patterns, it is ignored.
 603    Controlled by -I.  Multiple -I options accumulate.
 604    The -B option adds `*~' and `.*~' to this list.  */
 605
 606 struct ignore_pattern
 607   {
 608     const char *pattern;
 609     struct ignore_pattern *next;
 610   };
 611
 612 static struct ignore_pattern *ignore_patterns;
 613
 614 /* Similar to IGNORE_PATTERNS, except that -a or -A causes this
 615    variable itself to be ignored.  */
 616 static struct ignore_pattern *hide_patterns;
 617
 618 /* True means output nongraphic chars in file names as `?'.
 619    (-q, --hide-control-chars)
 620    qmark_funny_chars and the quoting style (-Q, --quoting-style=WORD) are
 621    independent.  The algorithm is: first, obey the quoting style to get a
 622    string representing the file name;  then, if qmark_funny_chars is set,
 623    replace all nonprintable chars in that string with `?'.  It's necessary
 624    to replace nonprintable chars even in quoted strings, because we don't
 625    want to mess up the terminal if control chars get sent to it, and some
 626    quoting methods pass through control chars as-is.  */
 627 static bool qmark_funny_chars;
 628
 629 /* Quoting options for file and dir name output.  */
 630
 631 static struct quoting_options *filename_quoting_options;
 632 static struct quoting_options *dirname_quoting_options;
 633
 634 /* The number of chars per hardware tab stop.  Setting this to zero
 635    inhibits the use of TAB characters for separating columns.  -T */
 636 static size_t tabsize;
 637
 638 /* True means print each directory name before listing it.  */
 639
 640 static bool print_dir_name;
 641
 642 /* The line length to use for breaking lines in many-per-line format.
 643    Can be set with -w.  */
 644
 645 static size_t line_length;
 646
 647 /* If true, the file listing format requires that stat be called on
 648    each file.  */
 649
 650 static bool format_needs_stat;
 651
 652 /* Similar to `format_needs_stat', but set if only the file type is
 653    needed.  */
 654
 655 static bool format_needs_type;
 656
 657 /* An arbitrary limit on the number of bytes in a printed time stamp.
 658    This is set to a relatively small value to avoid the need to worry
 659    about denial-of-service attacks on servers that run "ls" on behalf
 660    of remote clients.  1000 bytes should be enough for any practical
 661    time stamp format.  */
 662
 663 enum { TIME_STAMP_LEN_MAXIMUM = MAX (1000, INT_STRLEN_BOUND (time_t)) };
 664
 665 /* strftime formats for non-recent and recent files, respectively, in
 666    -l output.  */
 667
 668 static char const *long_time_format[2] =
 669   {
 670     /* strftime format for non-recent files (older than 6 months), in
 671        -l output.  This should contain the year, month and day (at
 672        least), in an order that is understood by people in your
 673        locale's territory.  Please try to keep the number of used
 674        screen columns small, because many people work in windows with
 675        only 80 columns.  But make this as wide as the other string
 676        below, for recent files.  */
 677     N_("%b %e  %Y"),
 678     /* strftime format for recent files (younger than 6 months), in -l
 679        output.  This should contain the month, day and time (at
 680        least), in an order that is understood by people in your
 681        locale's territory.  Please try to keep the number of used
 682        screen columns small, because many people work in windows with
 683        only 80 columns.  But make this as wide as the other string
 684        above, for non-recent files.  */
 685     N_("%b %e %H:%M")
 686   };
 687
 688 /* The set of signals that are caught.  */
 689
 690 static sigset_t caught_signals;
 691
 692 /* If nonzero, the value of the pending fatal signal.  */
 693
 694 static sig_atomic_t volatile interrupt_signal;
 695
 696 /* A count of the number of pending stop signals that have been received.  */
 697
 698 static sig_atomic_t volatile stop_signal_count;
 699
 700 /* Desired exit status.  */
 701
 702 static int exit_status;
 703
 704 /* Exit statuses.  */
 705 enum
 706   {
 707     /* "ls" had a minor problem (e.g., it could not stat a directory
 708        entry).  */
 709     LS_MINOR_PROBLEM = 1,
 710
 711     /* "ls" had more serious trouble.  */
 712     LS_FAILURE = 2
 713   };
 714
 715 /* For long options that have no equivalent short option, use a
 716    non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
 717 enum
 718 {
 719   AUTHOR_OPTION = CHAR_MAX + 1,
 720   BLOCK_SIZE_OPTION,
 721   COLOR_OPTION,
 722   DEREFERENCE_COMMAND_LINE_SYMLINK_TO_DIR_OPTION,
 723   FILE_TYPE_INDICATOR_OPTION,
 724   FORMAT_OPTION,
 725   FULL_TIME_OPTION,
 726   GROUP_DIRECTORIES_FIRST_OPTION,
 727   HIDE_OPTION,
 728   INDICATOR_STYLE_OPTION,
 729
 730   /* FIXME: --kilobytes is deprecated (but not -k); remove in late 2006 */
 731   KILOBYTES_LONG_OPTION,
 732
 733   QUOTING_STYLE_OPTION,
 734   SHOW_CONTROL_CHARS_OPTION,
 735   SI_OPTION,
 736   SORT_OPTION,
 737   TIME_OPTION,
 738   TIME_STYLE_OPTION
 739 };
 740
 741 static struct option const long_options[] =
 742 {
 743   {"all", no_argument, NULL, 'a'},
 744   {"escape", no_argument, NULL, 'b'},
 745   {"directory", no_argument, NULL, 'd'},
 746   {"dired", no_argument, NULL, 'D'},
 747   {"full-time", no_argument, NULL, FULL_TIME_OPTION},
 748   {"group-directories-first", no_argument, NULL,
 749    GROUP_DIRECTORIES_FIRST_OPTION},
 750   {"human-readable", no_argument, NULL, 'h'},
 751   {"inode", no_argument, NULL, 'i'},
 752   {"kilobytes", no_argument, NULL, KILOBYTES_LONG_OPTION},
 753   {"numeric-uid-gid", no_argument, NULL, 'n'},
 754   {"no-group", no_argument, NULL, 'G'},
 755   {"hide-control-chars", no_argument, NULL, 'q'},
 756   {"reverse", no_argument, NULL, 'r'},
 757   {"size", no_argument, NULL, 's'},
 758   {"width", required_argument, NULL, 'w'},
 759   {"almost-all", no_argument, NULL, 'A'},
 760   {"ignore-backups", no_argument, NULL, 'B'},
 761   {"classify", no_argument, NULL, 'F'},
 762   {"file-type", no_argument, NULL, FILE_TYPE_INDICATOR_OPTION},
 763   {"si", no_argument, NULL, SI_OPTION},
 764   {"dereference-command-line", no_argument, NULL, 'H'},
 765   {"dereference-command-line-symlink-to-dir", no_argument, NULL,
 766    DEREFERENCE_COMMAND_LINE_SYMLINK_TO_DIR_OPTION},
 767   {"hide", required_argument, NULL, HIDE_OPTION},
 768   {"ignore", required_argument, NULL, 'I'},
 769   {"indicator-style", required_argument, NULL, INDICATOR_STYLE_OPTION},
 770   {"dereference", no_argument, NULL, 'L'},
 771   {"literal", no_argument, NULL, 'N'},
 772   {"quote-name", no_argument, NULL, 'Q'},
 773   {"quoting-style", required_argument, NULL, QUOTING_STYLE_OPTION},
 774   {"recursive", no_argument, NULL, 'R'},
 775   {"format", required_argument, NULL, FORMAT_OPTION},
 776   {"show-control-chars", no_argument, NULL, SHOW_CONTROL_CHARS_OPTION},
 777   {"sort", required_argument, NULL, SORT_OPTION},
 778   {"tabsize", required_argument, NULL, 'T'},
 779   {"time", required_argument, NULL, TIME_OPTION},
 780   {"time-style", required_argument, NULL, TIME_STYLE_OPTION},
 781   {"color", optional_argument, NULL, COLOR_OPTION},
 782   {"block-size", required_argument, NULL, BLOCK_SIZE_OPTION},
 783   {"author", no_argument, NULL, AUTHOR_OPTION},
 784   {GETOPT_HELP_OPTION_DECL},
 785   {GETOPT_VERSION_OPTION_DECL},
 786   {NULL, 0, NULL, 0}
 787 };
 788
 789 static char const *const format_args[] =
 790 {
 791   "verbose", "long", "commas", "horizontal", "across",
 792   "vertical", "single-column", NULL
 793 };
 794 static enum format const format_types[] =
 795 {
 796   long_format, long_format, with_commas, horizontal, horizontal,
 797   many_per_line, one_per_line
 798 };
 799 ARGMATCH_VERIFY (format_args, format_types);
 800
 801 static char const *const sort_args[] =
 802 {
 803   "none", "time", "size", "extension", "version", NULL
 804 };
 805 static enum sort_type const sort_types[] =
 806 {
 807   sort_none, sort_time, sort_size, sort_extension, sort_version
 808 };
 809 ARGMATCH_VERIFY (sort_args, sort_types);
 810
 811 static char const *const time_args[] =
 812 {
 813   "atime", "access", "use", "ctime", "status", NULL
 814 };
 815 static enum time_type const time_types[] =
 816 {
 817   time_atime, time_atime, time_atime, time_ctime, time_ctime
 818 };
 819 ARGMATCH_VERIFY (time_args, time_types);
 820
 821 static char const *const color_args[] =
 822 {
 823   /* force and none are for compatibility with another color-ls version */
 824   "always", "yes", "force",
 825   "never", "no", "none",
 826   "auto", "tty", "if-tty", NULL
 827 };
 828 static enum color_type const color_types[] =
 829 {
 830   color_always, color_always, color_always,
 831   color_never, color_never, color_never,
 832   color_if_tty, color_if_tty, color_if_tty
 833 };
 834 ARGMATCH_VERIFY (color_args, color_types);
 835
 836 /* Information about filling a column.  */
 837 struct column_info
 838 {
 839   bool valid_len;
 840   size_t line_len;
 841   size_t *col_arr;
 842 };
 843
 844 /* Array with information about column filledness.  */
 845 static struct column_info *column_info;
 846
 847 /* Maximum number of columns ever possible for this display.  */
 848 static size_t max_idx;
 849
 850 /* The minimum width of a column is 3: 1 character for the name and 2
 851    for the separating white space.  */
 852 #define MIN_COLUMN_WIDTH        3
 853
 854
 855 /* This zero-based index is used solely with the --dired option.
 856    When that option is in effect, this counter is incremented for each
 857    byte of output generated by this program so that the beginning
 858    and ending indices (in that output) of every file name can be recorded
 859    and later output themselves.  */
 860 static size_t dired_pos;
 861
 862 #define DIRED_PUTCHAR(c) do {putchar ((c)); ++dired_pos;} while (0)
 863
 864 /* Write S to STREAM and increment DIRED_POS by S_LEN.  */
 865 #define DIRED_FPUTS(s, stream, s_len) \
 866     do {fputs (s, stream); dired_pos += s_len;} while (0)
 867
 868 /* Like DIRED_FPUTS, but for use when S is a literal string.  */
 869 #define DIRED_FPUTS_LITERAL(s, stream) \
 870     do {fputs (s, stream); dired_pos += sizeof (s) - 1;} while (0)
 871
 872 #define DIRED_INDENT()                                                  \
 873     do                                                                  \
 874       {                                                                 \
 875         if (dired)                                                      \
 876           DIRED_FPUTS_LITERAL ("  ", stdout);                           \
 877       }                                                                 \
 878     while (0)
 879
 880 /* With --dired, store pairs of beginning and ending indices of filenames.  */
 881 static struct obstack dired_obstack;
 882
 883 /* With --dired, store pairs of beginning and ending indices of any
 884    directory names that appear as headers (just before `total' line)
 885    for lists of directory entries.  Such directory names are seen when
 886    listing hierarchies using -R and when a directory is listed with at
 887    least one other command line argument.  */
 888 static struct obstack subdired_obstack;
 889
 890 /* Save the current index on the specified obstack, OBS.  */
 891 #define PUSH_CURRENT_DIRED_POS(obs)                                     \
 892   do                                                                    \
 893     {                                                                   \
 894       if (dired)                                                        \
 895         obstack_grow (obs, &dired_pos, sizeof (dired_pos));             \
 896     }                                                                   \
 897   while (0)
 898
 899 /* With -R, this stack is used to help detect directory cycles.
 900    The device/inode pairs on this stack mirror the pairs in the
 901    active_dir_set hash table.  */
 902 static struct obstack dev_ino_obstack;
 903
 904 /* Push a pair onto the device/inode stack.  */
 905 #define DEV_INO_PUSH(Dev, Ino)                                          \
 906   do                                                                    \
 907     {                                                                   \
 908       struct dev_ino *di;                                               \
 909       obstack_blank (&dev_ino_obstack, sizeof (struct dev_ino));        \
 910       di = -1 + (struct dev_ino *) obstack_next_free (&dev_ino_obstack); \
 911       di->st_dev = (Dev);                                               \
 912       di->st_ino = (Ino);                                               \
 913     }                                                                   \
 914   while (0)
 915
 916 /* Pop a dev/ino struct off the global dev_ino_obstack
 917    and return that struct.  */
 918 static struct dev_ino
 919 dev_ino_pop (void)
 920 {
 921   assert (sizeof (struct dev_ino) <= obstack_object_size (&dev_ino_obstack));
 922   obstack_blank (&dev_ino_obstack, -(int) (sizeof (struct dev_ino)));
 923   return *(struct dev_ino *) obstack_next_free (&dev_ino_obstack);
 924 }
 925
 926 #define ASSERT_MATCHING_DEV_INO(Name, Di)       \
 927   do                                            \
 928     {                                           \
 929       struct stat sb;                           \
 930       assert (Name);                            \
 931       assert (0 <= stat (Name, &sb));           \
 932       assert (sb.st_dev == Di.st_dev);          \
 933       assert (sb.st_ino == Di.st_ino);          \
 934     }                                           \
 935   while (0)
 936
 937
 938 /* Write to standard output PREFIX, followed by the quoting style and
 939    a space-separated list of the integers stored in OS all on one line.  */
 940
 941 static void
 942 dired_dump_obstack (const char *prefix, struct obstack *os)
 943 {
 944   size_t n_pos;
 945
 946   n_pos = obstack_object_size (os) / sizeof (dired_pos);
 947   if (n_pos > 0)
 948     {
 949       size_t i;
 950       size_t *pos;
 951
 952       pos = (size_t *) obstack_finish (os);
 953       fputs (prefix, stdout);
 954       for (i = 0; i < n_pos; i++)
 955         printf (" %lu", (unsigned long int) pos[i]);
 956       putchar ('\n');
 957     }
 958 }
 959
 960 static size_t
 961 dev_ino_hash (void const *x, size_t table_size)
 962 {
 963   struct dev_ino const *p = x;
 964   return (uintmax_t) p->st_ino % table_size;
 965 }
 966
 967 static bool
 968 dev_ino_compare (void const *x, void const *y)
 969 {
 970   struct dev_ino const *a = x;
 971   struct dev_ino const *b = y;
 972   return SAME_INODE (*a, *b) ? true : false;
 973 }
 974
 975 static void
 976 dev_ino_free (void *x)
 977 {
 978   free (x);
 979 }
 980
 981 /* Add the device/inode pair (P->st_dev/P->st_ino) to the set of
 982    active directories.  Return true if there is already a matching
 983    entry in the table.  */
 984
 985 static bool
 986 visit_dir (dev_t dev, ino_t ino)
 987 {
 988   struct dev_ino *ent;
 989   struct dev_ino *ent_from_table;
 990   bool found_match;
 991
 992   ent = xmalloc (sizeof *ent);
 993   ent->st_ino = ino;
 994   ent->st_dev = dev;
 995
 996   /* Attempt to insert this entry into the table.  */
 997   ent_from_table = hash_insert (active_dir_set, ent);
 998
 999   if (ent_from_table == NULL)
1000     {
1001       /* Insertion failed due to lack of memory.  */
1002       xalloc_die ();
1003     }
1004
1005   found_match = (ent_from_table != ent);
1006
1007   if (found_match)
1008     {
1009       /* ent was not inserted, so free it.  */
1010       free (ent);
1011     }
1012
1013   return found_match;
1014 }
1015
1016 static void
1017 free_pending_ent (struct pending *p)
1018 {
1019   free (p->name);
1020   free (p->realname);
1021   free (p);
1022 }
1023
1024 static bool
1025 is_colored (enum indicator_no type)
1026 {
1027   size_t len = color_indicator[type].len;
1028   char const *s = color_indicator[type].string;
1029   return ! (len == 0
1030             || (len == 1 && strncmp (s, "0", 1) == 0)
1031             || (len == 2 && strncmp (s, "00", 2) == 0));
1032 }
1033
1034 static void
1035 restore_default_color (void)
1036 {
1037   put_indicator (&color_indicator[C_LEFT]);
1038   put_indicator (&color_indicator[C_RIGHT]);
1039 }
1040
1041 /* An ordinary signal was received; arrange for the program to exit.  */
1042
1043 static void
1044 sighandler (int sig)
1045 {
1046   if (! SA_NOCLDSTOP)
1047     signal (sig, SIG_IGN);
1048   if (! interrupt_signal)
1049     interrupt_signal = sig;
1050 }
1051
1052 /* A SIGTSTP was received; arrange for the program to suspend itself.  */
1053
1054 static void
1055 stophandler (int sig)
1056 {
1057   if (! SA_NOCLDSTOP)
1058     signal (sig, stophandler);
1059   if (! interrupt_signal)
1060     stop_signal_count++;
1061 }
1062
1063 /* Process any pending signals.  If signals are caught, this function
1064    should be called periodically.  Ideally there should never be an
1065    unbounded amount of time when signals are not being processed.
1066    Signal handling can restore the default colors, so callers must
1067    immediately change colors after invoking this function.  */
1068
1069 static void
1070 process_signals (void)
1071 {
1072   while (interrupt_signal | stop_signal_count)
1073     {
1074       int sig;
1075       int stops;
1076       sigset_t oldset;
1077
1078       restore_default_color ();
1079       fflush (stdout);
1080
1081       sigprocmask (SIG_BLOCK, &caught_signals, &oldset);
1082
1083       /* Reload interrupt_signal and stop_signal_count, in case a new
1084          signal was handled before sigprocmask took effect.  */
1085       sig = interrupt_signal;
1086       stops = stop_signal_count;
1087
1088       /* SIGTSTP is special, since the application can receive that signal
1089          more than once.  In this case, don't set the signal handler to the
1090          default.  Instead, just raise the uncatchable SIGSTOP.  */
1091       if (stops)
1092         {
1093           stop_signal_count = stops - 1;
1094           sig = SIGSTOP;
1095         }
1096       else
1097         signal (sig, SIG_DFL);
1098
1099       /* Exit or suspend the program.  */
1100       raise (sig);
1101       sigprocmask (SIG_SETMASK, &oldset, NULL);
1102
1103       /* If execution reaches here, then the program has been
1104          continued (after being suspended).  */
1105     }
1106 }
1107
1108 int
1109 main (int argc, char **argv)
1110 {
1111   int i;
1112   struct pending *thispend;
1113   int n_files;
1114
1115   /* The signals that are trapped, and the number of such signals.  */
1116   static int const sig[] = { SIGHUP, SIGINT, SIGPIPE,
1117                              SIGQUIT, SIGTERM, SIGTSTP };
1118   enum { nsigs = sizeof sig / sizeof sig[0] };
1119
1120 #if ! SA_NOCLDSTOP
1121   bool caught_sig[nsigs];
1122 #endif
1123
1124   initialize_main (&argc, &argv);
1125   program_name = argv[0];
1126   setlocale (LC_ALL, "");
1127   bindtextdomain (PACKAGE, LOCALEDIR);
1128   textdomain (PACKAGE);
1129
1130   initialize_exit_failure (LS_FAILURE);
1131   atexit (close_stdout);
1132
1133 #define N_ENTRIES(Array) (sizeof Array / sizeof *(Array))
1134   assert (N_ENTRIES (color_indicator) + 1 == N_ENTRIES (indicator_name));
1135
1136   exit_status = EXIT_SUCCESS;
1137   print_dir_name = true;
1138   pending_dirs = NULL;
1139
1140   i = decode_switches (argc, argv);
1141
1142   if (print_with_color)
1143     parse_ls_color ();
1144
1145   /* Test print_with_color again, because the call to parse_ls_color
1146      may have just reset it -- e.g., if LS_COLORS is invalid.  */
1147   if (print_with_color)
1148     {
1149       /* Avoid following symbolic links when possible.  */
1150       if (is_colored (C_ORPHAN)
1151           || is_colored (C_EXEC)
1152           || (is_colored (C_MISSING) && format == long_format))
1153         check_symlink_color = true;
1154
1155       /* If the standard output is a controlling terminal, watch out
1156          for signals, so that the colors can be restored to the
1157          default state if "ls" is suspended or interrupted.  */
1158
1159       if (0 <= tcgetpgrp (STDOUT_FILENO))
1160         {
1161           int j;
1162 #if SA_NOCLDSTOP
1163           struct sigaction act;
1164
1165           sigemptyset (&caught_signals);
1166           for (j = 0; j < nsigs; j++)
1167             {
1168               sigaction (sig[j], NULL, &act);
1169               if (act.sa_handler != SIG_IGN)
1170                 sigaddset (&caught_signals, sig[j]);
1171             }
1172
1173           act.sa_mask = caught_signals;
1174           act.sa_flags = SA_RESTART;
1175
1176           for (j = 0; j < nsigs; j++)
1177             if (sigismember (&caught_signals, sig[j]))
1178               {
1179                 act.sa_handler = sig[j] == SIGTSTP ? stophandler : sighandler;
1180                 sigaction (sig[j], &act, NULL);
1181               }
1182 #else
1183           for (j = 0; j < nsigs; j++)
1184             {
1185               caught_sig[j] = (signal (sig[j], SIG_IGN) != SIG_IGN);
1186               if (caught_sig[j])
1187                 {
1188                   signal (sig[j], sig[j] == SIGTSTP ? stophandler : sighandler);
1189                   siginterrupt (sig[j], 0);
1190                 }
1191             }
1192 #endif
1193         }
1194
1195       prep_non_filename_text ();
1196     }
1197
1198   if (dereference == DEREF_UNDEFINED)
1199     dereference = ((immediate_dirs
1200                     || indicator_style == classify
1201                     || format == long_format)
1202                    ? DEREF_NEVER
1203                    : DEREF_COMMAND_LINE_SYMLINK_TO_DIR);
1204
1205   /* When using -R, initialize a data structure we'll use to
1206      detect any directory cycles.  */
1207   if (recursive)
1208     {
1209       active_dir_set = hash_initialize (INITIAL_TABLE_SIZE, NULL,
1210                                         dev_ino_hash,
1211                                         dev_ino_compare,
1212                                         dev_ino_free);
1213       if (active_dir_set == NULL)
1214         xalloc_die ();
1215
1216       obstack_init (&dev_ino_obstack);
1217     }
1218
1219   format_needs_stat = sort_type == sort_time || sort_type == sort_size
1220     || format == long_format
1221     || print_block_size;
1222   format_needs_type = (! format_needs_stat
1223                        && (recursive
1224                            || print_with_color
1225                            || indicator_style != none
1226                            || directories_first));
1227
1228   if (dired)
1229     {
1230       obstack_init (&dired_obstack);
1231       obstack_init (&subdired_obstack);
1232     }
1233
1234   nfiles = 100;
1235   files = xnmalloc (nfiles, sizeof *files);
1236   files_index = 0;
1237
1238   clear_files ();
1239
1240   n_files = argc - i;
1241
1242   if (n_files <= 0)
1243     {
1244       if (immediate_dirs)
1245         gobble_file (".", directory, NOT_AN_INODE_NUMBER, true, "");
1246       else
1247         queue_directory (".", NULL, true);
1248     }
1249   else
1250     do
1251       gobble_file (argv[i++], unknown, NOT_AN_INODE_NUMBER, true, "");
1252     while (i < argc);
1253
1254   if (files_index)
1255     {
1256       sort_files ();
1257       if (!immediate_dirs)
1258         extract_dirs_from_files (NULL, true);
1259       /* `files_index' might be zero now.  */
1260     }
1261
1262   /* In the following if/else blocks, it is sufficient to test `pending_dirs'
1263      (and not pending_dirs->name) because there may be no markers in the queue
1264      at this point.  A marker may be enqueued when extract_dirs_from_files is
1265      called with a non-empty string or via print_dir.  */
1266   if (files_index)
1267     {
1268       print_current_files ();
1269       if (pending_dirs)
1270         DIRED_PUTCHAR ('\n');
1271     }
1272   else if (n_files <= 1 && pending_dirs && pending_dirs->next == 0)
1273     print_dir_name = false;
1274
1275   while (pending_dirs)
1276     {
1277       thispend = pending_dirs;
1278       pending_dirs = pending_dirs->next;
1279
1280       if (LOOP_DETECT)
1281         {
1282           if (thispend->name == NULL)
1283             {
1284               /* thispend->name == NULL means this is a marker entry
1285                  indicating we've finished processing the directory.
1286                  Use its dev/ino numbers to remove the corresponding
1287                  entry from the active_dir_set hash table.  */
1288               struct dev_ino di = dev_ino_pop ();
1289               struct dev_ino *found = hash_delete (active_dir_set, &di);
1290               /* ASSERT_MATCHING_DEV_INO (thispend->realname, di); */
1291               assert (found);
1292               dev_ino_free (found);
1293               free_pending_ent (thispend);
1294               continue;
1295             }
1296         }
1297
1298       print_dir (thispend->name, thispend->realname,
1299                  thispend->command_line_arg);
1300
1301       free_pending_ent (thispend);
1302       print_dir_name = true;
1303     }
1304
1305   if (print_with_color)
1306     {
1307       int j;
1308
1309       restore_default_color ();
1310       fflush (stdout);
1311
1312       /* Restore the default signal handling.  */
1313 #if SA_NOCLDSTOP
1314       for (j = 0; j < nsigs; j++)
1315         if (sigismember (&caught_signals, sig[j]))
1316           signal (sig[j], SIG_DFL);
1317 #else
1318       for (j = 0; j < nsigs; j++)
1319         if (caught_sig[j])
1320           signal (sig[j], SIG_DFL);
1321 #endif
1322
1323       /* Act on any signals that arrived before the default was restored.
1324          This can process signals out of order, but there doesn't seem to
1325          be an easy way to do them in order, and the order isn't that
1326          important anyway.  */
1327       for (j = stop_signal_count; j; j--)
1328         raise (SIGSTOP);
1329       j = interrupt_signal;
1330       if (j)
1331         raise (j);
1332     }
1333
1334   if (dired)
1335     {
1336       /* No need to free these since we're about to exit.  */
1337       dired_dump_obstack ("//DIRED//", &dired_obstack);
1338       dired_dump_obstack ("//SUBDIRED//", &subdired_obstack);
1339       printf ("//DIRED-OPTIONS// --quoting-style=%s\n",
1340               quoting_style_args[get_quoting_style (filename_quoting_options)]);
1341     }
1342
1343   if (LOOP_DETECT)
1344     {
1345       assert (hash_get_n_entries (active_dir_set) == 0);
1346       hash_free (active_dir_set);
1347     }
1348
1349   exit (exit_status);
1350 }
1351
1352 /* Set all the option flags according to the switches specified.
1353    Return the index of the first non-option argument.  */
1354
1355 static int
1356 decode_switches (int argc, char **argv)
1357 {
1358   int c;
1359   char *time_style_option = NULL;
1360
1361   /* Record whether there is an option specifying sort type.  */
1362   bool sort_type_specified = false;
1363
1364   qmark_funny_chars = false;
1365
1366   /* initialize all switches to default settings */
1367
1368   switch (ls_mode)
1369     {
1370     case LS_MULTI_COL:
1371       /* This is for the `dir' program.  */
1372       format = many_per_line;
1373       set_quoting_style (NULL, escape_quoting_style);
1374       break;
1375
1376     case LS_LONG_FORMAT:
1377       /* This is for the `vdir' program.  */
1378       format = long_format;
1379       set_quoting_style (NULL, escape_quoting_style);
1380       break;
1381
1382     case LS_LS:
1383       /* This is for the `ls' program.  */
1384       if (isatty (STDOUT_FILENO))
1385         {
1386           format = many_per_line;
1387           /* See description of qmark_funny_chars, above.  */
1388           qmark_funny_chars = true;
1389         }
1390       else
1391         {
1392           format = one_per_line;
1393           qmark_funny_chars = false;
1394         }
1395       break;
1396
1397     default:
1398       abort ();
1399     }
1400
1401   time_type = time_mtime;
1402   sort_type = sort_name;
1403   sort_reverse = false;
1404   numeric_ids = false;
1405   print_block_size = false;
1406   indicator_style = none;
1407   print_inode = false;
1408   dereference = DEREF_UNDEFINED;
1409   recursive = false;
1410   immediate_dirs = false;
1411   ignore_mode = IGNORE_DEFAULT;
1412   ignore_patterns = NULL;
1413   hide_patterns = NULL;
1414
1415   /* FIXME: put this in a function.  */
1416   {
1417     char const *q_style = getenv ("QUOTING_STYLE");
1418     if (q_style)
1419       {
1420         int i = ARGMATCH (q_style, quoting_style_args, quoting_style_vals);
1421         if (0 <= i)
1422           set_quoting_style (NULL, quoting_style_vals[i]);
1423         else
1424           error (0, 0,
1425          _("ignoring invalid value of environment variable QUOTING_STYLE: %s"),
1426                  quotearg (q_style));
1427       }
1428   }
1429
1430   {
1431     char const *ls_block_size = getenv ("LS_BLOCK_SIZE");
1432     human_output_opts = human_options (ls_block_size, false,
1433                                        &output_block_size);
1434     if (ls_block_size || getenv ("BLOCK_SIZE"))
1435       file_output_block_size = output_block_size;
1436   }
1437
1438   line_length = 80;
1439   {
1440     char const *p = getenv ("COLUMNS");
1441     if (p && *p)
1442       {
1443         unsigned long int tmp_ulong;
1444         if (xstrtoul (p, NULL, 0, &tmp_ulong, NULL) == LONGINT_OK
1445             && 0 < tmp_ulong && tmp_ulong <= SIZE_MAX)
1446           {
1447             line_length = tmp_ulong;
1448           }
1449         else
1450           {
1451             error (0, 0,
1452                _("ignoring invalid width in environment variable COLUMNS: %s"),
1453                    quotearg (p));
1454           }
1455       }
1456   }
1457
1458 #ifdef TIOCGWINSZ
1459   {
1460     struct winsize ws;
1461
1462     if (ioctl (STDOUT_FILENO, TIOCGWINSZ, &ws) != -1
1463         && 0 < ws.ws_col && ws.ws_col == (size_t) ws.ws_col)
1464       line_length = ws.ws_col;
1465   }
1466 #endif
1467
1468   {
1469     char const *p = getenv ("TABSIZE");
1470     tabsize = 8;
1471     if (p)
1472       {
1473         unsigned long int tmp_ulong;
1474         if (xstrtoul (p, NULL, 0, &tmp_ulong, NULL) == LONGINT_OK
1475             && tmp_ulong <= SIZE_MAX)
1476           {
1477             tabsize = tmp_ulong;
1478           }
1479         else
1480           {
1481             error (0, 0,
1482              _("ignoring invalid tab size in environment variable TABSIZE: %s"),
1483                    quotearg (p));
1484           }
1485       }
1486   }
1487
1488   while ((c = getopt_long (argc, argv,
1489                            "abcdfghiklmnopqrstuvw:xABCDFGHI:LNQRST:UX1",
1490                            long_options, NULL)) != -1)
1491     {
1492       switch (c)
1493         {
1494         case 'a':
1495           ignore_mode = IGNORE_MINIMAL;
1496           break;
1497
1498         case 'b':
1499           set_quoting_style (NULL, escape_quoting_style);
1500           break;
1501
1502         case 'c':
1503           time_type = time_ctime;
1504           break;
1505
1506         case 'd':
1507           immediate_dirs = true;
1508           break;
1509
1510         case 'f':
1511           /* Same as enabling -a -U and disabling -l -s.  */
1512           ignore_mode = IGNORE_MINIMAL;
1513           sort_type = sort_none;
1514           sort_type_specified = true;
1515           /* disable -l */
1516           if (format == long_format)
1517             format = (isatty (STDOUT_FILENO) ? many_per_line : one_per_line);
1518           print_block_size = false;     /* disable -s */
1519           print_with_color = false;     /* disable --color */
1520           break;
1521
1522         case FILE_TYPE_INDICATOR_OPTION: /* --file-type */
1523           indicator_style = file_type;
1524           break;
1525
1526         case 'g':
1527           format = long_format;
1528           print_owner = false;
1529           break;
1530
1531         case 'h':
1532           human_output_opts = human_autoscale | human_SI | human_base_1024;
1533           file_output_block_size = output_block_size = 1;
1534           break;
1535
1536         case 'i':
1537           print_inode = true;
1538           break;
1539
1540         case KILOBYTES_LONG_OPTION:
1541           error (0, 0,
1542                  _("the --kilobytes option is deprecated; use -k instead"));
1543           /* fall through */
1544         case 'k':
1545           human_output_opts = 0;
1546           file_output_block_size = output_block_size = 1024;
1547           break;
1548
1549         case 'l':
1550           format = long_format;
1551           break;
1552
1553         case 'm':
1554           format = with_commas;
1555           break;
1556
1557         case 'n':
1558           numeric_ids = true;
1559           format = long_format;
1560           break;
1561
1562         case 'o':  /* Just like -l, but don't display group info.  */
1563           format = long_format;
1564           print_group = false;
1565           break;
1566
1567         case 'p':
1568           indicator_style = slash;
1569           break;
1570
1571         case 'q':
1572           qmark_funny_chars = true;
1573           break;
1574
1575         case 'r':
1576           sort_reverse = true;
1577           break;
1578
1579         case 's':
1580           print_block_size = true;
1581           break;
1582
1583         case 't':
1584           sort_type = sort_time;
1585           sort_type_specified = true;
1586           break;
1587
1588         case 'u':
1589           time_type = time_atime;
1590           break;
1591
1592         case 'v':
1593           sort_type = sort_version;
1594           sort_type_specified = true;
1595           break;
1596
1597         case 'w':
1598           {
1599             unsigned long int tmp_ulong;
1600             if (xstrtoul (optarg, NULL, 0, &tmp_ulong, NULL) != LONGINT_OK
1601                 || ! (0 < tmp_ulong && tmp_ulong <= SIZE_MAX))
1602               error (LS_FAILURE, 0, _("invalid line width: %s"),
1603                      quotearg (optarg));
1604             line_length = tmp_ulong;
1605             break;
1606           }
1607
1608         case 'x':
1609           format = horizontal;
1610           break;
1611
1612         case 'A':
1613           if (ignore_mode == IGNORE_DEFAULT)
1614             ignore_mode = IGNORE_DOT_AND_DOTDOT;
1615           break;
1616
1617         case 'B':
1618           add_ignore_pattern ("*~");
1619           add_ignore_pattern (".*~");
1620           break;
1621
1622         case 'C':
1623           format = many_per_line;
1624           break;
1625
1626         case 'D':
1627           dired = true;
1628           break;
1629
1630         case 'F':
1631           indicator_style = classify;
1632           break;
1633
1634         case 'G':               /* inhibit display of group info */
1635           print_group = false;
1636           break;
1637
1638         case 'H':
1639           dereference = DEREF_COMMAND_LINE_ARGUMENTS;
1640           break;
1641
1642         case DEREFERENCE_COMMAND_LINE_SYMLINK_TO_DIR_OPTION:
1643           dereference = DEREF_COMMAND_LINE_SYMLINK_TO_DIR;
1644           break;
1645
1646         case 'I':
1647           add_ignore_pattern (optarg);
1648           break;
1649
1650         case 'L':
1651           dereference = DEREF_ALWAYS;
1652           break;
1653
1654         case 'N':
1655           set_quoting_style (NULL, literal_quoting_style);
1656           break;
1657
1658         case 'Q':
1659           set_quoting_style (NULL, c_quoting_style);
1660           break;
1661
1662         case 'R':
1663           recursive = true;
1664           break;
1665
1666         case 'S':
1667           sort_type = sort_size;
1668           sort_type_specified = true;
1669           break;
1670
1671         case 'T':
1672           {
1673             unsigned long int tmp_ulong;
1674             if (xstrtoul (optarg, NULL, 0, &tmp_ulong, NULL) != LONGINT_OK
1675                 || SIZE_MAX < tmp_ulong)
1676               error (LS_FAILURE, 0, _("invalid tab size: %s"),
1677                      quotearg (optarg));
1678             tabsize = tmp_ulong;
1679             break;
1680           }
1681
1682         case 'U':
1683           sort_type = sort_none;
1684           sort_type_specified = true;
1685           break;
1686
1687         case 'X':
1688           sort_type = sort_extension;
1689           sort_type_specified = true;
1690           break;
1691
1692         case '1':
1693           /* -1 has no effect after -l.  */
1694           if (format != long_format)
1695             format = one_per_line;
1696           break;
1697
1698         case AUTHOR_OPTION:
1699           print_author = true;
1700           break;
1701
1702         case HIDE_OPTION:
1703           {
1704             struct ignore_pattern *hide = xmalloc (sizeof *hide);
1705             hide->pattern = optarg;
1706             hide->next = hide_patterns;
1707             hide_patterns = hide;
1708           }
1709           break;
1710
1711         case SORT_OPTION:
1712           sort_type = XARGMATCH ("--sort", optarg, sort_args, sort_types);
1713           sort_type_specified = true;
1714           break;
1715
1716         case GROUP_DIRECTORIES_FIRST_OPTION:
1717           directories_first = true;
1718           break;
1719
1720         case TIME_OPTION:
1721           time_type = XARGMATCH ("--time", optarg, time_args, time_types);
1722           break;
1723
1724         case FORMAT_OPTION:
1725           format = XARGMATCH ("--format", optarg, format_args, format_types);
1726           break;
1727
1728         case FULL_TIME_OPTION:
1729           format = long_format;
1730           time_style_option = "full-iso";
1731           break;
1732
1733         case COLOR_OPTION:
1734           {
1735             int i;
1736             if (optarg)
1737               i = XARGMATCH ("--color", optarg, color_args, color_types);
1738             else
1739               /* Using --color with no argument is equivalent to using
1740                  --color=always.  */
1741               i = color_always;
1742
1743             print_with_color = (i == color_always
1744                                 || (i == color_if_tty
1745                                     && isatty (STDOUT_FILENO)));
1746
1747             if (print_with_color)
1748               {
1749                 /* Don't use TAB characters in output.  Some terminal
1750                    emulators can't handle the combination of tabs and
1751                    color codes on the same line.  */
1752                 tabsize = 0;
1753               }
1754             break;
1755           }
1756
1757         case INDICATOR_STYLE_OPTION:
1758           indicator_style = XARGMATCH ("--indicator-style", optarg,
1759                                        indicator_style_args,
1760                                        indicator_style_types);
1761           break;
1762
1763         case QUOTING_STYLE_OPTION:
1764           set_quoting_style (NULL,
1765                              XARGMATCH ("--quoting-style", optarg,
1766                                         quoting_style_args,
1767                                         quoting_style_vals));
1768           break;
1769
1770         case TIME_STYLE_OPTION:
1771           time_style_option = optarg;
1772           break;
1773
1774         case SHOW_CONTROL_CHARS_OPTION:
1775           qmark_funny_chars = false;
1776           break;
1777
1778         case BLOCK_SIZE_OPTION:
1779           human_output_opts = human_options (optarg, true, &output_block_size);
1780           file_output_block_size = output_block_size;
1781           break;
1782
1783         case SI_OPTION:
1784           human_output_opts = human_autoscale | human_SI;
1785           file_output_block_size = output_block_size = 1;
1786           break;
1787
1788         case_GETOPT_HELP_CHAR;
1789
1790         case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1791
1792         default:
1793           usage (LS_FAILURE);
1794         }
1795     }
1796
1797   max_idx = MAX (1, line_length / MIN_COLUMN_WIDTH);
1798
1799   filename_quoting_options = clone_quoting_options (NULL);
1800   if (get_quoting_style (filename_quoting_options) == escape_quoting_style)
1801     set_char_quoting (filename_quoting_options, ' ', 1);
1802   if (file_type <= indicator_style)
1803     {
1804       char const *p;
1805       for (p = "*=>@|" + indicator_style - file_type; *p; p++)
1806         set_char_quoting (filename_quoting_options, *p, 1);
1807     }
1808
1809   dirname_quoting_options = clone_quoting_options (NULL);
1810   set_char_quoting (dirname_quoting_options, ':', 1);
1811
1812   /* --dired is meaningful only with --format=long (-l).
1813      Otherwise, ignore it.  FIXME: warn about this?
1814      Alternatively, make --dired imply --format=long?  */
1815   if (dired && format != long_format)
1816     dired = false;
1817
1818   /* If -c or -u is specified and not -l (or any other option that implies -l),
1819      and no sort-type was specified, then sort by the ctime (-c) or atime (-u).
1820      The behavior of ls when using either -c or -u but with neither -l nor -t
1821      appears to be unspecified by POSIX.  So, with GNU ls, `-u' alone means
1822      sort by atime (this is the one that's not specified by the POSIX spec),
1823      -lu means show atime and sort by name, -lut means show atime and sort
1824      by atime.  */
1825
1826   if ((time_type == time_ctime || time_type == time_atime)
1827       && !sort_type_specified && format != long_format)
1828     {
1829       sort_type = sort_time;
1830     }
1831
1832   if (format == long_format)
1833     {
1834       char *style = time_style_option;
1835       static char const posix_prefix[] = "posix-";
1836
1837       if (! style)
1838         if (! (style = getenv ("TIME_STYLE")))
1839           style = "locale";
1840
1841       while (strncmp (style, posix_prefix, sizeof posix_prefix - 1) == 0)
1842         {
1843           if (! hard_locale (LC_TIME))
1844             return optind;
1845           style += sizeof posix_prefix - 1;
1846         }
1847
1848       if (*style == '+')
1849         {
1850           char *p0 = style + 1;
1851           char *p1 = strchr (p0, '\n');
1852           if (! p1)
1853             p1 = p0;
1854           else
1855             {
1856               if (strchr (p1 + 1, '\n'))
1857                 error (LS_FAILURE, 0, _("invalid time style format %s"),
1858                        quote (p0));
1859               *p1++ = '\0';
1860             }
1861           long_time_format[0] = p0;
1862           long_time_format[1] = p1;
1863         }
1864       else
1865         switch (XARGMATCH ("time style", style,
1866                            time_style_args,
1867                            time_style_types))
1868           {
1869           case full_iso_time_style:
1870             long_time_format[0] = long_time_format[1] =
1871               "%Y-%m-%d %H:%M:%S.%N %z";
1872             break;
1873
1874           case long_iso_time_style:
1875           case_long_iso_time_style:
1876             long_time_format[0] = long_time_format[1] = "%Y-%m-%d %H:%M";
1877             break;
1878
1879           case iso_time_style:
1880             long_time_format[0] = "%Y-%m-%d ";
1881             long_time_format[1] = "%m-%d %H:%M";
1882             break;
1883
1884           case locale_time_style:
1885             if (hard_locale (LC_TIME))
1886               {
1887                 /* Ensure that the locale has translations for both
1888                    formats.  If not, fall back on long-iso format.  */
1889                 int i;
1890                 for (i = 0; i < 2; i++)
1891                   {
1892                     char const *locale_format =
1893                       dcgettext (NULL, long_time_format[i], LC_TIME);
1894                     if (locale_format == long_time_format[i])
1895                       goto case_long_iso_time_style;
1896                     long_time_format[i] = locale_format;
1897                   }
1898               }
1899           }
1900     }
1901
1902   return optind;
1903 }
1904
1905 /* Parse a string as part of the LS_COLORS variable; this may involve
1906    decoding all kinds of escape characters.  If equals_end is set an
1907    unescaped equal sign ends the string, otherwise only a : or \0
1908    does.  Set *OUTPUT_COUNT to the number of bytes output.  Return
1909    true if successful.
1910
1911    The resulting string is *not* null-terminated, but may contain
1912    embedded nulls.
1913
1914    Note that both dest and src are char **; on return they point to
1915    the first free byte after the array and the character that ended
1916    the input string, respectively.  */
1917
1918 static bool
1919 get_funky_string (char **dest, const char **src, bool equals_end,
1920                   size_t *output_count)
1921 {
1922   char num;                     /* For numerical codes */
1923   size_t count;                 /* Something to count with */
1924   enum {
1925     ST_GND, ST_BACKSLASH, ST_OCTAL, ST_HEX, ST_CARET, ST_END, ST_ERROR
1926   } state;
1927   const char *p;
1928   char *q;
1929
1930   p = *src;                     /* We don't want to double-indirect */
1931   q = *dest;                    /* the whole darn time.  */
1932
1933   count = 0;                    /* No characters counted in yet.  */
1934   num = 0;
1935
1936   state = ST_GND;               /* Start in ground state.  */
1937   while (state < ST_END)
1938     {
1939       switch (state)
1940         {
1941         case ST_GND:            /* Ground state (no escapes) */
1942           switch (*p)
1943             {
1944             case ':':
1945             case '\0':
1946               state = ST_END;   /* End of string */
1947               break;
1948             case '\\':
1949               state = ST_BACKSLASH; /* Backslash scape sequence */
1950               ++p;
1951               break;
1952             case '^':
1953               state = ST_CARET; /* Caret escape */
1954               ++p;
1955               break;
1956             case '=':
1957               if (equals_end)
1958                 {
1959                   state = ST_END; /* End */
1960                   break;
1961                 }
1962               /* else fall through */
1963             default:
1964               *(q++) = *(p++);
1965               ++count;
1966               break;
1967             }
1968           break;
1969
1970         case ST_BACKSLASH:      /* Backslash escaped character */
1971           switch (*p)
1972             {
1973             case '0':
1974             case '1':
1975             case '2':
1976             case '3':
1977             case '4':
1978             case '5':
1979             case '6':
1980             case '7':
1981               state = ST_OCTAL; /* Octal sequence */
1982               num = *p - '0';
1983               break;
1984             case 'x':
1985             case 'X':
1986               state = ST_HEX;   /* Hex sequence */
1987               num = 0;
1988               break;
1989             case 'a':           /* Bell */
1990               num = '\a';
1991               break;
1992             case 'b':           /* Backspace */
1993               num = '\b';
1994               break;
1995             case 'e':           /* Escape */
1996               num = 27;
1997               break;
1998             case 'f':           /* Form feed */
1999               num = '\f';
2000               break;
2001             case 'n':           /* Newline */
2002               num = '\n';
2003               break;
2004             case 'r':           /* Carriage return */
2005               num = '\r';
2006               break;
2007             case 't':           /* Tab */
2008               num = '\t';
2009               break;
2010             case 'v':           /* Vtab */
2011               num = '\v';
2012               break;
2013             case '?':           /* Delete */
2014               num = 127;
2015               break;
2016             case '_':           /* Space */
2017               num = ' ';
2018               break;
2019             case '\0':          /* End of string */
2020               state = ST_ERROR; /* Error! */
2021               break;
2022             default:            /* Escaped character like \ ^ : = */
2023               num = *p;
2024               break;
2025             }
2026           if (state == ST_BACKSLASH)
2027             {
2028               *(q++) = num;
2029               ++count;
2030               state = ST_GND;
2031             }
2032           ++p;
2033           break;
2034
2035         case ST_OCTAL:          /* Octal sequence */
2036           if (*p < '0' || *p > '7')
2037             {
2038               *(q++) = num;
2039               ++count;
2040               state = ST_GND;
2041             }
2042           else
2043             num = (num << 3) + (*(p++) - '0');
2044           break;
2045
2046         case ST_HEX:            /* Hex sequence */
2047           switch (*p)
2048             {
2049             case '0':
2050             case '1':
2051             case '2':
2052             case '3':
2053             case '4':
2054             case '5':
2055             case '6':
2056             case '7':
2057             case '8':
2058             case '9':
2059               num = (num << 4) + (*(p++) - '0');
2060               break;
2061             case 'a':
2062             case 'b':
2063             case 'c':
2064             case 'd':
2065             case 'e':
2066             case 'f':
2067               num = (num << 4) + (*(p++) - 'a') + 10;
2068               break;
2069             case 'A':
2070             case 'B':
2071             case 'C':
2072             case 'D':
2073             case 'E':
2074             case 'F':
2075               num = (num << 4) + (*(p++) - 'A') + 10;
2076               break;
2077             default:
2078               *(q++) = num;
2079               ++count;
2080               state = ST_GND;
2081               break;
2082             }
2083           break;
2084
2085         case ST_CARET:          /* Caret escape */
2086           state = ST_GND;       /* Should be the next state... */
2087           if (*p >= '@' && *p <= '~')
2088             {
2089               *(q++) = *(p++) & 037;
2090               ++count;
2091             }
2092           else if (*p == '?')
2093             {
2094               *(q++) = 127;
2095               ++count;
2096             }
2097           else
2098             state = ST_ERROR;
2099           break;
2100
2101         default:
2102           abort ();
2103         }
2104     }
2105
2106   *dest = q;
2107   *src = p;
2108   *output_count = count;
2109
2110   return state != ST_ERROR;
2111 }
2112
2113 static void
2114 parse_ls_color (void)
2115 {
2116   const char *p;                /* Pointer to character being parsed */
2117   char *buf;                    /* color_buf buffer pointer */
2118   int state;                    /* State of parser */
2119   int ind_no;                   /* Indicator number */
2120   char label[3];                /* Indicator label */
2121   struct color_ext_type *ext;   /* Extension we are working on */
2122
2123   if ((p = getenv ("LS_COLORS")) == NULL || *p == '\0')
2124     return;
2125
2126   ext = NULL;
2127   strcpy (label, "??");
2128
2129   /* This is an overly conservative estimate, but any possible
2130      LS_COLORS string will *not* generate a color_buf longer than
2131      itself, so it is a safe way of allocating a buffer in
2132      advance.  */
2133   buf = color_buf = xstrdup (p);
2134
2135   state = 1;
2136   while (state > 0)
2137     {
2138       switch (state)
2139         {
2140         case 1:         /* First label character */
2141           switch (*p)
2142             {
2143             case ':':
2144               ++p;
2145               break;
2146
2147             case '*':
2148               /* Allocate new extension block and add to head of
2149                  linked list (this way a later definition will
2150                  override an earlier one, which can be useful for
2151                  having terminal-specific defs override global).  */
2152
2153               ext = xmalloc (sizeof *ext);
2154               ext->next = color_ext_list;
2155               color_ext_list = ext;
2156
2157               ++p;
2158               ext->ext.string = buf;
2159
2160               state = (get_funky_string (&buf, &p, true, &ext->ext.len)
2161                        ? 4 : -1);
2162               break;
2163
2164             case '\0':
2165               state = 0;        /* Done! */
2166               break;
2167
2168             default:    /* Assume it is file type label */
2169               label[0] = *(p++);
2170               state = 2;
2171               break;
2172             }
2173           break;
2174
2175         case 2:         /* Second label character */
2176           if (*p)
2177             {
2178               label[1] = *(p++);
2179               state = 3;
2180             }
2181           else
2182             state = -1; /* Error */
2183           break;
2184
2185         case 3:         /* Equal sign after indicator label */
2186           state = -1;   /* Assume failure...  */
2187           if (*(p++) == '=')/* It *should* be...  */
2188             {
2189               for (ind_no = 0; indicator_name[ind_no] != NULL; ++ind_no)
2190                 {
2191                   if (STREQ (label, indicator_name[ind_no]))
2192                     {
2193                       color_indicator[ind_no].string = buf;
2194                       state = (get_funky_string (&buf, &p, false,
2195                                                  &color_indicator[ind_no].len)
2196                                ? 1 : -1);
2197                       break;
2198                     }
2199                 }
2200               if (state == -1)
2201                 error (0, 0, _("unrecognized prefix: %s"), quotearg (label));
2202             }
2203           break;
2204
2205         case 4:         /* Equal sign after *.ext */
2206           if (*(p++) == '=')
2207             {
2208               ext->seq.string = buf;
2209               state = (get_funky_string (&buf, &p, false, &ext->seq.len)
2210                        ? 1 : -1);
2211             }
2212           else
2213             state = -1;
2214           break;
2215         }
2216     }
2217
2218   if (state < 0)
2219     {
2220       struct color_ext_type *e;
2221       struct color_ext_type *e2;
2222
2223       error (0, 0,
2224              _("unparsable value for LS_COLORS environment variable"));
2225       free (color_buf);
2226       for (e = color_ext_list; e != NULL; /* empty */)
2227         {
2228           e2 = e;
2229           e = e->next;
2230           free (e2);
2231         }
2232       print_with_color = false;
2233     }
2234
2235   if (color_indicator[C_LINK].len == 6
2236       && !strncmp (color_indicator[C_LINK].string, "target", 6))
2237     color_symlink_as_referent = true;
2238 }
2239
2240 /* Set the exit status to report a failure.  If SERIOUS, it is a
2241    serious failure; otherwise, it is merely a minor problem.  */
2242
2243 static void
2244 set_exit_status (bool serious)
2245 {
2246   if (serious)
2247     exit_status = LS_FAILURE;
2248   else if (exit_status == EXIT_SUCCESS)
2249     exit_status = LS_MINOR_PROBLEM;
2250 }
2251
2252 /* Assuming a failure is serious if SERIOUS, use the printf-style
2253    MESSAGE to report the failure to access a file named FILE.  Assume
2254    errno is set appropriately for the failure.  */
2255
2256 static void
2257 file_failure (bool serious, char const *message, char const *file)
2258 {
2259   error (0, errno, message, quotearg_colon (file));
2260   set_exit_status (serious);
2261 }
2262
2263 /* Request that the directory named NAME have its contents listed later.
2264    If REALNAME is nonzero, it will be used instead of NAME when the
2265    directory name is printed.  This allows symbolic links to directories
2266    to be treated as regular directories but still be listed under their
2267    real names.  NAME == NULL is used to insert a marker entry for the
2268    directory named in REALNAME.
2269    If NAME is non-NULL, we use its dev/ino information to save
2270    a call to stat -- when doing a recursive (-R) traversal.
2271    COMMAND_LINE_ARG means this directory was mentioned on the command line.  */
2272
2273 static void
2274 queue_directory (char const *name, char const *realname, bool command_line_arg)
2275 {
2276   struct pending *new = xmalloc (sizeof *new);
2277   new->realname = realname ? xstrdup (realname) : NULL;
2278   new->name = name ? xstrdup (name) : NULL;
2279   new->command_line_arg = command_line_arg;
2280   new->next = pending_dirs;
2281   pending_dirs = new;
2282 }
2283
2284 /* Read directory NAME, and list the files in it.
2285    If REALNAME is nonzero, print its name instead of NAME;
2286    this is used for symbolic links to directories.
2287    COMMAND_LINE_ARG means this directory was mentioned on the command line.  */
2288
2289 static void
2290 print_dir (char const *name, char const *realname, bool command_line_arg)
2291 {
2292   DIR *dirp;
2293   struct dirent *next;
2294   uintmax_t total_blocks = 0;
2295   static bool first = true;
2296
2297   errno = 0;
2298   dirp = opendir (name);
2299   if (!dirp)
2300     {
2301       file_failure (command_line_arg, _("cannot open directory %s"), name);
2302       return;
2303     }
2304
2305   if (LOOP_DETECT)
2306     {
2307       struct stat dir_stat;
2308       int fd = dirfd (dirp);
2309
2310       /* If dirfd failed, endure the overhead of using stat.  */
2311       if ((0 <= fd
2312            ? fstat (fd, &dir_stat)
2313            : stat (name, &dir_stat)) < 0)
2314         {
2315           file_failure (command_line_arg,
2316                         _("cannot determine device and inode of %s"), name);
2317           return;
2318         }
2319
2320       /* If we've already visited this dev/inode pair, warn that
2321          we've found a loop, and do not process this directory.  */
2322       if (visit_dir (dir_stat.st_dev, dir_stat.st_ino))
2323         {
2324           error (0, 0, _("%s: not listing already-listed directory"),
2325                  quotearg_colon (name));
2326           return;
2327         }
2328
2329       DEV_INO_PUSH (dir_stat.st_dev, dir_stat.st_ino);
2330     }
2331
2332   /* Read the directory entries, and insert the subfiles into the `files'
2333      table.  */
2334
2335   clear_files ();
2336
2337   while (1)
2338     {
2339       /* Set errno to zero so we can distinguish between a readdir failure
2340          and when readdir simply finds that there are no more entries.  */
2341       errno = 0;
2342       next = readdir (dirp);
2343       if (next)
2344         {
2345           if (! file_ignored (next->d_name))
2346             {
2347               enum filetype type = unknown;
2348
2349 #if HAVE_STRUCT_DIRENT_D_TYPE
2350               switch (next->d_type)
2351                 {
2352                 case DT_BLK:  type = blockdev;          break;
2353                 case DT_CHR:  type = chardev;           break;
2354                 case DT_DIR:  type = directory;         break;
2355                 case DT_FIFO: type = fifo;              break;
2356                 case DT_LNK:  type = symbolic_link;     break;
2357                 case DT_REG:  type = normal;            break;
2358                 case DT_SOCK: type = sock;              break;
2359 # ifdef DT_WHT
2360                 case DT_WHT:  type = whiteout;          break;
2361 # endif
2362                 }
2363 #endif
2364               total_blocks += gobble_file (next->d_name, type, D_INO (next),
2365                                            false, name);
2366             }
2367         }
2368       else if (errno != 0)
2369         {
2370           file_failure (command_line_arg, _("reading directory %s"), name);
2371           if (errno != EOVERFLOW)
2372             break;
2373         }
2374       else
2375         break;
2376     }
2377
2378   if (closedir (dirp) != 0)
2379     {
2380       file_failure (command_line_arg, _("closing directory %s"), name);
2381       /* Don't return; print whatever we got.  */
2382     }
2383
2384   /* Sort the directory contents.  */
2385   sort_files ();
2386
2387   /* If any member files are subdirectories, perhaps they should have their
2388      contents listed rather than being mentioned here as files.  */
2389
2390   if (recursive)
2391     extract_dirs_from_files (name, command_line_arg);
2392
2393   if (recursive | print_dir_name)
2394     {
2395       if (!first)
2396         DIRED_PUTCHAR ('\n');
2397       first = false;
2398       DIRED_INDENT ();
2399       PUSH_CURRENT_DIRED_POS (&subdired_obstack);
2400       dired_pos += quote_name (stdout, realname ? realname : name,
2401                                dirname_quoting_options, NULL);
2402       PUSH_CURRENT_DIRED_POS (&subdired_obstack);
2403       DIRED_FPUTS_LITERAL (":\n", stdout);
2404     }
2405
2406   if (format == long_format || print_block_size)
2407     {
2408       const char *p;
2409       char buf[LONGEST_HUMAN_READABLE + 1];
2410
2411       DIRED_INDENT ();
2412       p = _("total");
2413       DIRED_FPUTS (p, stdout, strlen (p));
2414       DIRED_PUTCHAR (' ');
2415       p = human_readable (total_blocks, buf, human_output_opts,
2416                           ST_NBLOCKSIZE, output_block_size);
2417       DIRED_FPUTS (p, stdout, strlen (p));
2418       DIRED_PUTCHAR ('\n');
2419     }
2420
2421   if (files_index)
2422     print_current_files ();
2423 }
2424
2425 /* Add `pattern' to the list of patterns for which files that match are
2426    not listed.  */
2427
2428 static void
2429 add_ignore_pattern (const char *pattern)
2430 {
2431   struct ignore_pattern *ignore;
2432
2433   ignore = xmalloc (sizeof *ignore);
2434   ignore->pattern = pattern;
2435   /* Add it to the head of the linked list.  */
2436   ignore->next = ignore_patterns;
2437   ignore_patterns = ignore;
2438 }
2439
2440 /* Return true if one of the PATTERNS matches FILE.  */
2441
2442 static bool
2443 patterns_match (struct ignore_pattern const *patterns, char const *file)
2444 {
2445   struct ignore_pattern const *p;
2446   for (p = patterns; p; p = p->next)
2447     if (fnmatch (p->pattern, file, FNM_PERIOD) == 0)
2448       return true;
2449   return false;
2450 }
2451
2452 /* Return true if FILE should be ignored.  */
2453
2454 static bool
2455 file_ignored (char const *name)
2456 {
2457   return ((ignore_mode != IGNORE_MINIMAL
2458            && name[0] == '.'
2459            && (ignore_mode == IGNORE_DEFAULT || ! name[1 + (name[1] == '.')]))
2460           || (ignore_mode == IGNORE_DEFAULT
2461               && patterns_match (hide_patterns, name))
2462           || patterns_match (ignore_patterns, name));
2463 }
2464
2465 /* POSIX requires that a file size be printed without a sign, even
2466    when negative.  Assume the typical case where negative sizes are
2467    actually positive values that have wrapped around.  */
2468
2469 static uintmax_t
2470 unsigned_file_size (off_t size)
2471 {
2472   return size + (size < 0) * ((uintmax_t) OFF_T_MAX - OFF_T_MIN + 1);
2473 }
2474
2475 /* Enter and remove entries in the table `files'.  */
2476
2477 /* Empty the table of files.  */
2478
2479 static void
2480 clear_files (void)
2481 {
2482   size_t i;
2483
2484   for (i = 0; i < files_index; i++)
2485     {
2486       free (files[i].name);
2487       free (files[i].linkname);
2488     }
2489
2490   files_index = 0;
2491 #if USE_ACL
2492   any_has_acl = false;
2493 #endif
2494   inode_number_width = 0;
2495   block_size_width = 0;
2496   nlink_width = 0;
2497   owner_width = 0;
2498   group_width = 0;
2499   author_width = 0;
2500   major_device_number_width = 0;
2501   minor_device_number_width = 0;
2502   file_size_width = 0;
2503 }
2504
2505 /* Add a file to the current table of files.
2506    Verify that the file exists, and print an error message if it does not.
2507    Return the number of blocks that the file occupies.  */
2508
2509 static uintmax_t
2510 gobble_file (char const *name, enum filetype type, ino_t inode,
2511              bool command_line_arg, char const *dirname)
2512 {
2513   uintmax_t blocks = 0;
2514   struct fileinfo *f;
2515
2516   /* An inode value prior to gobble_file necessarily came from readdir,
2517      which is not used for command line arguments.  */
2518   assert (! command_line_arg || inode == NOT_AN_INODE_NUMBER);
2519
2520   if (files_index == nfiles)
2521     {
2522       files = xnrealloc (files, nfiles, 2 * sizeof *files);
2523       nfiles *= 2;
2524     }
2525
2526   f = &files[files_index];
2527   memset (f, '\0', sizeof *f);
2528   f->stat.st_ino = inode;
2529   f->filetype = type;
2530
2531   if (command_line_arg
2532       || format_needs_stat
2533       /* When coloring a directory (we may know the type from
2534          direct.d_type), we have to stat it in order to indicate
2535          sticky and/or other-writable attributes.  */
2536       || (type == directory && print_with_color)
2537       || (print_inode
2538           && (inode == NOT_AN_INODE_NUMBER
2539               /* When dereferencing symlinks, the inode must come from
2540                  stat, but readdir provides the inode of lstat.  Command
2541                  line dereferences are already taken care of by the above
2542                  assertion that the inode number is not yet known.  */
2543               || (dereference == DEREF_ALWAYS
2544                   && (type == symbolic_link || type == unknown))))
2545       || (format_needs_type
2546           && (type == unknown || command_line_arg
2547               /* --indicator-style=classify (aka -F)
2548                  requires that we stat each regular file
2549                  to see if it's executable.  */
2550               || (type == normal && (indicator_style == classify
2551                                      /* This is so that --color ends up
2552                                         highlighting files with the executable
2553                                         bit set even when options like -F are
2554                                         not specified.  */
2555                                      || (print_with_color
2556                                          && is_colored (C_EXEC))
2557                                      )))))
2558
2559     {
2560       /* Absolute name of this file.  */
2561       char *absolute_name;
2562
2563       int err;
2564
2565       if (name[0] == '/' || dirname[0] == 0)
2566         absolute_name = (char *) name;
2567       else
2568         {
2569           absolute_name = alloca (strlen (name) + strlen (dirname) + 2);
2570           attach (absolute_name, dirname, name);
2571         }
2572
2573       switch (dereference)
2574         {
2575         case DEREF_ALWAYS:
2576           err = stat (absolute_name, &f->stat);
2577           break;
2578
2579         case DEREF_COMMAND_LINE_ARGUMENTS:
2580         case DEREF_COMMAND_LINE_SYMLINK_TO_DIR:
2581           if (command_line_arg)
2582             {
2583               bool need_lstat;
2584               err = stat (absolute_name, &f->stat);
2585
2586               if (dereference == DEREF_COMMAND_LINE_ARGUMENTS)
2587                 break;
2588
2589               need_lstat = (err < 0
2590                             ? errno == ENOENT
2591                             : ! S_ISDIR (f->stat.st_mode));
2592               if (!need_lstat)
2593                 break;
2594
2595               /* stat failed because of ENOENT, maybe indicating a dangling
2596                  symlink.  Or stat succeeded, ABSOLUTE_NAME does not refer to a
2597                  directory, and --dereference-command-line-symlink-to-dir is
2598                  in effect.  Fall through so that we call lstat instead.  */
2599             }
2600
2601         default: /* DEREF_NEVER */
2602           err = lstat (absolute_name, &f->stat);
2603           break;
2604         }
2605
2606       if (err != 0)
2607         {
2608           /* Failure to stat a command line argument leads to
2609              an exit status of 2.  For other files, stat failure
2610              provokes an exit status of 1.  */
2611           file_failure (command_line_arg,
2612                         _("cannot access %s"), absolute_name);
2613           if (command_line_arg)
2614             return 0;
2615
2616           f->name = xstrdup (name);
2617           files_index++;
2618
2619           return 0;
2620         }
2621
2622       f->stat_ok = true;
2623
2624 #if USE_ACL
2625       if (format == long_format)
2626         {
2627           int n = file_has_acl (absolute_name, &f->stat);
2628           f->have_acl = (0 < n);
2629           any_has_acl |= f->have_acl;
2630           if (n < 0)
2631             error (0, errno, "%s", quotearg_colon (absolute_name));
2632         }
2633 #endif
2634
2635       if (S_ISLNK (f->stat.st_mode)
2636           && (format == long_format || check_symlink_color))
2637         {
2638           char *linkname;
2639           struct stat linkstats;
2640
2641           get_link_name (absolute_name, f, command_line_arg);
2642           linkname = make_link_name (absolute_name, f->linkname);
2643
2644           /* Avoid following symbolic links when possible, ie, when
2645              they won't be traced and when no indicator is needed.  */
2646           if (linkname
2647               && (file_type <= indicator_style || check_symlink_color)
2648               && stat (linkname, &linkstats) == 0)
2649             {
2650               f->linkok = true;
2651
2652               /* Symbolic links to directories that are mentioned on the
2653                  command line are automatically traced if not being
2654                  listed as files.  */
2655               if (!command_line_arg || format == long_format
2656                   || !S_ISDIR (linkstats.st_mode))
2657                 {
2658                   /* Get the linked-to file's mode for the filetype indicator
2659                      in long listings.  */
2660                   f->linkmode = linkstats.st_mode;
2661                 }
2662             }
2663           free (linkname);
2664         }
2665
2666       if (S_ISLNK (f->stat.st_mode))
2667         f->filetype = symbolic_link;
2668       else if (S_ISDIR (f->stat.st_mode))
2669         {
2670           if (command_line_arg & !immediate_dirs)
2671             f->filetype = arg_directory;
2672           else
2673             f->filetype = directory;
2674         }
2675       else
2676         f->filetype = normal;
2677
2678       blocks = ST_NBLOCKS (f->stat);
2679       {
2680         char buf[LONGEST_HUMAN_READABLE + 1];
2681         int len = mbswidth (human_readable (blocks, buf, human_output_opts,
2682                                             ST_NBLOCKSIZE, output_block_size),
2683                             0);
2684         if (block_size_width < len)
2685           block_size_width = len;
2686       }
2687
2688       if (print_owner)
2689         {
2690           int len = format_user_width (f->stat.st_uid);
2691           if (owner_width < len)
2692             owner_width = len;
2693         }
2694
2695       if (print_group)
2696         {
2697           int len = format_group_width (f->stat.st_gid);
2698           if (group_width < len)
2699             group_width = len;
2700         }
2701
2702       if (print_author)
2703         {
2704           int len = format_user_width (f->stat.st_author);
2705           if (author_width < len)
2706             author_width = len;
2707         }
2708
2709       {
2710         char buf[INT_BUFSIZE_BOUND (uintmax_t)];
2711         int len = strlen (umaxtostr (f->stat.st_nlink, buf));
2712         if (nlink_width < len)
2713           nlink_width = len;
2714       }
2715
2716       if (S_ISCHR (f->stat.st_mode) || S_ISBLK (f->stat.st_mode))
2717         {
2718           char buf[INT_BUFSIZE_BOUND (uintmax_t)];
2719           int len = strlen (umaxtostr (major (f->stat.st_rdev), buf));
2720           if (major_device_number_width < len)
2721             major_device_number_width = len;
2722           len = strlen (umaxtostr (minor (f->stat.st_rdev), buf));
2723           if (minor_device_number_width < len)
2724             minor_device_number_width = len;
2725           len = major_device_number_width + 2 + minor_device_number_width;
2726           if (file_size_width < len)
2727             file_size_width = len;
2728         }
2729       else
2730         {
2731           char buf[LONGEST_HUMAN_READABLE + 1];
2732           uintmax_t size = unsigned_file_size (f->stat.st_size);
2733           int len = mbswidth (human_readable (size, buf, human_output_opts,
2734                                               1, file_output_block_size),
2735                               0);
2736           if (file_size_width < len)
2737             file_size_width = len;
2738         }
2739     }
2740
2741   if (print_inode)
2742     {
2743       char buf[INT_BUFSIZE_BOUND (uintmax_t)];
2744       int len = strlen (umaxtostr (f->stat.st_ino, buf));
2745       if (inode_number_width < len)
2746         inode_number_width = len;
2747     }
2748
2749   f->name = xstrdup (name);
2750   files_index++;
2751
2752   return blocks;
2753 }
2754
2755 /* Return true if F refers to a directory.  */
2756 static bool
2757 is_directory (const struct fileinfo *f)
2758 {
2759   return f->filetype == directory || f->filetype == arg_directory;
2760 }
2761
2762 /* Put the name of the file that FILENAME is a symbolic link to
2763    into the LINKNAME field of `f'.  COMMAND_LINE_ARG indicates whether
2764    FILENAME is a command-line argument.  */
2765
2766 static void
2767 get_link_name (char const *filename, struct fileinfo *f, bool command_line_arg)
2768 {
2769   f->linkname = xreadlink (filename, f->stat.st_size);
2770   if (f->linkname == NULL)
2771     file_failure (command_line_arg, _("cannot read symbolic link %s"),
2772                   filename);
2773 }
2774
2775 /* If `linkname' is a relative name and `name' contains one or more
2776    leading directories, return `linkname' with those directories
2777    prepended; otherwise, return a copy of `linkname'.
2778    If `linkname' is zero, return zero.  */
2779
2780 static char *
2781 make_link_name (char const *name, char const *linkname)
2782 {
2783   char *linkbuf;
2784   size_t bufsiz;
2785
2786   if (!linkname)
2787     return NULL;
2788
2789   if (*linkname == '/')
2790     return xstrdup (linkname);
2791
2792   /* The link is to a relative name.  Prepend any leading directory
2793      in `name' to the link name.  */
2794   linkbuf = strrchr (name, '/');
2795   if (linkbuf == 0)
2796     return xstrdup (linkname);
2797
2798   bufsiz = linkbuf - name + 1;
2799   linkbuf = xmalloc (bufsiz + strlen (linkname) + 1);
2800   strncpy (linkbuf, name, bufsiz);
2801   strcpy (linkbuf + bufsiz, linkname);
2802   return linkbuf;
2803 }
2804
2805 /* Return true if the last component of NAME is `.' or `..'
2806    This is so we don't try to recurse on `././././. ...' */
2807
2808 static bool
2809 basename_is_dot_or_dotdot (const char *name)
2810 {
2811   char const *base = last_component (name);
2812   return dot_or_dotdot (base);
2813 }
2814
2815 /* Remove any entries from FILES that are for directories,
2816    and queue them to be listed as directories instead.
2817    DIRNAME is the prefix to prepend to each dirname
2818    to make it correct relative to ls's working dir;
2819    if it is null, no prefix is needed and "." and ".." should not be ignored.
2820    If COMMAND_LINE_ARG is true, this directory was mentioned at the top level,
2821    This is desirable when processing directories recursively.  */
2822
2823 static void
2824 extract_dirs_from_files (char const *dirname, bool command_line_arg)
2825 {
2826   size_t i;
2827   size_t j;
2828   bool ignore_dot_and_dot_dot = (dirname != NULL);
2829
2830   if (dirname && LOOP_DETECT)
2831     {
2832       /* Insert a marker entry first.  When we dequeue this marker entry,
2833          we'll know that DIRNAME has been processed and may be removed
2834          from the set of active directories.  */
2835       queue_directory (NULL, dirname, false);
2836     }
2837
2838   /* Queue the directories last one first, because queueing reverses the
2839      order.  */
2840   for (i = files_index; i-- != 0; )
2841     if (is_directory (&files[i])
2842         && (! ignore_dot_and_dot_dot
2843             || ! basename_is_dot_or_dotdot (files[i].name)))
2844       {
2845         if (!dirname || files[i].name[0] == '/')
2846           {
2847             queue_directory (files[i].name, files[i].linkname,
2848                              command_line_arg);
2849           }
2850         else
2851           {
2852             char *name = file_name_concat (dirname, files[i].name, NULL);
2853             queue_directory (name, files[i].linkname, command_line_arg);
2854             free (name);
2855           }
2856         if (files[i].filetype == arg_directory)
2857           free (files[i].name);
2858       }
2859
2860   /* Now delete the directories from the table, compacting all the remaining
2861      entries.  */
2862
2863   for (i = 0, j = 0; i < files_index; i++)
2864     {
2865       if (files[i].filetype != arg_directory)
2866         {
2867           if (j < i)
2868             files[j] = files[i];
2869           ++j;
2870         }
2871     }
2872   files_index = j;
2873 }
2874
2875 /* Use strcoll to compare strings in this locale.  If an error occurs,
2876    report an error and longjmp to failed_strcoll.  */
2877
2878 static jmp_buf failed_strcoll;
2879
2880 static int
2881 xstrcoll (char const *a, char const *b)
2882 {
2883   int diff;
2884   errno = 0;
2885   diff = strcoll (a, b);
2886   if (errno)
2887     {
2888       error (0, errno, _("cannot compare file names %s and %s"),
2889              quote_n (0, a), quote_n (1, b));
2890       set_exit_status (false);
2891       longjmp (failed_strcoll, 1);
2892     }
2893   return diff;
2894 }
2895
2896 /* Comparison routines for sorting the files.  */
2897
2898 typedef void const *V;
2899 typedef int (*qsortFunc)(V a, V b);
2900
2901 /* Used below in DEFINE_SORT_FUNCTIONS for _df_ sort function variants.
2902    The do { ... } while(0) makes it possible to use the macro more like
2903    a statement, without violating C89 rules: */
2904 #define DIRFIRST_CHECK(a, b)                                            \
2905   do                                                                    \
2906     {                                                                   \
2907       bool a_is_dir = is_directory ((struct fileinfo const *) a);       \
2908       bool b_is_dir = is_directory ((struct fileinfo const *) b);       \
2909       if (a_is_dir && !b_is_dir)                                        \
2910         return -1;         /* a goes before b */                        \
2911       if (!a_is_dir && b_is_dir)                                        \
2912         return 1;          /* b goes before a */                        \
2913     }                                                                   \
2914   while (0)
2915
2916 /* Define the 8 different sort function variants required for each sortkey.
2917    KEY_NAME is a token describing the sort key, e.g., ctime, atime, size.
2918    KEY_CMP_FUNC is a function to compare records based on that key, e.g.,
2919    ctime_cmp, atime_cmp, size_cmp.  Append KEY_NAME to the string,
2920    '[rev_][x]str{cmp|coll}[_df]_', to create each function name.  */
2921 #define DEFINE_SORT_FUNCTIONS(key_name, key_cmp_func)                   \
2922   /* direct, non-dirfirst versions */                                   \
2923   static int xstrcoll_##key_name (V a, V b)                             \
2924   { return key_cmp_func (a, b, xstrcoll); }                             \
2925   static int strcmp_##key_name (V a, V b)                               \
2926   { return key_cmp_func (a, b, strcmp); }                               \
2927                                                                         \
2928   /* reverse, non-dirfirst versions */                                  \
2929   static int rev_xstrcoll_##key_name (V a, V b)                         \
2930   { return key_cmp_func (b, a, xstrcoll); }                             \
2931   static int rev_strcmp_##key_name (V a, V b)                           \
2932   { return key_cmp_func (b, a, strcmp); }                               \
2933                                                                         \
2934   /* direct, dirfirst versions */                                       \
2935   static int xstrcoll_df_##key_name (V a, V b)                          \
2936   { DIRFIRST_CHECK (a, b); return key_cmp_func (a, b, xstrcoll); }      \
2937   static int strcmp_df_##key_name (V a, V b)                            \
2938   { DIRFIRST_CHECK (a, b); return key_cmp_func (a, b, strcmp); }        \
2939                                                                         \
2940   /* reverse, dirfirst versions */                                      \
2941   static int rev_xstrcoll_df_##key_name (V a, V b)                      \
2942   { DIRFIRST_CHECK (a, b); return key_cmp_func (b, a, xstrcoll); }      \
2943   static int rev_strcmp_df_##key_name (V a, V b)                        \
2944   { DIRFIRST_CHECK (a, b); return key_cmp_func (b, a, strcmp); }
2945
2946 static inline int
2947 cmp_ctime (struct fileinfo const *a, struct fileinfo const *b,
2948            int (*cmp) (char const *, char const *))
2949 {
2950   int diff = timespec_cmp (get_stat_ctime (&b->stat),
2951                            get_stat_ctime (&a->stat));
2952   return diff ? diff : cmp (a->name, b->name);
2953 }
2954
2955 static inline int
2956 cmp_mtime (struct fileinfo const *a, struct fileinfo const *b,
2957            int (*cmp) (char const *, char const *))
2958 {
2959   int diff = timespec_cmp (get_stat_mtime (&b->stat),
2960                            get_stat_mtime (&a->stat));
2961   return diff ? diff : cmp (a->name, b->name);
2962 }
2963
2964 static inline int
2965 cmp_atime (struct fileinfo const *a, struct fileinfo const *b,
2966            int (*cmp) (char const *, char const *))
2967 {
2968   int diff = timespec_cmp (get_stat_atime (&b->stat),
2969                            get_stat_atime (&a->stat));
2970   return diff ? diff : cmp (a->name, b->name);
2971 }
2972
2973 static inline int
2974 cmp_size (struct fileinfo const *a, struct fileinfo const *b,
2975           int (*cmp) (char const *, char const *))
2976 {
2977   int diff = longdiff (b->stat.st_size, a->stat.st_size);
2978   return diff ? diff : cmp (a->name, b->name);
2979 }
2980
2981 static inline int
2982 cmp_name (struct fileinfo const *a, struct fileinfo const *b,
2983           int (*cmp) (char const *, char const *))
2984 {
2985   return cmp (a->name, b->name);
2986 }
2987
2988 /* Compare file extensions.  Files with no extension are `smallest'.
2989    If extensions are the same, compare by filenames instead.  */
2990
2991 static inline int
2992 cmp_extension (struct fileinfo const *a, struct fileinfo const *b,
2993                int (*cmp) (char const *, char const *))
2994 {
2995   char const *base1 = strrchr (a->name, '.');
2996   char const *base2 = strrchr (b->name, '.');
2997   int diff = cmp (base1 ? base1 : "", base2 ? base2 : "");
2998   return diff ? diff : cmp (a->name, b->name);
2999 }
3000
3001 DEFINE_SORT_FUNCTIONS (ctime, cmp_ctime)
3002 DEFINE_SORT_FUNCTIONS (mtime, cmp_mtime)
3003 DEFINE_SORT_FUNCTIONS (atime, cmp_atime)
3004 DEFINE_SORT_FUNCTIONS (size, cmp_size)
3005 DEFINE_SORT_FUNCTIONS (name, cmp_name)
3006 DEFINE_SORT_FUNCTIONS (extension, cmp_extension)
3007
3008 /* Compare file versions.
3009    Unlike all other compare functions above, cmp_version depends only
3010    on strverscmp, which does not fail (even for locale reasons), and does not
3011    need a secondary sort key.
3012    All the other sort options, in fact, need xstrcoll and strcmp variants,
3013    because they all use a string comparison (either as the primary or secondary
3014    sort key), and xstrcoll has the ability to do a longjmp if strcoll fails for
3015    locale reasons.  Last, strverscmp is ALWAYS available in coreutils,
3016    thanks to the gnulib library. */
3017 static inline int
3018 cmp_version (struct fileinfo const *a, struct fileinfo const *b)
3019 {
3020   return strverscmp (a->name, b->name);
3021 }
3022
3023 static int xstrcoll_version (V a, V b)
3024 { return cmp_version (a, b); }
3025 static int rev_xstrcoll_version (V a, V b)
3026 { return cmp_version (b, a); }
3027 static int xstrcoll_df_version (V a, V b)
3028 { DIRFIRST_CHECK (a, b); return cmp_version (a, b); }
3029 static int rev_xstrcoll_df_version (V a, V b)
3030 { DIRFIRST_CHECK (a, b); return cmp_version (b, a); }
3031
3032
3033 /* We have 2^3 different variants for each sortkey function
3034    (for 3 independent sort modes).
3035    The function pointers stored in this array must be dereferenced as:
3036
3037     sort_variants[sort_key][use_strcmp][reverse][dirs_first]
3038
3039    Note that the order in which sortkeys are listed in the function pointer
3040    array below is defined by the order of the elements in the time_type and
3041    sort_type enums!  */
3042
3043 #define LIST_SORTFUNCTION_VARIANTS(key_name)                        \
3044   {                                                                 \
3045     {                                                               \
3046       { xstrcoll_##key_name, xstrcoll_df_##key_name },              \
3047       { rev_xstrcoll_##key_name, rev_xstrcoll_df_##key_name },      \
3048     },                                                              \
3049     {                                                               \
3050       { strcmp_##key_name, strcmp_df_##key_name },                  \
3051       { rev_strcmp_##key_name, rev_strcmp_df_##key_name },          \
3052     }                                                               \
3053   }
3054
3055 static qsortFunc sort_functions[][2][2][2] =
3056   {
3057     LIST_SORTFUNCTION_VARIANTS (name),
3058     LIST_SORTFUNCTION_VARIANTS (extension),
3059     LIST_SORTFUNCTION_VARIANTS (size),
3060
3061     {
3062       {
3063         { xstrcoll_version, xstrcoll_df_version },
3064         { rev_xstrcoll_version, rev_xstrcoll_df_version },
3065       },
3066
3067       /* We use NULL for the strcmp variants of version comparison
3068          since as explained in cmp_version definition, version comparison
3069          does not rely on xstrcoll, so it will never longjmp, and never
3070          need to try the strcmp fallback. */
3071       {
3072         { NULL, NULL },
3073         { NULL, NULL },
3074       }
3075     },
3076
3077     /* last are time sort functions */
3078     LIST_SORTFUNCTION_VARIANTS (mtime),
3079     LIST_SORTFUNCTION_VARIANTS (ctime),
3080     LIST_SORTFUNCTION_VARIANTS (atime)
3081   };
3082
3083 /* The number of sortkeys is calculated as
3084      the number of elements in the sort_type enum (i.e. sort_numtypes) +
3085      the number of elements in the time_type enum (i.e. time_numtypes) - 1
3086    This is because when sort_type==sort_time, we have up to
3087    time_numtypes possible sortkeys.
3088
3089    This line verifies at compile-time that the array of sort functions has been
3090    initialized for all possible sortkeys. */
3091 verify (ARRAY_CARDINALITY (sort_functions)
3092         == sort_numtypes + time_numtypes - 1 );
3093
3094
3095 /* Sort the files now in the table.  */
3096
3097 static void
3098 sort_files (void)
3099 {
3100   bool use_strcmp;
3101
3102   if (sort_type == sort_none)
3103     return;
3104
3105   /* Try strcoll.  If it fails, fall back on strcmp.  We can't safely
3106      ignore strcoll failures, as a failing strcoll might be a
3107      comparison function that is not a total order, and if we ignored
3108      the failure this might cause qsort to dump core.  */
3109
3110   if (! setjmp (failed_strcoll))
3111     use_strcmp = false;      /* strcoll() succeeded */
3112   else
3113     {
3114       use_strcmp = true;
3115       assert (sort_type != sort_version);
3116     }
3117
3118   /* When sort_type == sort_time, use time_type as subindex.  */
3119   qsort (files, files_index, sizeof *files,
3120          sort_functions[sort_type + (sort_type == sort_time ? time_type : 0)]
3121                        [use_strcmp][sort_reverse]
3122                        [directories_first]);
3123 }
3124
3125 /* List all the files now in the table.  */
3126
3127 static void
3128 print_current_files (void)
3129 {
3130   size_t i;
3131
3132   switch (format)
3133     {
3134     case one_per_line:
3135       for (i = 0; i < files_index; i++)
3136         {
3137           print_file_name_and_frills (files + i);
3138           putchar ('\n');
3139         }
3140       break;
3141
3142     case many_per_line:
3143       print_many_per_line ();
3144       break;
3145
3146     case horizontal:
3147       print_horizontal ();
3148       break;
3149
3150     case with_commas:
3151       print_with_commas ();
3152       break;
3153
3154     case long_format:
3155       for (i = 0; i < files_index; i++)
3156         {
3157           print_long_format (files + i);
3158           DIRED_PUTCHAR ('\n');
3159         }
3160       break;
3161     }
3162 }
3163
3164 /* Return the expected number of columns in a long-format time stamp,
3165    or zero if it cannot be calculated.  */
3166
3167 static int
3168 long_time_expected_width (void)
3169 {
3170   static int width = -1;
3171
3172   if (width < 0)
3173     {
3174       time_t epoch = 0;
3175       struct tm const *tm = localtime (&epoch);
3176       char buf[TIME_STAMP_LEN_MAXIMUM + 1];
3177
3178       /* In case you're wondering if localtime can fail with an input time_t
3179          value of 0, let's just say it's very unlikely, but not inconceivable.
3180          The TZ environment variable would have to specify a time zone that
3181          is 2**31-1900 years or more ahead of UTC.  This could happen only on
3182          a 64-bit system that blindly accepts e.g., TZ=UTC+20000000000000.
3183          However, this is not possible with Solaris 10 or glibc-2.3.5, since
3184          their implementations limit the offset to 167:59 and 24:00, resp.  */
3185       if (tm)
3186         {
3187           size_t len =
3188             nstrftime (buf, sizeof buf, long_time_format[0], tm, 0, 0);
3189           if (len != 0)
3190             width = mbsnwidth (buf, len, 0);
3191         }
3192
3193       if (width < 0)
3194         width = 0;
3195     }
3196
3197   return width;
3198 }
3199
3200 /* Get the current time.  */
3201
3202 static void
3203 get_current_time (void)
3204 {
3205 #if HAVE_CLOCK_GETTIME && defined CLOCK_REALTIME
3206   {
3207     struct timespec timespec;
3208     if (clock_gettime (CLOCK_REALTIME, &timespec) == 0)
3209       {
3210         current_time = timespec.tv_sec;
3211         current_time_ns = timespec.tv_nsec;
3212         return;
3213       }
3214   }
3215 #endif
3216
3217   /* The clock does not have nanosecond resolution, so get the maximum
3218      possible value for the current time that is consistent with the
3219      reported clock.  That way, files are not considered to be in the
3220      future merely because their time stamps have higher resolution
3221      than the clock resolution.  */
3222
3223 #if HAVE_GETTIMEOFDAY
3224   {
3225     struct timeval timeval;
3226     gettimeofday (&timeval, NULL);
3227     current_time = timeval.tv_sec;
3228     current_time_ns = timeval.tv_usec * 1000 + 999;
3229   }
3230 #else
3231   current_time = time (NULL);
3232   current_time_ns = 999999999;
3233 #endif
3234 }
3235
3236 /* Print the user or group name NAME, with numeric id ID, using a
3237    print width of WIDTH columns.  */
3238
3239 static void
3240 format_user_or_group (char const *name, unsigned long int id, int width)
3241 {
3242   size_t len;
3243
3244   if (name)
3245     {
3246       int width_gap = width - mbswidth (name, 0);
3247       int pad = MAX (0, width_gap);
3248       fputs (name, stdout);
3249       len = strlen (name) + pad;
3250
3251       do
3252         putchar (' ');
3253       while (pad--);
3254     }
3255   else
3256     {
3257       printf ("%*lu ", width, id);
3258       len = width;
3259     }
3260
3261   dired_pos += len + 1;
3262 }
3263
3264 /* Print the name or id of the user with id U, using a print width of
3265    WIDTH.  */
3266
3267 static void
3268 format_user (uid_t u, int width, bool stat_ok)
3269 {
3270   format_user_or_group (! stat_ok ? "?" :
3271                         (numeric_ids ? NULL : getuser (u)), u, width);
3272 }
3273
3274 /* Likewise, for groups.  */
3275
3276 static void
3277 format_group (gid_t g, int width, bool stat_ok)
3278 {
3279   format_user_or_group (! stat_ok ? "?" :
3280                         (numeric_ids ? NULL : getgroup (g)), g, width);
3281 }
3282
3283 /* Return the number of columns that format_user_or_group will print.  */
3284
3285 static int
3286 format_user_or_group_width (char const *name, unsigned long int id)
3287 {
3288   if (name)
3289     {
3290       int len = mbswidth (name, 0);
3291       return MAX (0, len);
3292     }
3293   else
3294     {
3295       char buf[INT_BUFSIZE_BOUND (unsigned long int)];
3296       sprintf (buf, "%lu", id);
3297       return strlen (buf);
3298     }
3299 }
3300
3301 /* Return the number of columns that format_user will print.  */
3302
3303 static int
3304 format_user_width (uid_t u)
3305 {
3306   return format_user_or_group_width (numeric_ids ? NULL : getuser (u), u);
3307 }
3308
3309 /* Likewise, for groups.  */
3310
3311 static int
3312 format_group_width (gid_t g)
3313 {
3314   return format_user_or_group_width (numeric_ids ? NULL : getgroup (g), g);
3315 }
3316
3317
3318 /* Print information about F in long format.  */
3319
3320 static void
3321 print_long_format (const struct fileinfo *f)
3322 {
3323   char modebuf[12];
3324   char buf
3325     [LONGEST_HUMAN_READABLE + 1         /* inode */
3326      + LONGEST_HUMAN_READABLE + 1       /* size in blocks */
3327      + sizeof (modebuf) - 1 + 1         /* mode string */
3328      + INT_BUFSIZE_BOUND (uintmax_t)    /* st_nlink */
3329      + LONGEST_HUMAN_READABLE + 2       /* major device number */
3330      + LONGEST_HUMAN_READABLE + 1       /* minor device number */
3331      + TIME_STAMP_LEN_MAXIMUM + 1       /* max length of time/date */
3332      ];
3333   size_t s;
3334   char *p;
3335   time_t when;
3336   int when_ns;
3337   struct timespec when_timespec;
3338   struct tm *when_local;
3339
3340   /* Compute the mode string, except remove the trailing space if no
3341      files in this directory have ACLs.  */
3342   if (f->stat_ok)
3343     filemodestring (&f->stat, modebuf);
3344   else
3345     {
3346       modebuf[0] = filetype_letter[f->filetype];
3347       memset (modebuf + 1, '?', 10);
3348       modebuf[11] = '\0';
3349     }
3350   if (! any_has_acl)
3351     modebuf[10] = '\0';
3352   else if (FILE_HAS_ACL (f))
3353     modebuf[10] = '+';
3354
3355   switch (time_type)
3356     {
3357     case time_ctime:
3358       when_timespec = get_stat_ctime (&f->stat);
3359       break;
3360     case time_mtime:
3361       when_timespec = get_stat_mtime (&f->stat);
3362       break;
3363     case time_atime:
3364       when_timespec = get_stat_atime (&f->stat);
3365       break;
3366     default:
3367       abort ();
3368     }
3369
3370   when = when_timespec.tv_sec;
3371   when_ns = when_timespec.tv_nsec;
3372
3373   p = buf;
3374
3375   if (print_inode)
3376     {
3377       char hbuf[INT_BUFSIZE_BOUND (uintmax_t)];
3378       sprintf (p, "%*s ", inode_number_width,
3379                (f->stat.st_ino == NOT_AN_INODE_NUMBER
3380                 ? "?"
3381                 : umaxtostr (f->stat.st_ino, hbuf)));
3382       /* Increment by strlen (p) here, rather than by inode_number_width + 1.
3383          The latter is wrong when inode_number_width is zero.  */
3384       p += strlen (p);
3385     }
3386
3387   if (print_block_size)
3388     {
3389       char hbuf[LONGEST_HUMAN_READABLE + 1];
3390       char const *blocks =
3391         (! f->stat_ok
3392          ? "?"
3393          : human_readable (ST_NBLOCKS (f->stat), hbuf, human_output_opts,
3394                            ST_NBLOCKSIZE, output_block_size));
3395       int pad;
3396       for (pad = block_size_width - mbswidth (blocks, 0); 0 < pad; pad--)
3397         *p++ = ' ';
3398       while ((*p++ = *blocks++))
3399         continue;
3400       p[-1] = ' ';
3401     }
3402
3403   /* The last byte of the mode string is the POSIX
3404      "optional alternate access method flag".  */
3405   {
3406     char hbuf[INT_BUFSIZE_BOUND (uintmax_t)];
3407     sprintf (p, "%s %*s ", modebuf, nlink_width,
3408              ! f->stat_ok ? "?" : umaxtostr (f->stat.st_nlink, hbuf));
3409   }
3410   /* Increment by strlen (p) here, rather than by, e.g.,
3411      sizeof modebuf - 2 + any_has_acl + 1 + nlink_width + 1.
3412      The latter is wrong when nlink_width is zero.  */
3413   p += strlen (p);
3414
3415   DIRED_INDENT ();
3416
3417   if (print_owner | print_group | print_author)
3418     {
3419       DIRED_FPUTS (buf, stdout, p - buf);
3420
3421       if (print_owner)
3422         format_user (f->stat.st_uid, owner_width, f->stat_ok);
3423
3424       if (print_group)
3425         format_group (f->stat.st_gid, group_width, f->stat_ok);
3426
3427       if (print_author)
3428         format_user (f->stat.st_author, author_width, f->stat_ok);
3429
3430       p = buf;
3431     }
3432
3433   if (f->stat_ok
3434       && (S_ISCHR (f->stat.st_mode) || S_ISBLK (f->stat.st_mode)))
3435     {
3436       char majorbuf[INT_BUFSIZE_BOUND (uintmax_t)];
3437       char minorbuf[INT_BUFSIZE_BOUND (uintmax_t)];
3438       int blanks_width = (file_size_width
3439                           - (major_device_number_width + 2
3440                              + minor_device_number_width));
3441       sprintf (p, "%*s, %*s ",
3442                major_device_number_width + MAX (0, blanks_width),
3443                umaxtostr (major (f->stat.st_rdev), majorbuf),
3444                minor_device_number_width,
3445                umaxtostr (minor (f->stat.st_rdev), minorbuf));
3446       p += file_size_width + 1;
3447     }
3448   else
3449     {
3450       char hbuf[LONGEST_HUMAN_READABLE + 1];
3451       char const *size =
3452         (! f->stat_ok
3453          ? "?"
3454          : human_readable (unsigned_file_size (f->stat.st_size),
3455                            hbuf, human_output_opts, 1, file_output_block_size));
3456       int pad;
3457       for (pad = file_size_width - mbswidth (size, 0); 0 < pad; pad--)
3458         *p++ = ' ';
3459       while ((*p++ = *size++))
3460         continue;
3461       p[-1] = ' ';
3462     }
3463
3464   when_local = localtime (&when_timespec.tv_sec);
3465   s = 0;
3466   *p = '\1';
3467
3468   if (f->stat_ok && when_local)
3469     {
3470       time_t six_months_ago;
3471       bool recent;
3472       char const *fmt;
3473
3474       /* If the file appears to be in the future, update the current
3475          time, in case the file happens to have been modified since
3476          the last time we checked the clock.  */
3477       if (current_time < when
3478           || (current_time == when && current_time_ns < when_ns))
3479         {
3480           /* Note that get_current_time calls gettimeofday which, on some non-
3481              compliant systems, clobbers the buffer used for localtime's result.
3482              But it's ok here, because we use a gettimeofday wrapper that
3483              saves and restores the buffer around the gettimeofday call.  */
3484           get_current_time ();
3485         }
3486
3487       /* Consider a time to be recent if it is within the past six
3488          months.  A Gregorian year has 365.2425 * 24 * 60 * 60 ==
3489          31556952 seconds on the average.  Write this value as an
3490          integer constant to avoid floating point hassles.  */
3491       six_months_ago = current_time - 31556952 / 2;
3492       recent = (six_months_ago <= when
3493                 && (when < current_time
3494                     || (when == current_time && when_ns <= current_time_ns)));
3495       fmt = long_time_format[recent];
3496
3497       s = nstrftime (p, TIME_STAMP_LEN_MAXIMUM + 1, fmt,
3498                      when_local, 0, when_ns);
3499     }
3500
3501   if (s || !*p)
3502     {
3503       p += s;
3504       *p++ = ' ';
3505
3506       /* NUL-terminate the string -- fputs (via DIRED_FPUTS) requires it.  */
3507       *p = '\0';
3508     }
3509   else
3510     {
3511       /* The time cannot be converted using the desired format, so
3512          print it as a huge integer number of seconds.  */
3513       char hbuf[INT_BUFSIZE_BOUND (intmax_t)];
3514       sprintf (p, "%*s ", long_time_expected_width (),
3515                (! f->stat_ok
3516                 ? "?"
3517                 : (TYPE_SIGNED (time_t)
3518                    ? imaxtostr (when, hbuf)
3519                    : umaxtostr (when, hbuf))));
3520       p += strlen (p);
3521     }
3522
3523   DIRED_FPUTS (buf, stdout, p - buf);
3524   print_name_with_quoting (f->name, FILE_OR_LINK_MODE (f), f->linkok,
3525                            f->stat_ok, f->filetype, &dired_obstack);
3526
3527   if (f->filetype == symbolic_link)
3528     {
3529       if (f->linkname)
3530         {
3531           DIRED_FPUTS_LITERAL (" -> ", stdout);
3532           print_name_with_quoting (f->linkname, f->linkmode, f->linkok - 1,
3533                                    f->stat_ok, f->filetype, NULL);
3534           if (indicator_style != none)
3535             print_type_indicator (true, f->linkmode, unknown);
3536         }
3537     }
3538   else if (indicator_style != none)
3539     print_type_indicator (f->stat_ok, f->stat.st_mode, f->filetype);
3540 }
3541
3542 /* Output to OUT a quoted representation of the file name NAME,
3543    using OPTIONS to control quoting.  Produce no output if OUT is NULL.
3544    Store the number of screen columns occupied by NAME's quoted
3545    representation into WIDTH, if non-NULL.  Return the number of bytes
3546    produced.  */
3547
3548 static size_t
3549 quote_name (FILE *out, const char *name, struct quoting_options const *options,
3550             size_t *width)
3551 {
3552   char smallbuf[BUFSIZ];
3553   size_t len = quotearg_buffer (smallbuf, sizeof smallbuf, name, -1, options);
3554   char *buf;
3555   size_t displayed_width IF_LINT (= 0);
3556
3557   if (len < sizeof smallbuf)
3558     buf = smallbuf;
3559   else
3560     {
3561       buf = alloca (len + 1);
3562       quotearg_buffer (buf, len + 1, name, -1, options);
3563     }
3564
3565   if (qmark_funny_chars)
3566     {
3567 #if HAVE_MBRTOWC
3568       if (MB_CUR_MAX > 1)
3569         {
3570           char const *p = buf;
3571           char const *plimit = buf + len;
3572           char *q = buf;
3573           displayed_width = 0;
3574
3575           while (p < plimit)
3576             switch (*p)
3577               {
3578                 case ' ': case '!': case '"': case '#': case '%':
3579                 case '&': case '\'': case '(': case ')': case '*':
3580                 case '+': case ',': case '-': case '.': case '/':
3581                 case '0': case '1': case '2': case '3': case '4':
3582                 case '5': case '6': case '7': case '8': case '9':
3583                 case ':': case ';': case '<': case '=': case '>':
3584                 case '?':
3585                 case 'A': case 'B': case 'C': case 'D': case 'E':
3586                 case 'F': case 'G': case 'H': case 'I': case 'J':
3587                 case 'K': case 'L': case 'M': case 'N': case 'O':
3588                 case 'P': case 'Q': case 'R': case 'S': case 'T':
3589                 case 'U': case 'V': case 'W': case 'X': case 'Y':
3590                 case 'Z':
3591                 case '[': case '\\': case ']': case '^': case '_':
3592                 case 'a': case 'b': case 'c': case 'd': case 'e':
3593                 case 'f': case 'g': case 'h': case 'i': case 'j':
3594                 case 'k': case 'l': case 'm': case 'n': case 'o':
3595                 case 'p': case 'q': case 'r': case 's': case 't':
3596                 case 'u': case 'v': case 'w': case 'x': case 'y':
3597                 case 'z': case '{': case '|': case '}': case '~':
3598                   /* These characters are printable ASCII characters.  */
3599                   *q++ = *p++;
3600                   displayed_width += 1;
3601                   break;
3602                 default:
3603                   /* If we have a multibyte sequence, copy it until we
3604                      reach its end, replacing each non-printable multibyte
3605                      character with a single question mark.  */
3606                   {
3607                     mbstate_t mbstate = { 0, };
3608                     do
3609                       {
3610                         wchar_t wc;
3611                         size_t bytes;
3612                         int w;
3613
3614                         bytes = mbrtowc (&wc, p, plimit - p, &mbstate);
3615
3616                         if (bytes == (size_t) -1)
3617                           {
3618                             /* An invalid multibyte sequence was
3619                                encountered.  Skip one input byte, and
3620                                put a question mark.  */
3621                             p++;
3622                             *q++ = '?';
3623                             displayed_width += 1;
3624                             break;
3625                           }
3626
3627                         if (bytes == (size_t) -2)
3628                           {
3629                             /* An incomplete multibyte character
3630                                at the end.  Replace it entirely with
3631                                a question mark.  */
3632                             p = plimit;
3633                             *q++ = '?';
3634                             displayed_width += 1;
3635                             break;
3636                           }
3637
3638                         if (bytes == 0)
3639                           /* A null wide character was encountered.  */
3640                           bytes = 1;
3641
3642                         w = wcwidth (wc);
3643                         if (w >= 0)
3644                           {
3645                             /* A printable multibyte character.
3646                                Keep it.  */
3647                             for (; bytes > 0; --bytes)
3648                               *q++ = *p++;
3649                             displayed_width += w;
3650                           }
3651                         else
3652                           {
3653                             /* An unprintable multibyte character.
3654                                Replace it entirely with a question
3655                                mark.  */
3656                             p += bytes;
3657                             *q++ = '?';
3658                             displayed_width += 1;
3659                           }
3660                       }
3661                     while (! mbsinit (&mbstate));
3662                   }
3663                   break;
3664               }
3665
3666           /* The buffer may have shrunk.  */
3667           len = q - buf;
3668         }
3669       else
3670 #endif
3671         {
3672           char *p = buf;
3673           char const *plimit = buf + len;
3674
3675           while (p < plimit)
3676             {
3677               if (! isprint (to_uchar (*p)))
3678                 *p = '?';
3679               p++;
3680             }
3681           displayed_width = len;
3682         }
3683     }
3684   else if (width != NULL)
3685     {
3686 #if HAVE_MBRTOWC
3687       if (MB_CUR_MAX > 1)
3688         displayed_width = mbsnwidth (buf, len, 0);
3689       else
3690 #endif
3691         {
3692           char const *p = buf;
3693           char const *plimit = buf + len;
3694
3695           displayed_width = 0;
3696           while (p < plimit)
3697             {
3698               if (isprint (to_uchar (*p)))
3699                 displayed_width++;
3700               p++;
3701             }
3702         }
3703     }
3704
3705   if (out != NULL)
3706     fwrite (buf, 1, len, out);
3707   if (width != NULL)
3708     *width = displayed_width;
3709   return len;
3710 }
3711
3712 static void
3713 print_name_with_quoting (const char *p, mode_t mode, int linkok,
3714                          bool stat_ok, enum filetype type,
3715                          struct obstack *stack)
3716 {
3717   if (print_with_color)
3718     print_color_indicator (p, mode, linkok, stat_ok, type);
3719
3720   if (stack)
3721     PUSH_CURRENT_DIRED_POS (stack);
3722
3723   dired_pos += quote_name (stdout, p, filename_quoting_options, NULL);
3724
3725   if (stack)
3726     PUSH_CURRENT_DIRED_POS (stack);
3727
3728   if (print_with_color)
3729     {
3730       process_signals ();
3731       prep_non_filename_text ();
3732     }
3733 }
3734
3735 static void
3736 prep_non_filename_text (void)
3737 {
3738   if (color_indicator[C_END].string != NULL)
3739     put_indicator (&color_indicator[C_END]);
3740   else
3741     {
3742       put_indicator (&color_indicator[C_LEFT]);
3743       put_indicator (&color_indicator[C_NORM]);
3744       put_indicator (&color_indicator[C_RIGHT]);
3745     }
3746 }
3747
3748 /* Print the file name of `f' with appropriate quoting.
3749    Also print file size, inode number, and filetype indicator character,
3750    as requested by switches.  */
3751
3752 static void
3753 print_file_name_and_frills (const struct fileinfo *f)
3754 {
3755   char buf[MAX (LONGEST_HUMAN_READABLE + 1, INT_BUFSIZE_BOUND (uintmax_t))];
3756
3757   if (print_inode)
3758     printf ("%*s ", format == with_commas ? 0 : inode_number_width,
3759             umaxtostr (f->stat.st_ino, buf));
3760
3761   if (print_block_size)
3762     printf ("%*s ", format == with_commas ? 0 : block_size_width,
3763             human_readable (ST_NBLOCKS (f->stat), buf, human_output_opts,
3764                             ST_NBLOCKSIZE, output_block_size));
3765
3766   print_name_with_quoting (f->name, FILE_OR_LINK_MODE (f), f->linkok,
3767                            f->stat_ok, f->filetype, NULL);
3768
3769   if (indicator_style != none)
3770     print_type_indicator (f->stat_ok, f->stat.st_mode, f->filetype);
3771 }
3772
3773 /* Given these arguments describing a file, return the single-byte
3774    type indicator, or 0.  */
3775 static char
3776 get_type_indicator (bool stat_ok, mode_t mode, enum filetype type)
3777 {
3778   char c;
3779
3780   if (stat_ok ? S_ISREG (mode) : type == normal)
3781     {
3782       if (stat_ok && indicator_style == classify && (mode & S_IXUGO))
3783         c = '*';
3784       else
3785         c = 0;
3786     }
3787   else
3788     {
3789       if (stat_ok ? S_ISDIR (mode) : type == directory || type == arg_directory)
3790         c = '/';
3791       else if (indicator_style == slash)
3792         c = 0;
3793       else if (stat_ok ? S_ISLNK (mode) : type == symbolic_link)
3794         c = '@';
3795       else if (stat_ok ? S_ISFIFO (mode) : type == fifo)
3796         c = '|';
3797       else if (stat_ok ? S_ISSOCK (mode) : type == sock)
3798         c = '=';
3799       else if (stat_ok && S_ISDOOR (mode))
3800         c = '>';
3801       else
3802         c = 0;
3803     }
3804   return c;
3805 }
3806
3807 static void
3808 print_type_indicator (bool stat_ok, mode_t mode, enum filetype type)
3809 {
3810   char c = get_type_indicator (stat_ok, mode, type);
3811   if (c)
3812     DIRED_PUTCHAR (c);
3813 }
3814
3815 static void
3816 print_color_indicator (const char *name, mode_t mode, int linkok,
3817                        bool stat_ok, enum filetype filetype)
3818 {
3819   int type;
3820   struct color_ext_type *ext;   /* Color extension */
3821   size_t len;                   /* Length of name */
3822
3823   /* Is this a nonexistent file?  If so, linkok == -1.  */
3824
3825   if (linkok == -1 && color_indicator[C_MISSING].string != NULL)
3826     type = C_MISSING;
3827   else if (! stat_ok)
3828     {
3829       static enum indicator_no filetype_indicator[] = FILETYPE_INDICATORS;
3830       type = filetype_indicator[filetype];
3831     }
3832   else
3833     {
3834       if (S_ISREG (mode))
3835         {
3836           type = C_FILE;
3837           if ((mode & S_ISUID) != 0)
3838             type = C_SETUID;
3839           else if ((mode & S_ISGID) != 0)
3840             type = C_SETGID;
3841           else if ((mode & S_IXUGO) != 0)
3842             type = C_EXEC;
3843         }
3844       else if (S_ISDIR (mode))
3845         {
3846           if ((mode & S_ISVTX) && (mode & S_IWOTH))
3847             type = C_STICKY_OTHER_WRITABLE;
3848           else if ((mode & S_IWOTH) != 0)
3849             type = C_OTHER_WRITABLE;
3850           else if ((mode & S_ISVTX) != 0)
3851             type = C_STICKY;
3852           else
3853             type = C_DIR;
3854         }
3855       else if (S_ISLNK (mode))
3856         type = ((!linkok && color_indicator[C_ORPHAN].string)
3857                 ? C_ORPHAN : C_LINK);
3858       else if (S_ISFIFO (mode))
3859         type = C_FIFO;
3860       else if (S_ISSOCK (mode))
3861         type = C_SOCK;
3862       else if (S_ISBLK (mode))
3863         type = C_BLK;
3864       else if (S_ISCHR (mode))
3865         type = C_CHR;
3866       else if (S_ISDOOR (mode))
3867         type = C_DOOR;
3868       else
3869         {
3870           /* Classify a file of some other type as C_ORPHAN.  */
3871           type = C_ORPHAN;
3872         }
3873     }
3874
3875   /* Check the file's suffix only if still classified as C_FILE.  */
3876   ext = NULL;
3877   if (type == C_FILE)
3878     {
3879       /* Test if NAME has a recognized suffix.  */
3880
3881       len = strlen (name);
3882       name += len;              /* Pointer to final \0.  */
3883       for (ext = color_ext_list; ext != NULL; ext = ext->next)
3884         {
3885           if (ext->ext.len <= len
3886               && strncmp (name - ext->ext.len, ext->ext.string,
3887                           ext->ext.len) == 0)
3888             break;
3889         }
3890     }
3891
3892   put_indicator (&color_indicator[C_LEFT]);
3893   put_indicator (ext ? &(ext->seq) : &color_indicator[type]);
3894   put_indicator (&color_indicator[C_RIGHT]);
3895 }
3896
3897 /* Output a color indicator (which may contain nulls).  */
3898 static void
3899 put_indicator (const struct bin_str *ind)
3900 {
3901   size_t i;
3902   const char *p;
3903
3904   p = ind->string;
3905
3906   for (i = ind->len; i != 0; --i)
3907     putchar (*(p++));
3908 }
3909
3910 static size_t
3911 length_of_file_name_and_frills (const struct fileinfo *f)
3912 {
3913   size_t len = 0;
3914   size_t name_width;
3915   char buf[MAX (LONGEST_HUMAN_READABLE + 1, INT_BUFSIZE_BOUND (uintmax_t))];
3916
3917   if (print_inode)
3918     len += 1 + (format == with_commas
3919                 ? strlen (umaxtostr (f->stat.st_ino, buf))
3920                 : inode_number_width);
3921
3922   if (print_block_size)
3923     len += 1 + (format == with_commas
3924                 ? strlen (human_readable (ST_NBLOCKS (f->stat), buf,
3925                                           human_output_opts, ST_NBLOCKSIZE,
3926                                           output_block_size))
3927                 : block_size_width);
3928
3929   quote_name (NULL, f->name, filename_quoting_options, &name_width);
3930   len += name_width;
3931
3932   if (indicator_style != none)
3933     {
3934       char c = get_type_indicator (f->stat_ok, f->stat.st_mode, f->filetype);
3935       len += (c != 0);
3936     }
3937
3938   return len;
3939 }
3940
3941 static void
3942 print_many_per_line (void)
3943 {
3944   size_t row;                   /* Current row.  */
3945   size_t cols = calculate_columns (true);
3946   struct column_info const *line_fmt = &column_info[cols - 1];
3947
3948   /* Calculate the number of rows that will be in each column except possibly
3949      for a short column on the right.  */
3950   size_t rows = files_index / cols + (files_index % cols != 0);
3951
3952   for (row = 0; row < rows; row++)
3953     {
3954       size_t col = 0;
3955       size_t filesno = row;
3956       size_t pos = 0;
3957
3958       /* Print the next row.  */
3959       while (1)
3960         {
3961           size_t name_length = length_of_file_name_and_frills (files + filesno);
3962           size_t max_name_length = line_fmt->col_arr[col++];
3963           print_file_name_and_frills (files + filesno);
3964
3965           filesno += rows;
3966           if (filesno >= files_index)
3967             break;
3968
3969           indent (pos + name_length, pos + max_name_length);
3970           pos += max_name_length;
3971         }
3972       putchar ('\n');
3973     }
3974 }
3975
3976 static void
3977 print_horizontal (void)
3978 {
3979   size_t filesno;
3980   size_t pos = 0;
3981   size_t cols = calculate_columns (false);
3982   struct column_info const *line_fmt = &column_info[cols - 1];
3983   size_t name_length = length_of_file_name_and_frills (files);
3984   size_t max_name_length = line_fmt->col_arr[0];
3985
3986   /* Print first entry.  */
3987   print_file_name_and_frills (files);
3988
3989   /* Now the rest.  */
3990   for (filesno = 1; filesno < files_index; ++filesno)
3991     {
3992       size_t col = filesno % cols;
3993
3994       if (col == 0)
3995         {
3996           putchar ('\n');
3997           pos = 0;
3998         }
3999       else
4000         {
4001           indent (pos + name_length, pos + max_name_length);
4002           pos += max_name_length;
4003         }
4004
4005       print_file_name_and_frills (files + filesno);
4006
4007       name_length = length_of_file_name_and_frills (files + filesno);
4008       max_name_length = line_fmt->col_arr[col];
4009     }
4010   putchar ('\n');
4011 }
4012
4013 static void
4014 print_with_commas (void)
4015 {
4016   size_t filesno;
4017   size_t pos = 0;
4018
4019   for (filesno = 0; filesno < files_index; filesno++)
4020     {
4021       size_t len = length_of_file_name_and_frills (files + filesno);
4022
4023       if (filesno != 0)
4024         {
4025           char separator;
4026
4027           if (pos + len + 2 < line_length)
4028             {
4029               pos += 2;
4030               separator = ' ';
4031             }
4032           else
4033             {
4034               pos = 0;
4035               separator = '\n';
4036             }
4037
4038           putchar (',');
4039           putchar (separator);
4040         }
4041
4042       print_file_name_and_frills (files + filesno);
4043       pos += len;
4044     }
4045   putchar ('\n');
4046 }
4047
4048 /* Assuming cursor is at position FROM, indent up to position TO.
4049    Use a TAB character instead of two or more spaces whenever possible.  */
4050
4051 static void
4052 indent (size_t from, size_t to)
4053 {
4054   while (from < to)
4055     {
4056       if (tabsize != 0 && to / tabsize > (from + 1) / tabsize)
4057         {
4058           putchar ('\t');
4059           from += tabsize - from % tabsize;
4060         }
4061       else
4062         {
4063           putchar (' ');
4064           from++;
4065         }
4066     }
4067 }
4068
4069 /* Put DIRNAME/NAME into DEST, handling `.' and `/' properly.  */
4070 /* FIXME: maybe remove this function someday.  See about using a
4071    non-malloc'ing version of file_name_concat.  */
4072
4073 static void
4074 attach (char *dest, const char *dirname, const char *name)
4075 {
4076   const char *dirnamep = dirname;
4077
4078   /* Copy dirname if it is not ".".  */
4079   if (dirname[0] != '.' || dirname[1] != 0)
4080     {
4081       while (*dirnamep)
4082         *dest++ = *dirnamep++;
4083       /* Add '/' if `dirname' doesn't already end with it.  */
4084       if (dirnamep > dirname && dirnamep[-1] != '/')
4085         *dest++ = '/';
4086     }
4087   while (*name)
4088     *dest++ = *name++;
4089   *dest = 0;
4090 }
4091
4092 /* Allocate enough column info suitable for the current number of
4093    files and display columns, and initialize the info to represent the
4094    narrowest possible columns.  */
4095
4096 static void
4097 init_column_info (void)
4098 {
4099   size_t i;
4100   size_t max_cols = MIN (max_idx, files_index);
4101
4102   /* Currently allocated columns in column_info.  */
4103   static size_t column_info_alloc;
4104
4105   if (column_info_alloc < max_cols)
4106     {
4107       size_t new_column_info_alloc;
4108       size_t *p;
4109
4110       if (max_cols < max_idx / 2)
4111         {
4112           /* The number of columns is far less than the display width
4113              allows.  Grow the allocation, but only so that it's
4114              double the current requirements.  If the display is
4115              extremely wide, this avoids allocating a lot of memory
4116              that is never needed.  */
4117           column_info = xnrealloc (column_info, max_cols,
4118                                    2 * sizeof *column_info);
4119           new_column_info_alloc = 2 * max_cols;
4120         }
4121       else
4122         {
4123           column_info = xnrealloc (column_info, max_idx, sizeof *column_info);
4124           new_column_info_alloc = max_idx;
4125         }
4126
4127       /* Allocate the new size_t objects by computing the triangle
4128          formula n * (n + 1) / 2, except that we don't need to
4129          allocate the part of the triangle that we've already
4130          allocated.  Check for address arithmetic overflow.  */
4131       {
4132         size_t column_info_growth = new_column_info_alloc - column_info_alloc;
4133         size_t s = column_info_alloc + 1 + new_column_info_alloc;
4134         size_t t = s * column_info_growth;
4135         if (s < new_column_info_alloc || t / column_info_growth != s)
4136           xalloc_die ();
4137         p = xnmalloc (t / 2, sizeof *p);
4138       }
4139
4140       /* Grow the triangle by parceling out the cells just allocated.  */
4141       for (i = column_info_alloc; i < new_column_info_alloc; i++)
4142         {
4143           column_info[i].col_arr = p;
4144           p += i + 1;
4145         }
4146
4147       column_info_alloc = new_column_info_alloc;
4148     }
4149
4150   for (i = 0; i < max_cols; ++i)
4151     {
4152       size_t j;
4153
4154       column_info[i].valid_len = true;
4155       column_info[i].line_len = (i + 1) * MIN_COLUMN_WIDTH;
4156       for (j = 0; j <= i; ++j)
4157         column_info[i].col_arr[j] = MIN_COLUMN_WIDTH;
4158     }
4159 }
4160
4161 /* Calculate the number of columns needed to represent the current set
4162    of files in the current display width.  */
4163
4164 static size_t
4165 calculate_columns (bool by_columns)
4166 {
4167   size_t filesno;               /* Index into files.  */
4168   size_t cols;                  /* Number of files across.  */
4169
4170   /* Normally the maximum number of columns is determined by the
4171      screen width.  But if few files are available this might limit it
4172      as well.  */
4173   size_t max_cols = MIN (max_idx, files_index);
4174
4175   init_column_info ();
4176
4177   /* Compute the maximum number of possible columns.  */
4178   for (filesno = 0; filesno < files_index; ++filesno)
4179     {
4180       size_t name_length = length_of_file_name_and_frills (files + filesno);
4181       size_t i;
4182
4183       for (i = 0; i < max_cols; ++i)
4184         {
4185           if (column_info[i].valid_len)
4186             {
4187               size_t idx = (by_columns
4188                             ? filesno / ((files_index + i) / (i + 1))
4189                             : filesno % (i + 1));
4190               size_t real_length = name_length + (idx == i ? 0 : 2);
4191
4192               if (column_info[i].col_arr[idx] < real_length)
4193                 {
4194                   column_info[i].line_len += (real_length
4195                                               - column_info[i].col_arr[idx]);
4196                   column_info[i].col_arr[idx] = real_length;
4197                   column_info[i].valid_len = (column_info[i].line_len
4198                                               < line_length);
4199                 }
4200             }
4201         }
4202     }
4203
4204   /* Find maximum allowed columns.  */
4205   for (cols = max_cols; 1 < cols; --cols)
4206     {
4207       if (column_info[cols - 1].valid_len)
4208         break;
4209     }
4210
4211   return cols;
4212 }
4213
4214 void
4215 usage (int status)
4216 {
4217   if (status != EXIT_SUCCESS)
4218     fprintf (stderr, _("Try `%s --help' for more information.\n"),
4219              program_name);
4220   else
4221     {
4222       printf (_("Usage: %s [OPTION]... [FILE]...\n"), program_name);
4223       fputs (_("\
4224 List information about the FILEs (the current directory by default).\n\
4225 Sort entries alphabetically if none of -cftuvSUX nor --sort.\n\
4226 \n\
4227 "), stdout);
4228       fputs (_("\
4229 Mandatory arguments to long options are mandatory for short options too.\n\
4230 "), stdout);
4231       fputs (_("\
4232   -a, --all                  do not ignore entries starting with .\n\
4233   -A, --almost-all           do not list implied . and ..\n\
4234       --author               with -l, print the author of each file\n\
4235   -b, --escape               print octal escapes for nongraphic characters\n\
4236 "), stdout);
4237       fputs (_("\
4238       --block-size=SIZE      use SIZE-byte blocks\n\
4239   -B, --ignore-backups       do not list implied entries ending with ~\n\
4240   -c                         with -lt: sort by, and show, ctime (time of last\n\
4241                                modification of file status information)\n\
4242                                with -l: show ctime and sort by name\n\
4243                                otherwise: sort by ctime\n\
4244 "), stdout);
4245       fputs (_("\
4246   -C                         list entries by columns\n\
4247       --color[=WHEN]         control whether color is used to distinguish file\n\
4248                                types.  WHEN may be `never', `always', or `auto'\n\
4249   -d, --directory            list directory entries instead of contents,\n\
4250                                and do not dereference symbolic links\n\
4251   -D, --dired                generate output designed for Emacs' dired mode\n\
4252 "), stdout);
4253       fputs (_("\
4254   -f                         do not sort, enable -aU, disable -ls --color\n\
4255   -F, --classify             append indicator (one of */=>@|) to entries\n\
4256       --file-type            likewise, except do not append `*'\n\
4257       --format=WORD          across -x, commas -m, horizontal -x, long -l,\n\
4258                                single-column -1, verbose -l, vertical -C\n\
4259       --full-time            like -l --time-style=full-iso\n\
4260 "), stdout);
4261       fputs (_("\
4262   -g                         like -l, but do not list owner\n\
4263 "), stdout);
4264       fputs (_("\
4265       --group-directories-first\n\
4266                              group directories before files\n\
4267 "), stdout);
4268       fputs (_("\
4269   -G, --no-group             in a long listing, don't print group names\n\
4270   -h, --human-readable       with -l, print sizes in human readable format\n\
4271                                (e.g., 1K 234M 2G)\n\
4272       --si                   likewise, but use powers of 1000 not 1024\n\
4273 "), stdout);
4274       fputs (_("\
4275   -H, --dereference-command-line\n\
4276                              follow symbolic links listed on the command line\n\
4277       --dereference-command-line-symlink-to-dir\n\
4278                              follow each command line symbolic link\n\
4279                              that points to a directory\n\
4280       --hide=PATTERN         do not list implied entries matching shell PATTERN\n\
4281                                (overridden by -a or -A)\n\
4282 "), stdout);
4283       fputs (_("\
4284       --indicator-style=WORD append indicator with style WORD to entry names:\n\
4285                                none (default), slash (-p),\n\
4286                                file-type (--file-type), classify (-F)\n\
4287   -i, --inode                print the index number of each file\n\
4288   -I, --ignore=PATTERN       do not list implied entries matching shell PATTERN\n\
4289   -k                         like --block-size=1K\n\
4290 "), stdout);
4291       fputs (_("\
4292   -l                         use a long listing format\n\
4293   -L, --dereference          when showing file information for a symbolic\n\
4294                                link, show information for the file the link\n\
4295                                references rather than for the link itself\n\
4296   -m                         fill width with a comma separated list of entries\n\
4297 "), stdout);
4298       fputs (_("\
4299   -n, --numeric-uid-gid      like -l, but list numeric user and group IDs\n\
4300   -N, --literal              print raw entry names (don't treat e.g. control\n\
4301                                characters specially)\n\
4302   -o                         like -l, but do not list group information\n\
4303   -p, --indicator-style=slash\n\
4304                              append / indicator to directories\n\
4305 "), stdout);
4306       fputs (_("\
4307   -q, --hide-control-chars   print ? instead of non graphic characters\n\
4308       --show-control-chars   show non graphic characters as-is (default\n\
4309                              unless program is `ls' and output is a terminal)\n\
4310   -Q, --quote-name           enclose entry names in double quotes\n\
4311       --quoting-style=WORD   use quoting style WORD for entry names:\n\
4312                                literal, locale, shell, shell-always, c, escape\n\
4313 "), stdout);
4314       fputs (_("\
4315   -r, --reverse              reverse order while sorting\n\
4316   -R, --recursive            list subdirectories recursively\n\
4317   -s, --size                 print the size of each file, in blocks\n\
4318 "), stdout);
4319       fputs (_("\
4320   -S                         sort by file size\n\
4321       --sort=WORD            sort by WORD instead of name: none -U,\n\
4322                              extension -X, size -S, time -t, version -v\n\
4323       --time=WORD            with -l, show time as WORD instead of modification\n\
4324                              time: atime -u, access -u, use -u, ctime -c,\n\
4325                              or status -c; use specified time as sort key\n\
4326                              if --sort=time\n\
4327 "), stdout);
4328       fputs (_("\
4329       --time-style=STYLE     with -l, show times using style STYLE:\n\
4330                              full-iso, long-iso, iso, locale, +FORMAT.\n\
4331                              FORMAT is interpreted like `date'; if FORMAT is\n\
4332                              FORMAT1<newline>FORMAT2, FORMAT1 applies to\n\
4333                              non-recent files and FORMAT2 to recent files;\n\
4334                              if STYLE is prefixed with `posix-', STYLE\n\
4335                              takes effect only outside the POSIX locale\n\
4336 "), stdout);
4337       fputs (_("\
4338   -t                         sort by modification time\n\
4339   -T, --tabsize=COLS         assume tab stops at each COLS instead of 8\n\
4340 "), stdout);
4341       fputs (_("\
4342   -u                         with -lt: sort by, and show, access time\n\
4343                                with -l: show access time and sort by name\n\
4344                                otherwise: sort by access time\n\
4345   -U                         do not sort; list entries in directory order\n\
4346   -v                         sort by version\n\
4347 "), stdout);
4348       fputs (_("\
4349   -w, --width=COLS           assume screen width instead of current value\n\
4350   -x                         list entries by lines instead of by columns\n\
4351   -X                         sort alphabetically by entry extension\n\
4352   -1                         list one file per line\n\
4353 "), stdout);
4354       fputs (HELP_OPTION_DESCRIPTION, stdout);
4355       fputs (VERSION_OPTION_DESCRIPTION, stdout);
4356       fputs (_("\n\
4357 SIZE may be (or may be an integer optionally followed by) one of following:\n\
4358 kB 1000, K 1024, MB 1000*1000, M 1024*1024, and so on for G, T, P, E, Z, Y.\n\
4359 "), stdout);
4360       fputs (_("\
4361 \n\
4362 By default, color is not used to distinguish types of files.  That is\n\
4363 equivalent to using --color=none.  Using the --color option without the\n\
4364 optional WHEN argument is equivalent to using --color=always.  With\n\
4365 --color=auto, color codes are output only if standard output is connected\n\
4366 to a terminal (tty).  The environment variable LS_COLORS can influence the\n\
4367 colors, and can be set easily by the dircolors command.\n\
4368 "), stdout);
4369       fputs (_("\
4370 \n\
4371 Exit status is 0 if OK, 1 if minor problems, 2 if serious trouble.\n\
4372 "), stdout);
4373       printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
4374     }
4375   exit (status);
4376 }