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