src/ls.c

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