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