1 /* `dir', `vdir' and `ls' directory listing programs for GNU.
2 Copyright (C) 85, 88, 90, 91, 1995-2006 Free Software Foundation, Inc.
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)
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.
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. */
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.
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.
29 the output format depends on whether the output
31 This is for the `ls' program. */
33 /* Written by Richard Stallman and David MacKenzie. */
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>. */
40 #include <sys/types.h>
49 # include <sys/ioctl.h>
52 #ifdef WINSIZE_IN_PTEM
53 # include <sys/stream.h>
54 # include <sys/ptem.h>
65 /* Use SA_NOCLDSTOP as a proxy for whether the sigaction machinery is
68 # define SA_NOCLDSTOP 0
69 # define sigprocmask(How, Set, Oset) /* empty */
71 # if ! HAVE_SIGINTERRUPT
72 # define siginterrupt(sig, flag) /* empty */
76 /* Get mbstate_t, mbrtowc(), mbsinit(), wcwidth(). */
85 #if !defined iswprint && !HAVE_ISWPRINT
86 # define iswprint(wc) 1
89 #ifndef HAVE_DECL_WCWIDTH
90 "this configure-time declaration test was not run"
92 #if !HAVE_DECL_WCWIDTH
96 /* If wcwidth() doesn't exist, assume all printable characters have
100 # define wcwidth(wc) ((wc) == 0 ? 0 : iswprint (wc) ? 1 : -1)
108 #include "argmatch.h"
113 #include "filenamecat.h"
114 #include "hard-locale.h"
117 #include "filemode.h"
118 #include "inttostr.h"
121 #include "mbswidth.h"
124 #include "quotearg.h"
126 #include "stat-time.h"
127 #include "strftime.h"
128 #include "strverscmp.h"
130 #include "xreadlink.h"
132 #define PROGRAM_NAME (ls_mode == LS_LS ? "ls" \
133 : (ls_mode == LS_MULTI_COL \
136 #define AUTHORS "Richard Stallman", "David MacKenzie"
138 #define obstack_chunk_alloc malloc
139 #define obstack_chunk_free free
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))
145 #if HAVE_STRUCT_DIRENT_D_TYPE && defined DTTOIF
146 # define DT_INIT(Val) = Val
148 # define DT_INIT(Val) /* empty */
151 #if ! HAVE_STRUCT_STAT_ST_AUTHOR
152 # define st_author st_uid
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)),
178 /* For symbolic link, name of the file linked to, otherwise zero. */
181 /* For symbolic link and long listing, st_mode of file linked to, otherwise
185 /* For symbolic link and color printing, true if linked-to file
186 exists, otherwise false. */
189 enum filetype filetype;
192 /* For long listings, true if the file has an access control list. */
198 # define FILE_HAS_ACL(F) ((F)->have_acl)
200 # define FILE_HAS_ACL(F) 0
203 #define LEN_STR_PAIR(s) sizeof (s) - 1, s
205 /* Null is a valid character in a color indicator (think about Epson
206 printers, for example) so we have to use a length/buffer string
211 size_t len; /* Number of bytes */
212 const char *string; /* Pointer to the same */
219 # define tcgetpgrp(Fd) 0
222 static size_t quote_name (FILE *out, const char *name,
223 struct quoting_options const *options,
225 static char *make_link_name (char const *name, char const *linkname);
226 static int decode_switches (int argc, char **argv);
227 static bool file_ignored (char const *name);
228 static uintmax_t gobble_file (char const *name, enum filetype type,
229 ino_t inode, bool command_line_arg,
230 char const *dirname);
231 static void print_color_indicator (const char *name, mode_t mode, int linkok,
233 static void put_indicator (const struct bin_str *ind);
234 static void add_ignore_pattern (const char *pattern);
235 static void attach (char *dest, const char *dirname, const char *name);
236 static void clear_files (void);
237 static void extract_dirs_from_files (char const *dirname,
238 bool command_line_arg);
239 static void get_link_name (char const *filename, struct fileinfo *f,
240 bool command_line_arg);
241 static void indent (size_t from, size_t to);
242 static size_t calculate_columns (bool by_columns);
243 static void print_current_files (void);
244 static void print_dir (char const *name, char const *realname,
245 bool command_line_arg);
246 static void print_file_name_and_frills (const struct fileinfo *f);
247 static void print_horizontal (void);
248 static int format_user_width (uid_t u);
249 static int format_group_width (gid_t g);
250 static void print_long_format (const struct fileinfo *f);
251 static void print_many_per_line (void);
252 static void print_name_with_quoting (const char *p, mode_t mode,
253 int linkok, int stat_failed,
254 struct obstack *stack);
255 static void prep_non_filename_text (void);
256 static void print_type_indicator (mode_t mode);
257 static void print_with_commas (void);
258 static void queue_directory (char const *name, char const *realname,
259 bool command_line_arg);
260 static void sort_files (void);
261 static void parse_ls_color (void);
262 void usage (int status);
264 /* The name this program was run with. */
267 /* Initial size of hash table.
268 Most hierarchies are likely to be shallower than this. */
269 #define INITIAL_TABLE_SIZE 30
271 /* The set of `active' directories, from the current command-line argument
272 to the level in the hierarchy at which files are being listed.
273 A directory is represented by its device and inode numbers (struct dev_ino).
274 A directory is added to this set when ls begins listing it or its
275 entries, and it is removed from the set just after ls has finished
276 processing it. This set is used solely to detect loops, e.g., with
277 mkdir loop; cd loop; ln -s ../loop sub; ls -RL */
278 static Hash_table *active_dir_set;
280 #define LOOP_DETECT (!!active_dir_set)
282 /* The table of files in the current directory:
284 `files' points to a vector of `struct fileinfo', one per file.
285 `nfiles' is the number of elements space has been allocated for.
286 `files_index' is the number actually in use. */
288 /* Address of block containing the files that are described. */
289 static struct fileinfo *files; /* FIXME: rename this to e.g. cwd_file */
291 /* Length of block that `files' points to, measured in files. */
292 static size_t nfiles; /* FIXME: rename this to e.g. cwd_n_alloc */
294 /* Index of first unused in `files'. */
295 static size_t files_index; /* FIXME: rename this to e.g. cwd_n_used */
297 /* When true, in a color listing, color each symlink name according to the
298 type of file it points to. Otherwise, color them according to the `ln'
299 directive in LS_COLORS. Dangling (orphan) symlinks are treated specially,
300 regardless. This is set when `ln=target' appears in LS_COLORS. */
302 static bool color_symlink_as_referent;
304 /* mode of appropriate file for colorization */
305 #define FILE_OR_LINK_MODE(File) \
306 ((color_symlink_as_referent & (File)->linkok) \
307 ? (File)->linkmode : (File)->stat.st_mode)
310 /* Record of one pending directory waiting to be listed. */
315 /* If the directory is actually the file pointed to by a symbolic link we
316 were told to list, `realname' will contain the name of the symbolic
317 link, otherwise zero. */
319 bool command_line_arg;
320 struct pending *next;
323 static struct pending *pending_dirs;
325 /* Current time in seconds and nanoseconds since 1970, updated as
326 needed when deciding whether a file is recent. */
328 static time_t current_time = TYPE_MINIMUM (time_t);
329 static int current_time_ns = -1;
331 /* Whether any of the files has an ACL. This affects the width of the
335 static bool any_has_acl;
337 enum { any_has_acl = false };
340 /* The number of columns to use for columns containing inode numbers,
341 block sizes, link counts, owners, groups, authors, major device
342 numbers, minor device numbers, and file sizes, respectively. */
344 static int inode_number_width;
345 static int block_size_width;
346 static int nlink_width;
347 static int owner_width;
348 static int group_width;
349 static int author_width;
350 static int major_device_number_width;
351 static int minor_device_number_width;
352 static int file_size_width;
356 /* long_format for lots of info, one per line.
357 one_per_line for just names, one per line.
358 many_per_line for just names, many per line, sorted vertically.
359 horizontal for just names, many per line, sorted horizontally.
360 with_commas for just names, many per line, separated by commas.
362 -l (and other options that imply -l), -1, -C, -x and -m control
367 long_format, /* -l and other options that imply -l */
368 one_per_line, /* -1 */
369 many_per_line, /* -C */
374 static enum format format;
376 /* `full-iso' uses full ISO-style dates and times. `long-iso' uses longer
377 ISO-style time stamps, though shorter than `full-iso'. `iso' uses shorter
378 ISO-style time stamps. `locale' uses locale-dependent time stamps. */
381 full_iso_time_style, /* --time-style=full-iso */
382 long_iso_time_style, /* --time-style=long-iso */
383 iso_time_style, /* --time-style=iso */
384 locale_time_style /* --time-style=locale */
387 static char const *const time_style_args[] =
389 "full-iso", "long-iso", "iso", "locale", NULL
391 static enum time_style const time_style_types[] =
393 full_iso_time_style, long_iso_time_style, iso_time_style,
396 ARGMATCH_VERIFY (time_style_args, time_style_types);
398 /* Type of time to print or sort by. Controlled by -c and -u.
399 The values of each item of this enum are important since they are
400 used as indices in the sort functions array (see sort_files()). */
404 time_mtime, /* default */
407 time_numtypes /* the number of elements of this enum */
410 static enum time_type time_type;
412 /* The file characteristic to sort by. Controlled by -t, -S, -U, -X, -v.
413 The values of each item of this enum are important since they are
414 used as indices in the sort functions array (see sort_files()). */
418 sort_none = -1, /* -U */
419 sort_name, /* default */
420 sort_extension, /* -X */
422 sort_version, /* -v */
424 sort_numtypes /* the number of elements of this enum */
427 static enum sort_type sort_type;
429 /* Direction of sort.
430 false means highest first if numeric,
431 lowest first if alphabetic;
432 these are the defaults.
433 true means the opposite order in each case. -r */
435 static bool sort_reverse;
437 /* True means to display owner information. -g turns this off. */
439 static bool print_owner = true;
441 /* True means to display author information. */
443 static bool print_author;
445 /* True means to display group information. -G and -o turn this off. */
447 static bool print_group = true;
449 /* True means print the user and group id's as numbers rather
452 static bool numeric_ids;
454 /* True means mention the size in blocks of each file. -s */
456 static bool print_block_size;
458 /* Human-readable options for output. */
459 static int human_output_opts;
461 /* The units to use when printing sizes other than file sizes. */
462 static uintmax_t output_block_size;
464 /* Likewise, but for file sizes. */
465 static uintmax_t file_output_block_size = 1;
467 /* Follow the output with a special string. Using this format,
468 Emacs' dired mode starts up twice as fast, and can handle all
469 strange characters in file names. */
472 /* `none' means don't mention the type of files.
473 `slash' means mention directories only, with a '/'.
474 `file_type' means mention file types.
475 `classify' means mention file types and mark executables.
477 Controlled by -F, -p, and --indicator-style. */
481 none, /* --indicator-style=none */
482 slash, /* -p, --indicator-style=slash */
483 file_type, /* --indicator-style=file-type */
484 classify /* -F, --indicator-style=classify */
487 static enum indicator_style indicator_style;
489 /* Names of indicator styles. */
490 static char const *const indicator_style_args[] =
492 "none", "slash", "file-type", "classify", NULL
494 static enum indicator_style const indicator_style_types[] =
496 none, slash, file_type, classify
498 ARGMATCH_VERIFY (indicator_style_args, indicator_style_types);
500 /* True means use colors to mark types. Also define the different
501 colors as well as the stuff for the LS_COLORS environment variable.
502 The LS_COLORS variable is now in a termcap-like format. */
504 static bool print_with_color;
508 color_never, /* 0: default or --color=never */
509 color_always, /* 1: --color=always */
510 color_if_tty /* 2: --color=tty */
513 enum Dereference_symlink
517 DEREF_COMMAND_LINE_ARGUMENTS, /* -H */
518 DEREF_COMMAND_LINE_SYMLINK_TO_DIR, /* the default, in certain cases */
519 DEREF_ALWAYS /* -L */
524 C_LEFT, C_RIGHT, C_END, C_NORM, C_FILE, C_DIR, C_LINK, C_FIFO, C_SOCK,
525 C_BLK, C_CHR, C_MISSING, C_ORPHAN, C_EXEC, C_DOOR, C_SETUID, C_SETGID,
526 C_STICKY, C_OTHER_WRITABLE, C_STICKY_OTHER_WRITABLE
529 static const char *const indicator_name[]=
531 "lc", "rc", "ec", "no", "fi", "di", "ln", "pi", "so",
532 "bd", "cd", "mi", "or", "ex", "do", "su", "sg", "st",
536 struct color_ext_type
538 struct bin_str ext; /* The extension we're looking for */
539 struct bin_str seq; /* The sequence to output when we do */
540 struct color_ext_type *next; /* Next in list */
543 static struct bin_str color_indicator[] =
545 { LEN_STR_PAIR ("\033[") }, /* lc: Left of color sequence */
546 { LEN_STR_PAIR ("m") }, /* rc: Right of color sequence */
547 { 0, NULL }, /* ec: End color (replaces lc+no+rc) */
548 { LEN_STR_PAIR ("0") }, /* no: Normal */
549 { LEN_STR_PAIR ("0") }, /* fi: File: default */
550 { LEN_STR_PAIR ("01;34") }, /* di: Directory: bright blue */
551 { LEN_STR_PAIR ("01;36") }, /* ln: Symlink: bright cyan */
552 { LEN_STR_PAIR ("33") }, /* pi: Pipe: yellow/brown */
553 { LEN_STR_PAIR ("01;35") }, /* so: Socket: bright magenta */
554 { LEN_STR_PAIR ("01;33") }, /* bd: Block device: bright yellow */
555 { LEN_STR_PAIR ("01;33") }, /* cd: Char device: bright yellow */
556 { 0, NULL }, /* mi: Missing file: undefined */
557 { 0, NULL }, /* or: Orphaned symlink: undefined */
558 { LEN_STR_PAIR ("01;32") }, /* ex: Executable: bright green */
559 { LEN_STR_PAIR ("01;35") }, /* do: Door: bright magenta */
560 { LEN_STR_PAIR ("37;41") }, /* su: setuid: white on red */
561 { LEN_STR_PAIR ("30;43") }, /* sg: setgid: black on yellow */
562 { LEN_STR_PAIR ("37;44") }, /* st: sticky: black on blue */
563 { LEN_STR_PAIR ("34;42") }, /* ow: other-writable: blue on green */
564 { LEN_STR_PAIR ("30;42") }, /* tw: ow w/ sticky: black on green */
568 static struct color_ext_type *color_ext_list = NULL;
570 /* Buffer for color sequences */
571 static char *color_buf;
573 /* True means to check for orphaned symbolic link, for displaying
576 static bool check_symlink_color;
578 /* True means mention the inode number of each file. -i */
580 static bool print_inode;
582 /* What to do with symbolic links. Affected by -d, -F, -H, -l (and
583 other options that imply -l), and -L. */
585 static enum Dereference_symlink dereference;
587 /* True means when a directory is found, display info on its
590 static bool recursive;
592 /* True means when an argument is a directory name, display info
595 static bool immediate_dirs;
597 /* True means that directories are grouped before files. */
599 static bool directories_first;
601 /* Which files to ignore. */
605 /* Ignore files whose names start with `.', and files specified by
606 --hide and --ignore. */
609 /* Ignore `.', `..', and files specified by --ignore. */
610 IGNORE_DOT_AND_DOTDOT,
612 /* Ignore only files specified by --ignore. */
616 /* A linked list of shell-style globbing patterns. If a non-argument
617 file name matches any of these patterns, it is ignored.
618 Controlled by -I. Multiple -I options accumulate.
619 The -B option adds `*~' and `.*~' to this list. */
621 struct ignore_pattern
624 struct ignore_pattern *next;
627 static struct ignore_pattern *ignore_patterns;
629 /* Similar to IGNORE_PATTERNS, except that -a or -A causes this
630 variable itself to be ignored. */
631 static struct ignore_pattern *hide_patterns;
633 /* True means output nongraphic chars in file names as `?'.
634 (-q, --hide-control-chars)
635 qmark_funny_chars and the quoting style (-Q, --quoting-style=WORD) are
636 independent. The algorithm is: first, obey the quoting style to get a
637 string representing the file name; then, if qmark_funny_chars is set,
638 replace all nonprintable chars in that string with `?'. It's necessary
639 to replace nonprintable chars even in quoted strings, because we don't
640 want to mess up the terminal if control chars get sent to it, and some
641 quoting methods pass through control chars as-is. */
642 static bool qmark_funny_chars;
644 /* Quoting options for file and dir name output. */
646 static struct quoting_options *filename_quoting_options;
647 static struct quoting_options *dirname_quoting_options;
649 /* The number of chars per hardware tab stop. Setting this to zero
650 inhibits the use of TAB characters for separating columns. -T */
651 static size_t tabsize;
653 /* True means print each directory name before listing it. */
655 static bool print_dir_name;
657 /* The line length to use for breaking lines in many-per-line format.
658 Can be set with -w. */
660 static size_t line_length;
662 /* If true, the file listing format requires that stat be called on
665 static bool format_needs_stat;
667 /* Similar to `format_needs_stat', but set if only the file type is
670 static bool format_needs_type;
672 /* An arbitrary limit on the number of bytes in a printed time stamp.
673 This is set to a relatively small value to avoid the need to worry
674 about denial-of-service attacks on servers that run "ls" on behalf
675 of remote clients. 1000 bytes should be enough for any practical
676 time stamp format. */
678 enum { TIME_STAMP_LEN_MAXIMUM = MAX (1000, INT_STRLEN_BOUND (time_t)) };
680 /* strftime formats for non-recent and recent files, respectively, in
683 static char const *long_time_format[2] =
685 /* strftime format for non-recent files (older than 6 months), in
686 -l output. This should contain the year, month and day (at
687 least), in an order that is understood by people in your
688 locale's territory. Please try to keep the number of used
689 screen columns small, because many people work in windows with
690 only 80 columns. But make this as wide as the other string
691 below, for recent files. */
693 /* strftime format for recent files (younger than 6 months), in -l
694 output. This should contain the month, day and time (at
695 least), in an order that is understood by people in your
696 locale's territory. Please try to keep the number of used
697 screen columns small, because many people work in windows with
698 only 80 columns. But make this as wide as the other string
699 above, for non-recent files. */
703 /* The set of signals that are caught. */
705 static sigset_t caught_signals;
707 /* If nonzero, the value of the pending fatal signal. */
709 static sig_atomic_t volatile interrupt_signal;
711 /* A count of the number of pending stop signals that have been received. */
713 static sig_atomic_t volatile stop_signal_count;
715 /* Desired exit status. */
717 static int exit_status;
722 /* "ls" had a minor problem (e.g., it could not stat a directory
724 LS_MINOR_PROBLEM = 1,
726 /* "ls" had more serious trouble. */
730 /* For long options that have no equivalent short option, use a
731 non-character as a pseudo short option, starting with CHAR_MAX + 1. */
734 AUTHOR_OPTION = CHAR_MAX + 1,
737 DEREFERENCE_COMMAND_LINE_SYMLINK_TO_DIR_OPTION,
738 FILE_TYPE_INDICATOR_OPTION,
741 GROUP_DIRECTORIES_FIRST_OPTION,
743 INDICATOR_STYLE_OPTION,
745 /* FIXME: --kilobytes is deprecated (but not -k); remove in late 2006 */
746 KILOBYTES_LONG_OPTION,
748 QUOTING_STYLE_OPTION,
749 SHOW_CONTROL_CHARS_OPTION,
756 static struct option const long_options[] =
758 {"all", no_argument, NULL, 'a'},
759 {"escape", no_argument, NULL, 'b'},
760 {"directory", no_argument, NULL, 'd'},
761 {"dired", no_argument, NULL, 'D'},
762 {"full-time", no_argument, NULL, FULL_TIME_OPTION},
763 {"group-directories-first", no_argument, NULL,
764 GROUP_DIRECTORIES_FIRST_OPTION},
765 {"human-readable", no_argument, NULL, 'h'},
766 {"inode", no_argument, NULL, 'i'},
767 {"kilobytes", no_argument, NULL, KILOBYTES_LONG_OPTION},
768 {"numeric-uid-gid", no_argument, NULL, 'n'},
769 {"no-group", no_argument, NULL, 'G'},
770 {"hide-control-chars", no_argument, NULL, 'q'},
771 {"reverse", no_argument, NULL, 'r'},
772 {"size", no_argument, NULL, 's'},
773 {"width", required_argument, NULL, 'w'},
774 {"almost-all", no_argument, NULL, 'A'},
775 {"ignore-backups", no_argument, NULL, 'B'},
776 {"classify", no_argument, NULL, 'F'},
777 {"file-type", no_argument, NULL, FILE_TYPE_INDICATOR_OPTION},
778 {"si", no_argument, NULL, SI_OPTION},
779 {"dereference-command-line", no_argument, NULL, 'H'},
780 {"dereference-command-line-symlink-to-dir", no_argument, NULL,
781 DEREFERENCE_COMMAND_LINE_SYMLINK_TO_DIR_OPTION},
782 {"hide", required_argument, NULL, HIDE_OPTION},
783 {"ignore", required_argument, NULL, 'I'},
784 {"indicator-style", required_argument, NULL, INDICATOR_STYLE_OPTION},
785 {"dereference", no_argument, NULL, 'L'},
786 {"literal", no_argument, NULL, 'N'},
787 {"quote-name", no_argument, NULL, 'Q'},
788 {"quoting-style", required_argument, NULL, QUOTING_STYLE_OPTION},
789 {"recursive", no_argument, NULL, 'R'},
790 {"format", required_argument, NULL, FORMAT_OPTION},
791 {"show-control-chars", no_argument, NULL, SHOW_CONTROL_CHARS_OPTION},
792 {"sort", required_argument, NULL, SORT_OPTION},
793 {"tabsize", required_argument, NULL, 'T'},
794 {"time", required_argument, NULL, TIME_OPTION},
795 {"time-style", required_argument, NULL, TIME_STYLE_OPTION},
796 {"color", optional_argument, NULL, COLOR_OPTION},
797 {"block-size", required_argument, NULL, BLOCK_SIZE_OPTION},
798 {"author", no_argument, NULL, AUTHOR_OPTION},
799 {GETOPT_HELP_OPTION_DECL},
800 {GETOPT_VERSION_OPTION_DECL},
804 static char const *const format_args[] =
806 "verbose", "long", "commas", "horizontal", "across",
807 "vertical", "single-column", NULL
809 static enum format const format_types[] =
811 long_format, long_format, with_commas, horizontal, horizontal,
812 many_per_line, one_per_line
814 ARGMATCH_VERIFY (format_args, format_types);
816 static char const *const sort_args[] =
818 "none", "time", "size", "extension", "version", NULL
820 static enum sort_type const sort_types[] =
822 sort_none, sort_time, sort_size, sort_extension, sort_version
824 ARGMATCH_VERIFY (sort_args, sort_types);
826 static char const *const time_args[] =
828 "atime", "access", "use", "ctime", "status", NULL
830 static enum time_type const time_types[] =
832 time_atime, time_atime, time_atime, time_ctime, time_ctime
834 ARGMATCH_VERIFY (time_args, time_types);
836 static char const *const color_args[] =
838 /* force and none are for compatibility with another color-ls version */
839 "always", "yes", "force",
840 "never", "no", "none",
841 "auto", "tty", "if-tty", NULL
843 static enum color_type const color_types[] =
845 color_always, color_always, color_always,
846 color_never, color_never, color_never,
847 color_if_tty, color_if_tty, color_if_tty
849 ARGMATCH_VERIFY (color_args, color_types);
851 /* Information about filling a column. */
859 /* Array with information about column filledness. */
860 static struct column_info *column_info;
862 /* Maximum number of columns ever possible for this display. */
863 static size_t max_idx;
865 /* The minimum width of a column is 3: 1 character for the name and 2
866 for the separating white space. */
867 #define MIN_COLUMN_WIDTH 3
870 /* This zero-based index is used solely with the --dired option.
871 When that option is in effect, this counter is incremented for each
872 byte of output generated by this program so that the beginning
873 and ending indices (in that output) of every file name can be recorded
874 and later output themselves. */
875 static size_t dired_pos;
877 #define DIRED_PUTCHAR(c) do {putchar ((c)); ++dired_pos;} while (0)
879 /* Write S to STREAM and increment DIRED_POS by S_LEN. */
880 #define DIRED_FPUTS(s, stream, s_len) \
881 do {fputs ((s), (stream)); dired_pos += s_len;} while (0)
883 /* Like DIRED_FPUTS, but for use when S is a literal string. */
884 #define DIRED_FPUTS_LITERAL(s, stream) \
885 do {fputs ((s), (stream)); dired_pos += sizeof((s)) - 1;} while (0)
887 #define DIRED_INDENT() \
891 DIRED_FPUTS_LITERAL (" ", stdout); \
895 /* With --dired, store pairs of beginning and ending indices of filenames. */
896 static struct obstack dired_obstack;
898 /* With --dired, store pairs of beginning and ending indices of any
899 directory names that appear as headers (just before `total' line)
900 for lists of directory entries. Such directory names are seen when
901 listing hierarchies using -R and when a directory is listed with at
902 least one other command line argument. */
903 static struct obstack subdired_obstack;
905 /* Save the current index on the specified obstack, OBS. */
906 #define PUSH_CURRENT_DIRED_POS(obs) \
910 obstack_grow ((obs), &dired_pos, sizeof (dired_pos)); \
914 /* With -R, this stack is used to help detect directory cycles.
915 The device/inode pairs on this stack mirror the pairs in the
916 active_dir_set hash table. */
917 static struct obstack dev_ino_obstack;
919 /* Push a pair onto the device/inode stack. */
920 #define DEV_INO_PUSH(Dev, Ino) \
923 struct dev_ino *di; \
924 obstack_blank (&dev_ino_obstack, sizeof (struct dev_ino)); \
925 di = -1 + (struct dev_ino *) obstack_next_free (&dev_ino_obstack); \
926 di->st_dev = (Dev); \
927 di->st_ino = (Ino); \
931 /* Pop a dev/ino struct off the global dev_ino_obstack
932 and return that struct. */
933 static struct dev_ino
936 assert (sizeof (struct dev_ino) <= obstack_object_size (&dev_ino_obstack));
937 obstack_blank (&dev_ino_obstack, -(int) (sizeof (struct dev_ino)));
938 return *(struct dev_ino*) obstack_next_free (&dev_ino_obstack);
941 #define ASSERT_MATCHING_DEV_INO(Name, Di) \
946 assert (0 <= stat (Name, &sb)); \
947 assert (sb.st_dev == Di.st_dev); \
948 assert (sb.st_ino == Di.st_ino); \
953 /* Write to standard output PREFIX, followed by the quoting style and
954 a space-separated list of the integers stored in OS all on one line. */
957 dired_dump_obstack (const char *prefix, struct obstack *os)
961 n_pos = obstack_object_size (os) / sizeof (dired_pos);
967 pos = (size_t *) obstack_finish (os);
968 fputs (prefix, stdout);
969 for (i = 0; i < n_pos; i++)
970 printf (" %lu", (unsigned long int) pos[i]);
976 dev_ino_hash (void const *x, size_t table_size)
978 struct dev_ino const *p = x;
979 return (uintmax_t) p->st_ino % table_size;
983 dev_ino_compare (void const *x, void const *y)
985 struct dev_ino const *a = x;
986 struct dev_ino const *b = y;
987 return SAME_INODE (*a, *b) ? true : false;
991 dev_ino_free (void *x)
996 /* Add the device/inode pair (P->st_dev/P->st_ino) to the set of
997 active directories. Return true if there is already a matching
998 entry in the table. */
1001 visit_dir (dev_t dev, ino_t ino)
1003 struct dev_ino *ent;
1004 struct dev_ino *ent_from_table;
1007 ent = xmalloc (sizeof *ent);
1011 /* Attempt to insert this entry into the table. */
1012 ent_from_table = hash_insert (active_dir_set, ent);
1014 if (ent_from_table == NULL)
1016 /* Insertion failed due to lack of memory. */
1020 found_match = (ent_from_table != ent);
1024 /* ent was not inserted, so free it. */
1032 free_pending_ent (struct pending *p)
1040 is_colored (enum indicator_no type)
1042 size_t len = color_indicator[type].len;
1043 char const *s = color_indicator[type].string;
1045 || (len == 1 && strncmp (s, "0", 1) == 0)
1046 || (len == 2 && strncmp (s, "00", 2) == 0));
1050 restore_default_color (void)
1052 put_indicator (&color_indicator[C_LEFT]);
1053 put_indicator (&color_indicator[C_RIGHT]);
1056 /* An ordinary signal was received; arrange for the program to exit. */
1059 sighandler (int sig)
1062 signal (sig, SIG_IGN);
1063 if (! interrupt_signal)
1064 interrupt_signal = sig;
1067 /* A SIGTSTP was received; arrange for the program to suspend itself. */
1070 stophandler (int sig)
1073 signal (sig, stophandler);
1074 if (! interrupt_signal)
1075 stop_signal_count++;
1078 /* Process any pending signals. If signals are caught, this function
1079 should be called periodically. Ideally there should never be an
1080 unbounded amount of time when signals are not being processed.
1081 Signal handling can restore the default colors, so callers must
1082 immediately change colors after invoking this function. */
1085 process_signals (void)
1087 while (interrupt_signal | stop_signal_count)
1093 restore_default_color ();
1096 sigprocmask (SIG_BLOCK, &caught_signals, &oldset);
1098 /* Reload interrupt_signal and stop_signal_count, in case a new
1099 signal was handled before sigprocmask took effect. */
1100 sig = interrupt_signal;
1101 stops = stop_signal_count;
1103 /* SIGTSTP is special, since the application can receive that signal
1104 more than once. In this case, don't set the signal handler to the
1105 default. Instead, just raise the uncatchable SIGSTOP. */
1108 stop_signal_count = stops - 1;
1112 signal (sig, SIG_DFL);
1114 /* Exit or suspend the program. */
1116 sigprocmask (SIG_SETMASK, &oldset, NULL);
1118 /* If execution reaches here, then the program has been
1119 continued (after being suspended). */
1124 main (int argc, char **argv)
1127 struct pending *thispend;
1130 /* The signals that are trapped, and the number of such signals. */
1131 static int const sig[] = { SIGHUP, SIGINT, SIGPIPE,
1132 SIGQUIT, SIGTERM, SIGTSTP };
1133 enum { nsigs = sizeof sig / sizeof sig[0] };
1136 bool caught_sig[nsigs];
1139 initialize_main (&argc, &argv);
1140 program_name = argv[0];
1141 setlocale (LC_ALL, "");
1142 bindtextdomain (PACKAGE, LOCALEDIR);
1143 textdomain (PACKAGE);
1145 initialize_exit_failure (LS_FAILURE);
1146 atexit (close_stdout);
1148 #define N_ENTRIES(Array) (sizeof Array / sizeof *(Array))
1149 assert (N_ENTRIES (color_indicator) + 1 == N_ENTRIES (indicator_name));
1151 exit_status = EXIT_SUCCESS;
1152 print_dir_name = true;
1153 pending_dirs = NULL;
1155 i = decode_switches (argc, argv);
1157 if (print_with_color)
1160 /* Test print_with_color again, because the call to parse_ls_color
1161 may have just reset it -- e.g., if LS_COLORS is invalid. */
1162 if (print_with_color)
1164 /* Avoid following symbolic links when possible. */
1165 if (is_colored (C_ORPHAN)
1166 || is_colored (C_EXEC)
1167 || (is_colored (C_MISSING) && format == long_format))
1168 check_symlink_color = true;
1170 /* If the standard output is a controlling terminal, watch out
1171 for signals, so that the colors can be restored to the
1172 default state if "ls" is suspended or interrupted. */
1174 if (0 <= tcgetpgrp (STDOUT_FILENO))
1178 struct sigaction act;
1180 sigemptyset (&caught_signals);
1181 for (j = 0; j < nsigs; j++)
1183 sigaction (sig[j], NULL, &act);
1184 if (act.sa_handler != SIG_IGN)
1185 sigaddset (&caught_signals, sig[j]);
1188 act.sa_mask = caught_signals;
1189 act.sa_flags = SA_RESTART;
1191 for (j = 0; j < nsigs; j++)
1192 if (sigismember (&caught_signals, sig[j]))
1194 act.sa_handler = sig[j] == SIGTSTP ? stophandler : sighandler;
1195 sigaction (sig[j], &act, NULL);
1198 for (j = 0; j < nsigs; j++)
1200 caught_sig[j] = (signal (sig[j], SIG_IGN) != SIG_IGN);
1203 signal (sig[j], sig[j] == SIGTSTP ? stophandler : sighandler);
1204 siginterrupt (sig[j], 0);
1210 prep_non_filename_text ();
1213 if (dereference == DEREF_UNDEFINED)
1214 dereference = ((immediate_dirs
1215 || indicator_style == classify
1216 || format == long_format)
1218 : DEREF_COMMAND_LINE_SYMLINK_TO_DIR);
1220 /* When using -R, initialize a data structure we'll use to
1221 detect any directory cycles. */
1224 active_dir_set = hash_initialize (INITIAL_TABLE_SIZE, NULL,
1228 if (active_dir_set == NULL)
1231 obstack_init (&dev_ino_obstack);
1234 format_needs_stat = sort_type == sort_time || sort_type == sort_size
1235 || format == long_format
1236 || print_block_size;
1237 format_needs_type = (! format_needs_stat
1240 || indicator_style != none
1241 || directories_first));
1245 obstack_init (&dired_obstack);
1246 obstack_init (&subdired_obstack);
1250 files = xnmalloc (nfiles, sizeof *files);
1260 gobble_file (".", directory, NOT_AN_INODE_NUMBER, true, "");
1262 queue_directory (".", NULL, true);
1266 gobble_file (argv[i++], command_line, NOT_AN_INODE_NUMBER, true, "");
1272 if (!immediate_dirs)
1273 extract_dirs_from_files (NULL, true);
1274 /* `files_index' might be zero now. */
1277 /* In the following if/else blocks, it is sufficient to test `pending_dirs'
1278 (and not pending_dirs->name) because there may be no markers in the queue
1279 at this point. A marker may be enqueued when extract_dirs_from_files is
1280 called with a non-empty string or via print_dir. */
1283 print_current_files ();
1285 DIRED_PUTCHAR ('\n');
1287 else if (n_files <= 1 && pending_dirs && pending_dirs->next == 0)
1288 print_dir_name = false;
1290 while (pending_dirs)
1292 thispend = pending_dirs;
1293 pending_dirs = pending_dirs->next;
1297 if (thispend->name == NULL)
1299 /* thispend->name == NULL means this is a marker entry
1300 indicating we've finished processing the directory.
1301 Use its dev/ino numbers to remove the corresponding
1302 entry from the active_dir_set hash table. */
1303 struct dev_ino di = dev_ino_pop ();
1304 struct dev_ino *found = hash_delete (active_dir_set, &di);
1305 /* ASSERT_MATCHING_DEV_INO (thispend->realname, di); */
1307 dev_ino_free (found);
1308 free_pending_ent (thispend);
1313 print_dir (thispend->name, thispend->realname,
1314 thispend->command_line_arg);
1316 free_pending_ent (thispend);
1317 print_dir_name = true;
1320 if (print_with_color)
1324 restore_default_color ();
1327 /* Restore the default signal handling. */
1329 for (j = 0; j < nsigs; j++)
1330 if (sigismember (&caught_signals, sig[j]))
1331 signal (sig[j], SIG_DFL);
1333 for (j = 0; j < nsigs; j++)
1335 signal (sig[j], SIG_DFL);
1338 /* Act on any signals that arrived before the default was restored.
1339 This can process signals out of order, but there doesn't seem to
1340 be an easy way to do them in order, and the order isn't that
1341 important anyway. */
1342 for (j = stop_signal_count; j; j--)
1344 j = interrupt_signal;
1351 /* No need to free these since we're about to exit. */
1352 dired_dump_obstack ("//DIRED//", &dired_obstack);
1353 dired_dump_obstack ("//SUBDIRED//", &subdired_obstack);
1354 printf ("//DIRED-OPTIONS// --quoting-style=%s\n",
1355 quoting_style_args[get_quoting_style (filename_quoting_options)]);
1360 assert (hash_get_n_entries (active_dir_set) == 0);
1361 hash_free (active_dir_set);
1367 /* Set all the option flags according to the switches specified.
1368 Return the index of the first non-option argument. */
1371 decode_switches (int argc, char **argv)
1374 char *time_style_option = NULL;
1376 /* Record whether there is an option specifying sort type. */
1377 bool sort_type_specified = false;
1379 qmark_funny_chars = false;
1381 /* initialize all switches to default settings */
1386 /* This is for the `dir' program. */
1387 format = many_per_line;
1388 set_quoting_style (NULL, escape_quoting_style);
1391 case LS_LONG_FORMAT:
1392 /* This is for the `vdir' program. */
1393 format = long_format;
1394 set_quoting_style (NULL, escape_quoting_style);
1398 /* This is for the `ls' program. */
1399 if (isatty (STDOUT_FILENO))
1401 format = many_per_line;
1402 /* See description of qmark_funny_chars, above. */
1403 qmark_funny_chars = true;
1407 format = one_per_line;
1408 qmark_funny_chars = false;
1416 time_type = time_mtime;
1417 sort_type = sort_name;
1418 sort_reverse = false;
1419 numeric_ids = false;
1420 print_block_size = false;
1421 indicator_style = none;
1422 print_inode = false;
1423 dereference = DEREF_UNDEFINED;
1425 immediate_dirs = false;
1426 ignore_mode = IGNORE_DEFAULT;
1427 ignore_patterns = NULL;
1428 hide_patterns = NULL;
1430 /* FIXME: put this in a function. */
1432 char const *q_style = getenv ("QUOTING_STYLE");
1435 int i = ARGMATCH (q_style, quoting_style_args, quoting_style_vals);
1437 set_quoting_style (NULL, quoting_style_vals[i]);
1440 _("ignoring invalid value of environment variable QUOTING_STYLE: %s"),
1441 quotearg (q_style));
1446 char const *ls_block_size = getenv ("LS_BLOCK_SIZE");
1447 human_output_opts = human_options (ls_block_size, false,
1448 &output_block_size);
1449 if (ls_block_size || getenv ("BLOCK_SIZE"))
1450 file_output_block_size = output_block_size;
1455 char const *p = getenv ("COLUMNS");
1458 unsigned long int tmp_ulong;
1459 if (xstrtoul (p, NULL, 0, &tmp_ulong, NULL) == LONGINT_OK
1460 && 0 < tmp_ulong && tmp_ulong <= SIZE_MAX)
1462 line_length = tmp_ulong;
1467 _("ignoring invalid width in environment variable COLUMNS: %s"),
1477 if (ioctl (STDOUT_FILENO, TIOCGWINSZ, &ws) != -1
1478 && 0 < ws.ws_col && ws.ws_col == (size_t) ws.ws_col)
1479 line_length = ws.ws_col;
1484 char const *p = getenv ("TABSIZE");
1488 unsigned long int tmp_ulong;
1489 if (xstrtoul (p, NULL, 0, &tmp_ulong, NULL) == LONGINT_OK
1490 && tmp_ulong <= SIZE_MAX)
1492 tabsize = tmp_ulong;
1497 _("ignoring invalid tab size in environment variable TABSIZE: %s"),
1503 while ((c = getopt_long (argc, argv,
1504 "abcdfghiklmnopqrstuvw:xABCDFGHI:LNQRST:UX1",
1505 long_options, NULL)) != -1)
1510 ignore_mode = IGNORE_MINIMAL;
1514 set_quoting_style (NULL, escape_quoting_style);
1518 time_type = time_ctime;
1522 immediate_dirs = true;
1526 /* Same as enabling -a -U and disabling -l -s. */
1527 ignore_mode = IGNORE_MINIMAL;
1528 sort_type = sort_none;
1529 sort_type_specified = true;
1531 if (format == long_format)
1532 format = (isatty (STDOUT_FILENO) ? many_per_line : one_per_line);
1533 print_block_size = false; /* disable -s */
1534 print_with_color = false; /* disable --color */
1537 case FILE_TYPE_INDICATOR_OPTION: /* --file-type */
1538 indicator_style = file_type;
1542 format = long_format;
1543 print_owner = false;
1547 human_output_opts = human_autoscale | human_SI | human_base_1024;
1548 file_output_block_size = output_block_size = 1;
1555 case KILOBYTES_LONG_OPTION:
1557 _("the --kilobytes option is deprecated; use -k instead"));
1560 human_output_opts = 0;
1561 file_output_block_size = output_block_size = 1024;
1565 format = long_format;
1569 format = with_commas;
1574 format = long_format;
1577 case 'o': /* Just like -l, but don't display group info. */
1578 format = long_format;
1579 print_group = false;
1583 indicator_style = slash;
1587 qmark_funny_chars = true;
1591 sort_reverse = true;
1595 print_block_size = true;
1599 sort_type = sort_time;
1600 sort_type_specified = true;
1604 time_type = time_atime;
1608 sort_type = sort_version;
1609 sort_type_specified = true;
1614 unsigned long int tmp_ulong;
1615 if (xstrtoul (optarg, NULL, 0, &tmp_ulong, NULL) != LONGINT_OK
1616 || ! (0 < tmp_ulong && tmp_ulong <= SIZE_MAX))
1617 error (LS_FAILURE, 0, _("invalid line width: %s"),
1619 line_length = tmp_ulong;
1624 format = horizontal;
1628 if (ignore_mode == IGNORE_DEFAULT)
1629 ignore_mode = IGNORE_DOT_AND_DOTDOT;
1633 add_ignore_pattern ("*~");
1634 add_ignore_pattern (".*~");
1638 format = many_per_line;
1646 indicator_style = classify;
1649 case 'G': /* inhibit display of group info */
1650 print_group = false;
1654 dereference = DEREF_COMMAND_LINE_ARGUMENTS;
1657 case DEREFERENCE_COMMAND_LINE_SYMLINK_TO_DIR_OPTION:
1658 dereference = DEREF_COMMAND_LINE_SYMLINK_TO_DIR;
1662 add_ignore_pattern (optarg);
1666 dereference = DEREF_ALWAYS;
1670 set_quoting_style (NULL, literal_quoting_style);
1674 set_quoting_style (NULL, c_quoting_style);
1682 sort_type = sort_size;
1683 sort_type_specified = true;
1688 unsigned long int tmp_ulong;
1689 if (xstrtoul (optarg, NULL, 0, &tmp_ulong, NULL) != LONGINT_OK
1690 || SIZE_MAX < tmp_ulong)
1691 error (LS_FAILURE, 0, _("invalid tab size: %s"),
1693 tabsize = tmp_ulong;
1698 sort_type = sort_none;
1699 sort_type_specified = true;
1703 sort_type = sort_extension;
1704 sort_type_specified = true;
1708 /* -1 has no effect after -l. */
1709 if (format != long_format)
1710 format = one_per_line;
1714 print_author = true;
1719 struct ignore_pattern *hide = xmalloc (sizeof *hide);
1720 hide->pattern = optarg;
1721 hide->next = hide_patterns;
1722 hide_patterns = hide;
1727 sort_type = XARGMATCH ("--sort", optarg, sort_args, sort_types);
1728 sort_type_specified = true;
1731 case GROUP_DIRECTORIES_FIRST_OPTION:
1732 directories_first = true;
1736 time_type = XARGMATCH ("--time", optarg, time_args, time_types);
1740 format = XARGMATCH ("--format", optarg, format_args, format_types);
1743 case FULL_TIME_OPTION:
1744 format = long_format;
1745 time_style_option = "full-iso";
1752 i = XARGMATCH ("--color", optarg, color_args, color_types);
1754 /* Using --color with no argument is equivalent to using
1758 print_with_color = (i == color_always
1759 || (i == color_if_tty
1760 && isatty (STDOUT_FILENO)));
1762 if (print_with_color)
1764 /* Don't use TAB characters in output. Some terminal
1765 emulators can't handle the combination of tabs and
1766 color codes on the same line. */
1772 case INDICATOR_STYLE_OPTION:
1773 indicator_style = XARGMATCH ("--indicator-style", optarg,
1774 indicator_style_args,
1775 indicator_style_types);
1778 case QUOTING_STYLE_OPTION:
1779 set_quoting_style (NULL,
1780 XARGMATCH ("--quoting-style", optarg,
1782 quoting_style_vals));
1785 case TIME_STYLE_OPTION:
1786 time_style_option = optarg;
1789 case SHOW_CONTROL_CHARS_OPTION:
1790 qmark_funny_chars = false;
1793 case BLOCK_SIZE_OPTION:
1794 human_output_opts = human_options (optarg, true, &output_block_size);
1795 file_output_block_size = output_block_size;
1799 human_output_opts = human_autoscale | human_SI;
1800 file_output_block_size = output_block_size = 1;
1803 case_GETOPT_HELP_CHAR;
1805 case_GETOPT_VERSION_CHAR (PROGRAM_NAME, AUTHORS);
1812 max_idx = MAX (1, line_length / MIN_COLUMN_WIDTH);
1814 filename_quoting_options = clone_quoting_options (NULL);
1815 if (get_quoting_style (filename_quoting_options) == escape_quoting_style)
1816 set_char_quoting (filename_quoting_options, ' ', 1);
1817 if (file_type <= indicator_style)
1820 for (p = "*=>@|" + indicator_style - file_type; *p; p++)
1821 set_char_quoting (filename_quoting_options, *p, 1);
1824 dirname_quoting_options = clone_quoting_options (NULL);
1825 set_char_quoting (dirname_quoting_options, ':', 1);
1827 /* --dired is meaningful only with --format=long (-l).
1828 Otherwise, ignore it. FIXME: warn about this?
1829 Alternatively, make --dired imply --format=long? */
1830 if (dired && format != long_format)
1833 /* If -c or -u is specified and not -l (or any other option that implies -l),
1834 and no sort-type was specified, then sort by the ctime (-c) or atime (-u).
1835 The behavior of ls when using either -c or -u but with neither -l nor -t
1836 appears to be unspecified by POSIX. So, with GNU ls, `-u' alone means
1837 sort by atime (this is the one that's not specified by the POSIX spec),
1838 -lu means show atime and sort by name, -lut means show atime and sort
1841 if ((time_type == time_ctime || time_type == time_atime)
1842 && !sort_type_specified && format != long_format)
1844 sort_type = sort_time;
1847 if (format == long_format)
1849 char *style = time_style_option;
1850 static char const posix_prefix[] = "posix-";
1853 if (! (style = getenv ("TIME_STYLE")))
1856 while (strncmp (style, posix_prefix, sizeof posix_prefix - 1) == 0)
1858 if (! hard_locale (LC_TIME))
1860 style += sizeof posix_prefix - 1;
1865 char *p0 = style + 1;
1866 char *p1 = strchr (p0, '\n');
1871 if (strchr (p1 + 1, '\n'))
1872 error (LS_FAILURE, 0, _("invalid time style format %s"),
1876 long_time_format[0] = p0;
1877 long_time_format[1] = p1;
1880 switch (XARGMATCH ("time style", style,
1884 case full_iso_time_style:
1885 long_time_format[0] = long_time_format[1] =
1886 "%Y-%m-%d %H:%M:%S.%N %z";
1889 case long_iso_time_style:
1890 case_long_iso_time_style:
1891 long_time_format[0] = long_time_format[1] = "%Y-%m-%d %H:%M";
1894 case iso_time_style:
1895 long_time_format[0] = "%Y-%m-%d ";
1896 long_time_format[1] = "%m-%d %H:%M";
1899 case locale_time_style:
1900 if (hard_locale (LC_TIME))
1902 /* Ensure that the locale has translations for both
1903 formats. If not, fall back on long-iso format. */
1905 for (i = 0; i < 2; i++)
1907 char const *locale_format =
1908 dcgettext (NULL, long_time_format[i], LC_TIME);
1909 if (locale_format == long_time_format[i])
1910 goto case_long_iso_time_style;
1911 long_time_format[i] = locale_format;
1920 /* Parse a string as part of the LS_COLORS variable; this may involve
1921 decoding all kinds of escape characters. If equals_end is set an
1922 unescaped equal sign ends the string, otherwise only a : or \0
1923 does. Set *OUTPUT_COUNT to the number of bytes output. Return
1926 The resulting string is *not* null-terminated, but may contain
1929 Note that both dest and src are char **; on return they point to
1930 the first free byte after the array and the character that ended
1931 the input string, respectively. */
1934 get_funky_string (char **dest, const char **src, bool equals_end,
1935 size_t *output_count)
1937 char num; /* For numerical codes */
1938 size_t count; /* Something to count with */
1940 ST_GND, ST_BACKSLASH, ST_OCTAL, ST_HEX, ST_CARET, ST_END, ST_ERROR
1945 p = *src; /* We don't want to double-indirect */
1946 q = *dest; /* the whole darn time. */
1948 count = 0; /* No characters counted in yet. */
1951 state = ST_GND; /* Start in ground state. */
1952 while (state < ST_END)
1956 case ST_GND: /* Ground state (no escapes) */
1961 state = ST_END; /* End of string */
1964 state = ST_BACKSLASH; /* Backslash scape sequence */
1968 state = ST_CARET; /* Caret escape */
1974 state = ST_END; /* End */
1977 /* else fall through */
1985 case ST_BACKSLASH: /* Backslash escaped character */
1996 state = ST_OCTAL; /* Octal sequence */
2001 state = ST_HEX; /* Hex sequence */
2004 case 'a': /* Bell */
2007 case 'b': /* Backspace */
2010 case 'e': /* Escape */
2013 case 'f': /* Form feed */
2016 case 'n': /* Newline */
2019 case 'r': /* Carriage return */
2025 case 'v': /* Vtab */
2028 case '?': /* Delete */
2031 case '_': /* Space */
2034 case '\0': /* End of string */
2035 state = ST_ERROR; /* Error! */
2037 default: /* Escaped character like \ ^ : = */
2041 if (state == ST_BACKSLASH)
2050 case ST_OCTAL: /* Octal sequence */
2051 if (*p < '0' || *p > '7')
2058 num = (num << 3) + (*(p++) - '0');
2061 case ST_HEX: /* Hex sequence */
2074 num = (num << 4) + (*(p++) - '0');
2082 num = (num << 4) + (*(p++) - 'a') + 10;
2090 num = (num << 4) + (*(p++) - 'A') + 10;
2100 case ST_CARET: /* Caret escape */
2101 state = ST_GND; /* Should be the next state... */
2102 if (*p >= '@' && *p <= '~')
2104 *(q++) = *(p++) & 037;
2123 *output_count = count;
2125 return state != ST_ERROR;
2129 parse_ls_color (void)
2131 const char *p; /* Pointer to character being parsed */
2132 char *buf; /* color_buf buffer pointer */
2133 int state; /* State of parser */
2134 int ind_no; /* Indicator number */
2135 char label[3]; /* Indicator label */
2136 struct color_ext_type *ext; /* Extension we are working on */
2138 if ((p = getenv ("LS_COLORS")) == NULL || *p == '\0')
2142 strcpy (label, "??");
2144 /* This is an overly conservative estimate, but any possible
2145 LS_COLORS string will *not* generate a color_buf longer than
2146 itself, so it is a safe way of allocating a buffer in
2148 buf = color_buf = xstrdup (p);
2155 case 1: /* First label character */
2163 /* Allocate new extension block and add to head of
2164 linked list (this way a later definition will
2165 override an earlier one, which can be useful for
2166 having terminal-specific defs override global). */
2168 ext = xmalloc (sizeof *ext);
2169 ext->next = color_ext_list;
2170 color_ext_list = ext;
2173 ext->ext.string = buf;
2175 state = (get_funky_string (&buf, &p, true, &ext->ext.len)
2180 state = 0; /* Done! */
2183 default: /* Assume it is file type label */
2190 case 2: /* Second label character */
2197 state = -1; /* Error */
2200 case 3: /* Equal sign after indicator label */
2201 state = -1; /* Assume failure... */
2202 if (*(p++) == '=')/* It *should* be... */
2204 for (ind_no = 0; indicator_name[ind_no] != NULL; ++ind_no)
2206 if (STREQ (label, indicator_name[ind_no]))
2208 color_indicator[ind_no].string = buf;
2209 state = (get_funky_string (&buf, &p, false,
2210 &color_indicator[ind_no].len)
2216 error (0, 0, _("unrecognized prefix: %s"), quotearg (label));
2220 case 4: /* Equal sign after *.ext */
2223 ext->seq.string = buf;
2224 state = (get_funky_string (&buf, &p, false, &ext->seq.len)
2235 struct color_ext_type *e;
2236 struct color_ext_type *e2;
2239 _("unparsable value for LS_COLORS environment variable"));
2241 for (e = color_ext_list; e != NULL; /* empty */)
2247 print_with_color = false;
2250 if (color_indicator[C_LINK].len == 6
2251 && !strncmp (color_indicator[C_LINK].string, "target", 6))
2252 color_symlink_as_referent = true;
2255 /* Set the exit status to report a failure. If SERIOUS, it is a
2256 serious failure; otherwise, it is merely a minor problem. */
2259 set_exit_status (bool serious)
2262 exit_status = LS_FAILURE;
2263 else if (exit_status == EXIT_SUCCESS)
2264 exit_status = LS_MINOR_PROBLEM;
2267 /* Assuming a failure is serious if SERIOUS, use the printf-style
2268 MESSAGE to report the failure to access a file named FILE. Assume
2269 errno is set appropriately for the failure. */
2272 file_failure (bool serious, char const *message, char const *file)
2274 error (0, errno, message, quotearg_colon (file));
2275 set_exit_status (serious);
2278 /* Request that the directory named NAME have its contents listed later.
2279 If REALNAME is nonzero, it will be used instead of NAME when the
2280 directory name is printed. This allows symbolic links to directories
2281 to be treated as regular directories but still be listed under their
2282 real names. NAME == NULL is used to insert a marker entry for the
2283 directory named in REALNAME.
2284 If NAME is non-NULL, we use its dev/ino information to save
2285 a call to stat -- when doing a recursive (-R) traversal.
2286 COMMAND_LINE_ARG means this directory was mentioned on the command line. */
2289 queue_directory (char const *name, char const *realname, bool command_line_arg)
2291 struct pending *new = xmalloc (sizeof *new);
2292 new->realname = realname ? xstrdup (realname) : NULL;
2293 new->name = name ? xstrdup (name) : NULL;
2294 new->command_line_arg = command_line_arg;
2295 new->next = pending_dirs;
2299 /* Read directory NAME, and list the files in it.
2300 If REALNAME is nonzero, print its name instead of NAME;
2301 this is used for symbolic links to directories.
2302 COMMAND_LINE_ARG means this directory was mentioned on the command line. */
2305 print_dir (char const *name, char const *realname, bool command_line_arg)
2308 struct dirent *next;
2309 uintmax_t total_blocks = 0;
2310 static bool first = true;
2313 dirp = opendir (name);
2316 file_failure (command_line_arg, _("cannot open directory %s"), name);
2322 struct stat dir_stat;
2323 int fd = dirfd (dirp);
2325 /* If dirfd failed, endure the overhead of using stat. */
2327 ? fstat (fd, &dir_stat)
2328 : stat (name, &dir_stat)) < 0)
2330 file_failure (command_line_arg,
2331 _("cannot determine device and inode of %s"), name);
2335 /* If we've already visited this dev/inode pair, warn that
2336 we've found a loop, and do not process this directory. */
2337 if (visit_dir (dir_stat.st_dev, dir_stat.st_ino))
2339 error (0, 0, _("%s: not listing already-listed directory"),
2340 quotearg_colon (name));
2344 DEV_INO_PUSH (dir_stat.st_dev, dir_stat.st_ino);
2347 /* Read the directory entries, and insert the subfiles into the `files'
2354 /* Set errno to zero so we can distinguish between a readdir failure
2355 and when readdir simply finds that there are no more entries. */
2357 next = readdir (dirp);
2360 if (! file_ignored (next->d_name))
2362 enum filetype type = unknown;
2364 #if HAVE_STRUCT_DIRENT_D_TYPE
2365 if (next->d_type == DT_BLK
2366 || next->d_type == DT_CHR
2367 || next->d_type == DT_DIR
2368 || next->d_type == DT_FIFO
2369 || next->d_type == DT_LNK
2370 || next->d_type == DT_REG
2371 || next->d_type == DT_SOCK)
2372 type = next->d_type;
2374 total_blocks += gobble_file (next->d_name, type, D_INO (next),
2378 else if (errno != 0)
2380 file_failure (command_line_arg, _("reading directory %s"), name);
2381 if (errno != EOVERFLOW)
2388 if (closedir (dirp) != 0)
2390 file_failure (command_line_arg, _("closing directory %s"), name);
2391 /* Don't return; print whatever we got. */
2394 /* Sort the directory contents. */
2397 /* If any member files are subdirectories, perhaps they should have their
2398 contents listed rather than being mentioned here as files. */
2401 extract_dirs_from_files (name, command_line_arg);
2403 if (recursive | print_dir_name)
2406 DIRED_PUTCHAR ('\n');
2409 PUSH_CURRENT_DIRED_POS (&subdired_obstack);
2410 dired_pos += quote_name (stdout, realname ? realname : name,
2411 dirname_quoting_options, NULL);
2412 PUSH_CURRENT_DIRED_POS (&subdired_obstack);
2413 DIRED_FPUTS_LITERAL (":\n", stdout);
2416 if (format == long_format || print_block_size)
2419 char buf[LONGEST_HUMAN_READABLE + 1];
2423 DIRED_FPUTS (p, stdout, strlen (p));
2424 DIRED_PUTCHAR (' ');
2425 p = human_readable (total_blocks, buf, human_output_opts,
2426 ST_NBLOCKSIZE, output_block_size);
2427 DIRED_FPUTS (p, stdout, strlen (p));
2428 DIRED_PUTCHAR ('\n');
2432 print_current_files ();
2435 /* Add `pattern' to the list of patterns for which files that match are
2439 add_ignore_pattern (const char *pattern)
2441 struct ignore_pattern *ignore;
2443 ignore = xmalloc (sizeof *ignore);
2444 ignore->pattern = pattern;
2445 /* Add it to the head of the linked list. */
2446 ignore->next = ignore_patterns;
2447 ignore_patterns = ignore;
2450 /* Return true if one of the PATTERNS matches FILE. */
2453 patterns_match (struct ignore_pattern const *patterns, char const *file)
2455 struct ignore_pattern const *p;
2456 for (p = patterns; p; p = p->next)
2457 if (fnmatch (p->pattern, file, FNM_PERIOD) == 0)
2462 /* Return true if FILE should be ignored. */
2465 file_ignored (char const *name)
2467 return ((ignore_mode != IGNORE_MINIMAL
2469 && (ignore_mode == IGNORE_DEFAULT || ! name[1 + (name[1] == '.')]))
2470 || (ignore_mode == IGNORE_DEFAULT
2471 && patterns_match (hide_patterns, name))
2472 || patterns_match (ignore_patterns, name));
2475 /* POSIX requires that a file size be printed without a sign, even
2476 when negative. Assume the typical case where negative sizes are
2477 actually positive values that have wrapped around. */
2480 unsigned_file_size (off_t size)
2482 return size + (size < 0) * ((uintmax_t) OFF_T_MAX - OFF_T_MIN + 1);
2485 /* Enter and remove entries in the table `files'. */
2487 /* Empty the table of files. */
2494 for (i = 0; i < files_index; i++)
2496 free (files[i].name);
2497 free (files[i].linkname);
2502 any_has_acl = false;
2504 inode_number_width = 0;
2505 block_size_width = 0;
2510 major_device_number_width = 0;
2511 minor_device_number_width = 0;
2512 file_size_width = 0;
2515 /* Add a file to the current table of files.
2516 Verify that the file exists, and print an error message if it does not.
2517 Return the number of blocks that the file occupies. */
2520 gobble_file (char const *name, enum filetype type, ino_t inode,
2521 bool command_line_arg, char const *dirname)
2526 /* An inode value prior to gobble_file necessarily came from readdir,
2527 which is not used for command line arguments. */
2528 assert (! command_line_arg || inode == NOT_AN_INODE_NUMBER);
2530 if (files_index == nfiles)
2532 files = xnrealloc (files, nfiles, 2 * sizeof *files);
2536 f = &files[files_index];
2541 if (command_line_arg
2542 || format_needs_stat
2544 && (inode == NOT_AN_INODE_NUMBER
2545 /* When dereferencing symlinks, the inode must come from
2546 stat, but readdir provides the inode of lstat. Command
2547 line dereferences are already taken care of by the above
2548 assertion that the inode number is not yet known. */
2549 || (dereference == DEREF_ALWAYS
2550 && (type == symbolic_link || type == unknown))))
2551 || (format_needs_type
2552 && (type == unknown || type == command_line
2553 /* --indicator-style=classify (aka -F)
2554 requires that we stat each regular file
2555 to see if it's executable. */
2556 || (type == normal && (indicator_style == classify
2557 /* This is so that --color ends up
2558 highlighting files with the executable
2559 bit set even when options like -F are
2561 || (print_with_color
2562 && is_colored (C_EXEC))
2566 /* Absolute name of this file. */
2567 char *absolute_name;
2571 if (name[0] == '/' || dirname[0] == 0)
2572 absolute_name = (char *) name;
2575 absolute_name = alloca (strlen (name) + strlen (dirname) + 2);
2576 attach (absolute_name, dirname, name);
2579 switch (dereference)
2582 err = stat (absolute_name, &f->stat);
2585 case DEREF_COMMAND_LINE_ARGUMENTS:
2586 case DEREF_COMMAND_LINE_SYMLINK_TO_DIR:
2587 if (command_line_arg)
2590 err = stat (absolute_name, &f->stat);
2592 if (dereference == DEREF_COMMAND_LINE_ARGUMENTS)
2595 need_lstat = (err < 0
2597 : ! S_ISDIR (f->stat.st_mode));
2601 /* stat failed because of ENOENT, maybe indicating a dangling
2602 symlink. Or stat succeeded, ABSOLUTE_NAME does not refer to a
2603 directory, and --dereference-command-line-symlink-to-dir is
2604 in effect. Fall through so that we call lstat instead. */
2607 default: /* DEREF_NEVER */
2608 err = lstat (absolute_name, &f->stat);
2612 f->stat_failed = (err < 0);
2615 /* We treat stat failures for files the user named special.
2616 There is no guarantee that these files really exist so
2617 we do not print any information. */
2618 if (type == command_line)
2620 file_failure (1, "%s", absolute_name);
2625 memset (&f->stat, '\0', sizeof (f->stat));
2627 f->name = xstrdup (absolute_name);
2634 if (format == long_format)
2636 int n = file_has_acl (absolute_name, &f->stat);
2637 f->have_acl = (0 < n);
2638 any_has_acl |= f->have_acl;
2640 error (0, errno, "%s", quotearg_colon (absolute_name));
2644 if (S_ISLNK (f->stat.st_mode)
2645 && (format == long_format || check_symlink_color))
2648 struct stat linkstats;
2650 get_link_name (absolute_name, f, command_line_arg);
2651 linkname = make_link_name (absolute_name, f->linkname);
2653 /* Avoid following symbolic links when possible, ie, when
2654 they won't be traced and when no indicator is needed. */
2656 && (file_type <= indicator_style || check_symlink_color)
2657 && stat (linkname, &linkstats) == 0)
2661 /* Symbolic links to directories that are mentioned on the
2662 command line are automatically traced if not being
2664 if (!command_line_arg || format == long_format
2665 || !S_ISDIR (linkstats.st_mode))
2667 /* Get the linked-to file's mode for the filetype indicator
2668 in long listings. */
2669 f->linkmode = linkstats.st_mode;
2676 if (S_ISLNK (f->stat.st_mode))
2677 f->filetype = symbolic_link;
2678 else if (S_ISDIR (f->stat.st_mode))
2680 if (command_line_arg & !immediate_dirs)
2681 f->filetype = arg_directory;
2683 f->filetype = directory;
2686 f->filetype = normal;
2688 blocks = ST_NBLOCKS (f->stat);
2690 char buf[LONGEST_HUMAN_READABLE + 1];
2691 int len = mbswidth (human_readable (blocks, buf, human_output_opts,
2692 ST_NBLOCKSIZE, output_block_size),
2694 if (block_size_width < len)
2695 block_size_width = len;
2700 int len = format_user_width (f->stat.st_uid);
2701 if (owner_width < len)
2707 int len = format_group_width (f->stat.st_gid);
2708 if (group_width < len)
2714 int len = format_user_width (f->stat.st_author);
2715 if (author_width < len)
2720 char buf[INT_BUFSIZE_BOUND (uintmax_t)];
2721 int len = strlen (umaxtostr (f->stat.st_nlink, buf));
2722 if (nlink_width < len)
2726 if (S_ISCHR (f->stat.st_mode) || S_ISBLK (f->stat.st_mode))
2728 char buf[INT_BUFSIZE_BOUND (uintmax_t)];
2729 int len = strlen (umaxtostr (major (f->stat.st_rdev), buf));
2730 if (major_device_number_width < len)
2731 major_device_number_width = len;
2732 len = strlen (umaxtostr (minor (f->stat.st_rdev), buf));
2733 if (minor_device_number_width < len)
2734 minor_device_number_width = len;
2735 len = major_device_number_width + 2 + minor_device_number_width;
2736 if (file_size_width < len)
2737 file_size_width = len;
2741 char buf[LONGEST_HUMAN_READABLE + 1];
2742 uintmax_t size = unsigned_file_size (f->stat.st_size);
2743 int len = mbswidth (human_readable (size, buf, human_output_opts,
2744 1, file_output_block_size),
2746 if (file_size_width < len)
2747 file_size_width = len;
2753 f->stat.st_ino = inode;
2754 #if HAVE_STRUCT_DIRENT_D_TYPE && defined DTTOIF
2755 f->stat.st_mode = DTTOIF (type);
2762 char buf[INT_BUFSIZE_BOUND (uintmax_t)];
2763 int len = strlen (umaxtostr (f->stat.st_ino, buf));
2764 if (inode_number_width < len)
2765 inode_number_width = len;
2768 f->name = xstrdup (name);
2774 /* Return true if F refers to a directory. */
2776 is_directory (const struct fileinfo *f)
2778 return f->filetype == directory || f->filetype == arg_directory;
2784 /* Put the name of the file that FILENAME is a symbolic link to
2785 into the LINKNAME field of `f'. COMMAND_LINE_ARG indicates whether
2786 FILENAME is a command-line argument. */
2789 get_link_name (char const *filename, struct fileinfo *f, bool command_line_arg)
2791 f->linkname = xreadlink (filename, f->stat.st_size);
2792 if (f->linkname == NULL)
2793 file_failure (command_line_arg, _("cannot read symbolic link %s"),
2797 /* If `linkname' is a relative name and `name' contains one or more
2798 leading directories, return `linkname' with those directories
2799 prepended; otherwise, return a copy of `linkname'.
2800 If `linkname' is zero, return zero. */
2803 make_link_name (char const *name, char const *linkname)
2811 if (*linkname == '/')
2812 return xstrdup (linkname);
2814 /* The link is to a relative name. Prepend any leading directory
2815 in `name' to the link name. */
2816 linkbuf = strrchr (name, '/');
2818 return xstrdup (linkname);
2820 bufsiz = linkbuf - name + 1;
2821 linkbuf = xmalloc (bufsiz + strlen (linkname) + 1);
2822 strncpy (linkbuf, name, bufsiz);
2823 strcpy (linkbuf + bufsiz, linkname);
2828 /* Return true if the last component of NAME is `.' or `..'
2829 This is so we don't try to recurse on `././././. ...' */
2832 basename_is_dot_or_dotdot (const char *name)
2834 char const *base = last_component (name);
2835 return DOT_OR_DOTDOT (base);
2838 /* Remove any entries from FILES that are for directories,
2839 and queue them to be listed as directories instead.
2840 DIRNAME is the prefix to prepend to each dirname
2841 to make it correct relative to ls's working dir;
2842 if it is null, no prefix is needed and "." and ".." should not be ignored.
2843 If COMMAND_LINE_ARG is true, this directory was mentioned at the top level,
2844 This is desirable when processing directories recursively. */
2847 extract_dirs_from_files (char const *dirname, bool command_line_arg)
2851 bool ignore_dot_and_dot_dot = (dirname != NULL);
2853 if (dirname && LOOP_DETECT)
2855 /* Insert a marker entry first. When we dequeue this marker entry,
2856 we'll know that DIRNAME has been processed and may be removed
2857 from the set of active directories. */
2858 queue_directory (NULL, dirname, false);
2861 /* Queue the directories last one first, because queueing reverses the
2863 for (i = files_index; i-- != 0; )
2864 if (is_directory (&files[i])
2865 && (! ignore_dot_and_dot_dot
2866 || ! basename_is_dot_or_dotdot (files[i].name)))
2868 if (!dirname || files[i].name[0] == '/')
2870 queue_directory (files[i].name, files[i].linkname,
2875 char *name = file_name_concat (dirname, files[i].name, NULL);
2876 queue_directory (name, files[i].linkname, command_line_arg);
2879 if (files[i].filetype == arg_directory)
2880 free (files[i].name);
2883 /* Now delete the directories from the table, compacting all the remaining
2886 for (i = 0, j = 0; i < files_index; i++)
2888 if (files[i].filetype != arg_directory)
2891 files[j] = files[i];
2898 /* Use strcoll to compare strings in this locale. If an error occurs,
2899 report an error and longjmp to failed_strcoll. */
2901 static jmp_buf failed_strcoll;
2904 xstrcoll (char const *a, char const *b)
2908 diff = strcoll (a, b);
2911 error (0, errno, _("cannot compare file names %s and %s"),
2912 quote_n (0, a), quote_n (1, b));
2913 set_exit_status (false);
2914 longjmp (failed_strcoll, 1);
2919 /* Comparison routines for sorting the files. */
2921 typedef void const *V;
2922 typedef int (*qsortFunc)(V a, V b);
2924 /* Used below in DEFINE_SORT_FUNCTIONS for _df_ sort function variants.
2925 The do { ... } while(0) makes it possible to use the macro more like
2926 a statement, without violating C89 rules: */
2927 #define DIRFIRST_CHECK(a, b) \
2930 bool a_is_dir = is_directory ((struct fileinfo const *) a); \
2931 bool b_is_dir = is_directory ((struct fileinfo const *) b); \
2932 if (a_is_dir && !b_is_dir) \
2933 return -1; /* a goes before b */ \
2934 if (!a_is_dir && b_is_dir) \
2935 return 1; /* b goes before a */ \
2939 /* Define the 8 different sort function variants required for each sortkey.
2940 KEY_NAME is a token describing the sort key, e.g., ctime, atime, size.
2941 KEY_CMP_FUNC is a function to compare records based on that key, e.g.,
2942 ctime_cmp, atime_cmp, size_cmp. Append KEY_NAME to the string,
2943 '[rev_][x]str{cmp|coll}[_df]_', to create each function name. */
2944 #define DEFINE_SORT_FUNCTIONS(key_name, key_cmp_func) \
2945 /* direct, non-dirfirst versions */ \
2946 static int xstrcoll_##key_name (V a, V b) \
2947 { return key_cmp_func (a, b, xstrcoll); } \
2948 static int strcmp_##key_name (V a, V b) \
2949 { return key_cmp_func (a, b, strcmp); } \
2951 /* reverse, non-dirfirst versions */ \
2952 static int rev_xstrcoll_##key_name (V a, V b) \
2953 { return key_cmp_func (b, a, xstrcoll); } \
2954 static int rev_strcmp_##key_name (V a, V b) \
2955 { return key_cmp_func (b, a, strcmp); } \
2957 /* direct, dirfirst versions */ \
2958 static int xstrcoll_df_##key_name (V a, V b) \
2959 { DIRFIRST_CHECK (a, b); return key_cmp_func (a, b, xstrcoll); } \
2960 static int strcmp_df_##key_name (V a, V b) \
2961 { DIRFIRST_CHECK (a, b); return key_cmp_func (a, b, strcmp); } \
2963 /* reverse, dirfirst versions */ \
2964 static int rev_xstrcoll_df_##key_name (V a, V b) \
2965 { DIRFIRST_CHECK (a, b); return key_cmp_func (b, a, xstrcoll); } \
2966 static int rev_strcmp_df_##key_name (V a, V b) \
2967 { DIRFIRST_CHECK (a, b); return key_cmp_func (b, a, strcmp); }
2970 cmp_ctime (struct fileinfo const *a, struct fileinfo const *b,
2971 int (*cmp) (char const *, char const *))
2973 int diff = timespec_cmp (get_stat_ctime (&b->stat),
2974 get_stat_ctime (&a->stat));
2975 return diff ? diff : cmp (a->name, b->name);
2979 cmp_mtime (struct fileinfo const *a, struct fileinfo const *b,
2980 int (*cmp) (char const *, char const *))
2982 int diff = timespec_cmp (get_stat_mtime (&b->stat),
2983 get_stat_mtime (&a->stat));
2984 return diff ? diff : cmp (a->name, b->name);
2988 cmp_atime (struct fileinfo const *a, struct fileinfo const *b,
2989 int (*cmp) (char const *, char const *))
2991 int diff = timespec_cmp (get_stat_atime (&b->stat),
2992 get_stat_atime (&a->stat));
2993 return diff ? diff : cmp (a->name, b->name);
2997 cmp_size (struct fileinfo const *a, struct fileinfo const *b,
2998 int (*cmp) (char const *, char const *))
3000 int diff = longdiff (b->stat.st_size, a->stat.st_size);
3001 return diff ? diff : cmp (a->name, b->name);
3005 cmp_name (struct fileinfo const *a, struct fileinfo const *b,
3006 int (*cmp) (char const *, char const *))
3008 return cmp (a->name, b->name);
3011 /* Compare file extensions. Files with no extension are `smallest'.
3012 If extensions are the same, compare by filenames instead. */
3015 cmp_extension (struct fileinfo const *a, struct fileinfo const *b,
3016 int (*cmp) (char const *, char const *))
3018 char const *base1 = strrchr (a->name, '.');
3019 char const *base2 = strrchr (b->name, '.');
3020 int diff = cmp (base1 ? base1 : "", base2 ? base2 : "");
3021 return diff ? diff : cmp (a->name, b->name);
3024 DEFINE_SORT_FUNCTIONS (ctime, cmp_ctime)
3025 DEFINE_SORT_FUNCTIONS (mtime, cmp_mtime)
3026 DEFINE_SORT_FUNCTIONS (atime, cmp_atime)
3027 DEFINE_SORT_FUNCTIONS (size, cmp_size)
3028 DEFINE_SORT_FUNCTIONS (name, cmp_name)
3029 DEFINE_SORT_FUNCTIONS (extension, cmp_extension)
3031 /* Compare file versions.
3032 Unlike all other compare functions above, cmp_version depends only
3033 on strverscmp, which does not fail (even for locale reasons), and does not
3034 need a secondary sort key.
3035 All the other sort options, in fact, need xstrcoll and strcmp variants,
3036 because they all use a string comparison (either as the primary or secondary
3037 sort key), and xstrcoll has the ability to do a longjmp if strcoll fails for
3038 locale reasons. Last, strverscmp is ALWAYS available in coreutils,
3039 thanks to the gnulib library. */
3041 cmp_version (struct fileinfo const *a, struct fileinfo const *b)
3043 return strverscmp (a->name, b->name);
3046 static int xstrcoll_version (V a, V b)
3047 { return cmp_version (a, b); }
3048 static int rev_xstrcoll_version (V a, V b)
3049 { return cmp_version (b, a); }
3050 static int xstrcoll_df_version (V a, V b)
3051 { DIRFIRST_CHECK (a, b); return cmp_version (a, b); }
3052 static int rev_xstrcoll_df_version (V a, V b)
3053 { DIRFIRST_CHECK (a, b); return cmp_version (b, a); }
3056 /* We have 2^3 different variants for each sortkey function
3057 (for 3 independent sort modes).
3058 The function pointers stored in this array must be dereferenced as:
3060 sort_variants[sort_key][use_strcmp][reverse][dirs_first]
3062 Note that the order in which sortkeys are listed in the function pointer
3063 array below is defined by the order of the elements in the time_type and
3066 #define LIST_SORTFUNCTION_VARIANTS(key_name) \
3069 { xstrcoll_##key_name, xstrcoll_df_##key_name }, \
3070 { rev_xstrcoll_##key_name, rev_xstrcoll_df_##key_name }, \
3073 { strcmp_##key_name, strcmp_df_##key_name }, \
3074 { rev_strcmp_##key_name, rev_strcmp_df_##key_name }, \
3078 static qsortFunc sort_functions[][2][2][2] =
3080 LIST_SORTFUNCTION_VARIANTS (name),
3081 LIST_SORTFUNCTION_VARIANTS (extension),
3082 LIST_SORTFUNCTION_VARIANTS (size),
3086 { xstrcoll_version, xstrcoll_df_version },
3087 { rev_xstrcoll_version, rev_xstrcoll_df_version },
3090 /* We use NULL for the strcmp variants of version comparison
3091 since as explained in cmp_version definition, version comparison
3092 does not rely on xstrcoll, so it will never longjmp, and never
3093 need to try the strcmp fallback. */
3100 /* last are time sort functions */
3101 LIST_SORTFUNCTION_VARIANTS (mtime),
3102 LIST_SORTFUNCTION_VARIANTS (ctime),
3103 LIST_SORTFUNCTION_VARIANTS (atime)
3106 /* The number of sortkeys is calculated as
3107 the number of elements in the sort_type enum (i.e. sort_numtypes) +
3108 the number of elements in the time_type enum (i.e. time_numtypes) - 1
3109 This is because when sort_type==sort_time, we have up to
3110 time_numtypes possible sortkeys.
3112 This line verifies at compile-time that the array of sort functions has been
3113 initialized for all possible sortkeys. */
3114 verify (ARRAY_CARDINALITY (sort_functions)
3115 == sort_numtypes + time_numtypes - 1 );
3118 /* Sort the files now in the table. */
3125 if (sort_type == sort_none)
3128 /* Try strcoll. If it fails, fall back on strcmp. We can't safely
3129 ignore strcoll failures, as a failing strcoll might be a
3130 comparison function that is not a total order, and if we ignored
3131 the failure this might cause qsort to dump core. */
3133 if (! setjmp (failed_strcoll))
3134 use_strcmp = false; /* strcoll() succeeded */
3138 assert (sort_type != sort_version);
3141 /* When sort_type == sort_time, use time_type as subindex. */
3142 int timeoffset = sort_type == sort_time ? time_type : 0;
3144 qsort (files, files_index, sizeof *files,
3145 sort_functions[sort_type + timeoffset][use_strcmp][sort_reverse]
3146 [directories_first]);
3149 /* List all the files now in the table. */
3152 print_current_files (void)
3159 for (i = 0; i < files_index; i++)
3161 print_file_name_and_frills (files + i);
3167 print_many_per_line ();
3171 print_horizontal ();
3175 print_with_commas ();
3179 for (i = 0; i < files_index; i++)
3181 print_long_format (files + i);
3182 DIRED_PUTCHAR ('\n');
3188 /* Return the expected number of columns in a long-format time stamp,
3189 or zero if it cannot be calculated. */
3192 long_time_expected_width (void)
3194 static int width = -1;
3199 struct tm const *tm = localtime (&epoch);
3200 char buf[TIME_STAMP_LEN_MAXIMUM + 1];
3202 /* In case you're wondering if localtime can fail with an input time_t
3203 value of 0, let's just say it's very unlikely, but not inconceivable.
3204 The TZ environment variable would have to specify a time zone that
3205 is 2**31-1900 years or more ahead of UTC. This could happen only on
3206 a 64-bit system that blindly accepts e.g., TZ=UTC+20000000000000.
3207 However, this is not possible with Solaris 10 or glibc-2.3.5, since
3208 their implementations limit the offset to 167:59 and 24:00, resp. */
3212 nstrftime (buf, sizeof buf, long_time_format[0], tm, 0, 0);
3214 width = mbsnwidth (buf, len, 0);
3224 /* Get the current time. */
3227 get_current_time (void)
3229 #if HAVE_CLOCK_GETTIME && defined CLOCK_REALTIME
3231 struct timespec timespec;
3232 if (clock_gettime (CLOCK_REALTIME, ×pec) == 0)
3234 current_time = timespec.tv_sec;
3235 current_time_ns = timespec.tv_nsec;
3241 /* The clock does not have nanosecond resolution, so get the maximum
3242 possible value for the current time that is consistent with the
3243 reported clock. That way, files are not considered to be in the
3244 future merely because their time stamps have higher resolution
3245 than the clock resolution. */
3247 #if HAVE_GETTIMEOFDAY
3249 struct timeval timeval;
3250 gettimeofday (&timeval, NULL);
3251 current_time = timeval.tv_sec;
3252 current_time_ns = timeval.tv_usec * 1000 + 999;
3255 current_time = time (NULL);
3256 current_time_ns = 999999999;
3260 /* Print the user or group name NAME, with numeric id ID, using a
3261 print width of WIDTH columns. */
3264 format_user_or_group (char const *name, unsigned long int id, int width)
3270 int width_gap = width - mbswidth (name, 0);
3271 int pad = MAX (0, width_gap);
3272 fputs (name, stdout);
3273 len = strlen (name) + pad;
3281 printf ("%*lu ", width, id);
3285 dired_pos += len + 1;
3288 /* Print the name or id of the user with id U, using a print width of
3292 format_user (uid_t u, int width, int stat_failed)
3294 format_user_or_group (stat_failed ? "?" :
3295 (numeric_ids ? NULL : getuser (u)), u, width);
3298 /* Likewise, for groups. */
3301 format_group (gid_t g, int width, int stat_failed)
3303 format_user_or_group (stat_failed ? "?" :
3304 (numeric_ids ? NULL : getgroup (g)), g, width);
3307 /* Return the number of columns that format_user_or_group will print. */
3310 format_user_or_group_width (char const *name, unsigned long int id)
3314 int len = mbswidth (name, 0);
3315 return MAX (0, len);
3319 char buf[INT_BUFSIZE_BOUND (unsigned long int)];
3320 sprintf (buf, "%lu", id);
3321 return strlen (buf);
3325 /* Return the number of columns that format_user will print. */
3328 format_user_width (uid_t u)
3330 return format_user_or_group_width (numeric_ids ? NULL : getuser (u), u);
3333 /* Likewise, for groups. */
3336 format_group_width (gid_t g)
3338 return format_user_or_group_width (numeric_ids ? NULL : getgroup (g), g);
3342 /* Print information about F in long format. */
3345 print_long_format (const struct fileinfo *f)
3349 [LONGEST_HUMAN_READABLE + 1 /* inode */
3350 + LONGEST_HUMAN_READABLE + 1 /* size in blocks */
3351 + sizeof (modebuf) - 1 + 1 /* mode string */
3352 + INT_BUFSIZE_BOUND (uintmax_t) /* st_nlink */
3353 + LONGEST_HUMAN_READABLE + 2 /* major device number */
3354 + LONGEST_HUMAN_READABLE + 1 /* minor device number */
3355 + TIME_STAMP_LEN_MAXIMUM + 1 /* max length of time/date */
3361 struct timespec when_timespec;
3362 struct tm *when_local;
3364 /* Compute the mode string, except remove the trailing space if no
3365 files in this directory have ACLs. */
3366 filemodestring (&f->stat, modebuf);
3369 else if (FILE_HAS_ACL (f))
3375 when_timespec = get_stat_ctime (&f->stat);
3378 when_timespec = get_stat_mtime (&f->stat);
3381 when_timespec = get_stat_atime (&f->stat);
3387 when = when_timespec.tv_sec;
3388 when_ns = when_timespec.tv_nsec;
3394 char hbuf[INT_BUFSIZE_BOUND (uintmax_t)];
3395 sprintf (p, "%*s ", inode_number_width,
3396 f->stat_failed ? "?" : umaxtostr (f->stat.st_ino, hbuf));
3397 p += inode_number_width + 1;
3400 if (print_block_size)
3402 char hbuf[LONGEST_HUMAN_READABLE + 1];
3403 char const *blocks =
3406 : human_readable (ST_NBLOCKS (f->stat), hbuf, human_output_opts,
3407 ST_NBLOCKSIZE, output_block_size);
3409 for (pad = block_size_width - mbswidth (blocks, 0); 0 < pad; pad--)
3411 while ((*p++ = *blocks++))
3416 /* The last byte of the mode string is the POSIX
3417 "optional alternate access method flag". */
3419 char hbuf[INT_BUFSIZE_BOUND (uintmax_t)];
3420 sprintf (p, "%s %*s ", modebuf, nlink_width,
3421 f->stat_failed ? "?" : umaxtostr (f->stat.st_nlink, hbuf));
3423 p += sizeof modebuf - 2 + any_has_acl + 1 + nlink_width + 1;
3427 if (print_owner | print_group | print_author)
3429 DIRED_FPUTS (buf, stdout, p - buf);
3432 format_user (f->stat.st_uid, owner_width, f->stat_failed);
3435 format_group (f->stat.st_gid, group_width, f->stat_failed);
3438 format_user (f->stat.st_author, author_width, f->stat_failed);
3444 && (S_ISCHR (f->stat.st_mode) || S_ISBLK (f->stat.st_mode)))
3446 char majorbuf[INT_BUFSIZE_BOUND (uintmax_t)];
3447 char minorbuf[INT_BUFSIZE_BOUND (uintmax_t)];
3448 int blanks_width = (file_size_width
3449 - (major_device_number_width + 2
3450 + minor_device_number_width));
3451 sprintf (p, "%*s, %*s ",
3452 major_device_number_width + MAX (0, blanks_width),
3453 umaxtostr (major (f->stat.st_rdev), majorbuf),
3454 minor_device_number_width,
3455 umaxtostr (minor (f->stat.st_rdev), minorbuf));
3456 p += file_size_width + 1;
3460 char hbuf[LONGEST_HUMAN_READABLE + 1];
3464 : human_readable (unsigned_file_size (f->stat.st_size),
3465 hbuf, human_output_opts, 1, file_output_block_size);
3467 for (pad = file_size_width - mbswidth (size, 0); 0 < pad; pad--)
3469 while ((*p++ = *size++))
3474 when_local = localtime (&when_timespec.tv_sec);
3478 if (!f->stat_failed && when_local)
3480 time_t six_months_ago;
3484 /* If the file appears to be in the future, update the current
3485 time, in case the file happens to have been modified since
3486 the last time we checked the clock. */
3487 if (current_time < when
3488 || (current_time == when && current_time_ns < when_ns))
3490 /* Note that get_current_time calls gettimeofday which, on some non-
3491 compliant systems, clobbers the buffer used for localtime's result.
3492 But it's ok here, because we use a gettimeofday wrapper that
3493 saves and restores the buffer around the gettimeofday call. */
3494 get_current_time ();
3497 /* Consider a time to be recent if it is within the past six
3498 months. A Gregorian year has 365.2425 * 24 * 60 * 60 ==
3499 31556952 seconds on the average. Write this value as an
3500 integer constant to avoid floating point hassles. */
3501 six_months_ago = current_time - 31556952 / 2;
3502 recent = (six_months_ago <= when
3503 && (when < current_time
3504 || (when == current_time && when_ns <= current_time_ns)));
3505 fmt = long_time_format[recent];
3507 s = nstrftime (p, TIME_STAMP_LEN_MAXIMUM + 1, fmt,
3508 when_local, 0, when_ns);
3516 /* NUL-terminate the string -- fputs (via DIRED_FPUTS) requires it. */
3521 /* The time cannot be converted using the desired format, so
3522 print it as a huge integer number of seconds. */
3523 char hbuf[INT_BUFSIZE_BOUND (intmax_t)];
3524 sprintf (p, "%*s ", long_time_expected_width (),
3527 : (TYPE_SIGNED (time_t)
3528 ? imaxtostr (when, hbuf)
3529 : umaxtostr (when, hbuf)));
3533 DIRED_FPUTS (buf, stdout, p - buf);
3534 print_name_with_quoting (f->name, FILE_OR_LINK_MODE (f), f->linkok,
3535 f->stat_failed, &dired_obstack);
3537 if (f->filetype == symbolic_link)
3541 DIRED_FPUTS_LITERAL (" -> ", stdout);
3542 print_name_with_quoting (f->linkname, f->linkmode, f->linkok - 1,
3543 f->stat_failed, NULL);
3544 if (indicator_style != none)
3545 print_type_indicator (f->linkmode);
3548 else if (indicator_style != none)
3549 print_type_indicator (f->stat.st_mode);
3552 /* Output to OUT a quoted representation of the file name NAME,
3553 using OPTIONS to control quoting. Produce no output if OUT is NULL.
3554 Store the number of screen columns occupied by NAME's quoted
3555 representation into WIDTH, if non-NULL. Return the number of bytes
3559 quote_name (FILE *out, const char *name, struct quoting_options const *options,
3562 char smallbuf[BUFSIZ];
3563 size_t len = quotearg_buffer (smallbuf, sizeof smallbuf, name, -1, options);
3565 size_t displayed_width IF_LINT (= 0);
3567 if (len < sizeof smallbuf)
3571 buf = alloca (len + 1);
3572 quotearg_buffer (buf, len + 1, name, -1, options);
3575 if (qmark_funny_chars)
3580 char const *p = buf;
3581 char const *plimit = buf + len;
3583 displayed_width = 0;
3588 case ' ': case '!': case '"': case '#': case '%':
3589 case '&': case '\'': case '(': case ')': case '*':
3590 case '+': case ',': case '-': case '.': case '/':
3591 case '0': case '1': case '2': case '3': case '4':
3592 case '5': case '6': case '7': case '8': case '9':
3593 case ':': case ';': case '<': case '=': case '>':
3595 case 'A': case 'B': case 'C': case 'D': case 'E':
3596 case 'F': case 'G': case 'H': case 'I': case 'J':
3597 case 'K': case 'L': case 'M': case 'N': case 'O':
3598 case 'P': case 'Q': case 'R': case 'S': case 'T':
3599 case 'U': case 'V': case 'W': case 'X': case 'Y':
3601 case '[': case '\\': case ']': case '^': case '_':
3602 case 'a': case 'b': case 'c': case 'd': case 'e':
3603 case 'f': case 'g': case 'h': case 'i': case 'j':
3604 case 'k': case 'l': case 'm': case 'n': case 'o':
3605 case 'p': case 'q': case 'r': case 's': case 't':
3606 case 'u': case 'v': case 'w': case 'x': case 'y':
3607 case 'z': case '{': case '|': case '}': case '~':
3608 /* These characters are printable ASCII characters. */
3610 displayed_width += 1;
3613 /* If we have a multibyte sequence, copy it until we
3614 reach its end, replacing each non-printable multibyte
3615 character with a single question mark. */
3618 memset (&mbstate, 0, sizeof mbstate);
3625 bytes = mbrtowc (&wc, p, plimit - p, &mbstate);
3627 if (bytes == (size_t) -1)
3629 /* An invalid multibyte sequence was
3630 encountered. Skip one input byte, and
3631 put a question mark. */
3634 displayed_width += 1;
3638 if (bytes == (size_t) -2)
3640 /* An incomplete multibyte character
3641 at the end. Replace it entirely with
3645 displayed_width += 1;
3650 /* A null wide character was encountered. */
3656 /* A printable multibyte character.
3658 for (; bytes > 0; --bytes)
3660 displayed_width += w;
3664 /* An unprintable multibyte character.
3665 Replace it entirely with a question
3669 displayed_width += 1;
3672 while (! mbsinit (&mbstate));
3677 /* The buffer may have shrunk. */
3684 char const *plimit = buf + len;
3688 if (! isprint (to_uchar (*p)))
3692 displayed_width = len;
3695 else if (width != NULL)
3699 displayed_width = mbsnwidth (buf, len, 0);
3703 char const *p = buf;
3704 char const *plimit = buf + len;
3706 displayed_width = 0;
3709 if (isprint (to_uchar (*p)))
3717 fwrite (buf, 1, len, out);
3719 *width = displayed_width;
3724 print_name_with_quoting (const char *p, mode_t mode, int linkok,
3725 int stat_failed, struct obstack *stack)
3727 if (print_with_color)
3728 print_color_indicator (p, mode, linkok, stat_failed);
3731 PUSH_CURRENT_DIRED_POS (stack);
3733 dired_pos += quote_name (stdout, p, filename_quoting_options, NULL);
3736 PUSH_CURRENT_DIRED_POS (stack);
3738 if (print_with_color)
3741 prep_non_filename_text ();
3746 prep_non_filename_text (void)
3748 if (color_indicator[C_END].string != NULL)
3749 put_indicator (&color_indicator[C_END]);
3752 put_indicator (&color_indicator[C_LEFT]);
3753 put_indicator (&color_indicator[C_NORM]);
3754 put_indicator (&color_indicator[C_RIGHT]);
3758 /* Print the file name of `f' with appropriate quoting.
3759 Also print file size, inode number, and filetype indicator character,
3760 as requested by switches. */
3763 print_file_name_and_frills (const struct fileinfo *f)
3765 char buf[MAX (LONGEST_HUMAN_READABLE + 1, INT_BUFSIZE_BOUND (uintmax_t))];
3768 printf ("%*s ", format == with_commas ? 0 : inode_number_width,
3769 umaxtostr (f->stat.st_ino, buf));
3771 if (print_block_size)
3772 printf ("%*s ", format == with_commas ? 0 : block_size_width,
3773 human_readable (ST_NBLOCKS (f->stat), buf, human_output_opts,
3774 ST_NBLOCKSIZE, output_block_size));
3776 print_name_with_quoting (f->name, FILE_OR_LINK_MODE (f), f->linkok,
3777 f->stat_failed, NULL);
3779 if (indicator_style != none)
3780 print_type_indicator (f->stat.st_mode);
3784 print_type_indicator (mode_t mode)
3790 if (indicator_style == classify && (mode & S_IXUGO))
3799 else if (indicator_style == slash)
3801 else if (S_ISLNK (mode))
3803 else if (S_ISFIFO (mode))
3805 else if (S_ISSOCK (mode))
3807 else if (S_ISDOOR (mode))
3818 print_color_indicator (const char *name, mode_t mode, int linkok,
3822 struct color_ext_type *ext; /* Color extension */
3823 size_t len; /* Length of name */
3825 /* Is this a nonexistent file? If so, linkok == -1. */
3827 if (linkok == -1 && color_indicator[C_MISSING].string != NULL)
3836 if ((mode & S_ISVTX) && (mode & S_IWOTH))
3837 type = C_STICKY_OTHER_WRITABLE;
3838 else if ((mode & S_IWOTH) != 0)
3839 type = C_OTHER_WRITABLE;
3840 else if ((mode & S_ISVTX) != 0)
3845 else if (S_ISLNK (mode))
3846 type = ((!linkok && color_indicator[C_ORPHAN].string)
3847 ? C_ORPHAN : C_LINK);
3848 else if (S_ISFIFO (mode))
3850 else if (S_ISSOCK (mode))
3852 else if (S_ISBLK (mode))
3854 else if (S_ISCHR (mode))
3856 else if (S_ISDOOR (mode))
3858 else if (stat_failed)
3863 if ((mode & S_ISUID) != 0)
3865 else if ((mode & S_ISGID) != 0)
3867 else if ((mode & S_IXUGO) != 0)
3871 /* Check the file's suffix only if still classified as C_FILE. */
3875 /* Test if NAME has a recognized suffix. */
3877 len = strlen (name);
3878 name += len; /* Pointer to final \0. */
3879 for (ext = color_ext_list; ext != NULL; ext = ext->next)
3881 if (ext->ext.len <= len
3882 && strncmp (name - ext->ext.len, ext->ext.string,
3889 put_indicator (&color_indicator[C_LEFT]);
3890 put_indicator (ext ? &(ext->seq) : &color_indicator[type]);
3891 put_indicator (&color_indicator[C_RIGHT]);
3894 /* Output a color indicator (which may contain nulls). */
3896 put_indicator (const struct bin_str *ind)
3903 for (i = ind->len; i != 0; --i)
3908 length_of_file_name_and_frills (const struct fileinfo *f)
3912 char buf[MAX (LONGEST_HUMAN_READABLE + 1, INT_BUFSIZE_BOUND (uintmax_t))];
3915 len += 1 + (format == with_commas
3916 ? strlen (umaxtostr (f->stat.st_ino, buf))
3917 : inode_number_width);
3919 if (print_block_size)
3920 len += 1 + (format == with_commas
3921 ? strlen (human_readable (ST_NBLOCKS (f->stat), buf,
3922 human_output_opts, ST_NBLOCKSIZE,
3924 : block_size_width);
3926 quote_name (NULL, f->name, filename_quoting_options, &name_width);
3929 if (indicator_style != none)
3931 mode_t mode = f->stat.st_mode;
3933 len += (S_ISREG (mode)
3934 ? (indicator_style == classify && (mode & S_IXUGO))
3936 || (indicator_style != slash
3940 || S_ISDOOR (mode)))));
3947 print_many_per_line (void)
3949 size_t row; /* Current row. */
3950 size_t cols = calculate_columns (true);
3951 struct column_info const *line_fmt = &column_info[cols - 1];
3953 /* Calculate the number of rows that will be in each column except possibly
3954 for a short column on the right. */
3955 size_t rows = files_index / cols + (files_index % cols != 0);
3957 for (row = 0; row < rows; row++)
3960 size_t filesno = row;
3963 /* Print the next row. */
3966 size_t name_length = length_of_file_name_and_frills (files + filesno);
3967 size_t max_name_length = line_fmt->col_arr[col++];
3968 print_file_name_and_frills (files + filesno);
3971 if (filesno >= files_index)
3974 indent (pos + name_length, pos + max_name_length);
3975 pos += max_name_length;
3982 print_horizontal (void)
3986 size_t cols = calculate_columns (false);
3987 struct column_info const *line_fmt = &column_info[cols - 1];
3988 size_t name_length = length_of_file_name_and_frills (files);
3989 size_t max_name_length = line_fmt->col_arr[0];
3991 /* Print first entry. */
3992 print_file_name_and_frills (files);
3995 for (filesno = 1; filesno < files_index; ++filesno)
3997 size_t col = filesno % cols;
4006 indent (pos + name_length, pos + max_name_length);
4007 pos += max_name_length;
4010 print_file_name_and_frills (files + filesno);
4012 name_length = length_of_file_name_and_frills (files + filesno);
4013 max_name_length = line_fmt->col_arr[col];
4019 print_with_commas (void)
4024 for (filesno = 0; filesno < files_index; filesno++)
4026 size_t len = length_of_file_name_and_frills (files + filesno);
4032 if (pos + len + 2 < line_length)
4044 putchar (separator);
4047 print_file_name_and_frills (files + filesno);
4053 /* Assuming cursor is at position FROM, indent up to position TO.
4054 Use a TAB character instead of two or more spaces whenever possible. */
4057 indent (size_t from, size_t to)
4061 if (tabsize != 0 && to / tabsize > (from + 1) / tabsize)
4064 from += tabsize - from % tabsize;
4074 /* Put DIRNAME/NAME into DEST, handling `.' and `/' properly. */
4075 /* FIXME: maybe remove this function someday. See about using a
4076 non-malloc'ing version of file_name_concat. */
4079 attach (char *dest, const char *dirname, const char *name)
4081 const char *dirnamep = dirname;
4083 /* Copy dirname if it is not ".". */
4084 if (dirname[0] != '.' || dirname[1] != 0)
4087 *dest++ = *dirnamep++;
4088 /* Add '/' if `dirname' doesn't already end with it. */
4089 if (dirnamep > dirname && dirnamep[-1] != '/')
4097 /* Allocate enough column info suitable for the current number of
4098 files and display columns, and initialize the info to represent the
4099 narrowest possible columns. */
4102 init_column_info (void)
4105 size_t max_cols = MIN (max_idx, files_index);
4107 /* Currently allocated columns in column_info. */
4108 static size_t column_info_alloc;
4110 if (column_info_alloc < max_cols)
4112 size_t new_column_info_alloc;
4115 if (max_cols < max_idx / 2)
4117 /* The number of columns is far less than the display width
4118 allows. Grow the allocation, but only so that it's
4119 double the current requirements. If the display is
4120 extremely wide, this avoids allocating a lot of memory
4121 that is never needed. */
4122 column_info = xnrealloc (column_info, max_cols,
4123 2 * sizeof *column_info);
4124 new_column_info_alloc = 2 * max_cols;
4128 column_info = xnrealloc (column_info, max_idx, sizeof *column_info);
4129 new_column_info_alloc = max_idx;
4132 /* Allocate the new size_t objects by computing the triangle
4133 formula n * (n + 1) / 2, except that we don't need to
4134 allocate the part of the triangle that we've already
4135 allocated. Check for address arithmetic overflow. */
4137 size_t column_info_growth = new_column_info_alloc - column_info_alloc;
4138 size_t s = column_info_alloc + 1 + new_column_info_alloc;
4139 size_t t = s * column_info_growth;
4140 if (s < new_column_info_alloc || t / column_info_growth != s)
4142 p = xnmalloc (t / 2, sizeof *p);
4145 /* Grow the triangle by parceling out the cells just allocated. */
4146 for (i = column_info_alloc; i < new_column_info_alloc; i++)
4148 column_info[i].col_arr = p;
4152 column_info_alloc = new_column_info_alloc;
4155 for (i = 0; i < max_cols; ++i)
4159 column_info[i].valid_len = true;
4160 column_info[i].line_len = (i + 1) * MIN_COLUMN_WIDTH;
4161 for (j = 0; j <= i; ++j)
4162 column_info[i].col_arr[j] = MIN_COLUMN_WIDTH;
4166 /* Calculate the number of columns needed to represent the current set
4167 of files in the current display width. */
4170 calculate_columns (bool by_columns)
4172 size_t filesno; /* Index into files. */
4173 size_t cols; /* Number of files across. */
4175 /* Normally the maximum number of columns is determined by the
4176 screen width. But if few files are available this might limit it
4178 size_t max_cols = MIN (max_idx, files_index);
4180 init_column_info ();
4182 /* Compute the maximum number of possible columns. */
4183 for (filesno = 0; filesno < files_index; ++filesno)
4185 size_t name_length = length_of_file_name_and_frills (files + filesno);
4188 for (i = 0; i < max_cols; ++i)
4190 if (column_info[i].valid_len)
4192 size_t idx = (by_columns
4193 ? filesno / ((files_index + i) / (i + 1))
4194 : filesno % (i + 1));
4195 size_t real_length = name_length + (idx == i ? 0 : 2);
4197 if (column_info[i].col_arr[idx] < real_length)
4199 column_info[i].line_len += (real_length
4200 - column_info[i].col_arr[idx]);
4201 column_info[i].col_arr[idx] = real_length;
4202 column_info[i].valid_len = (column_info[i].line_len
4209 /* Find maximum allowed columns. */
4210 for (cols = max_cols; 1 < cols; --cols)
4212 if (column_info[cols - 1].valid_len)
4222 if (status != EXIT_SUCCESS)
4223 fprintf (stderr, _("Try `%s --help' for more information.\n"),
4227 printf (_("Usage: %s [OPTION]... [FILE]...\n"), program_name);
4229 List information about the FILEs (the current directory by default).\n\
4230 Sort entries alphabetically if none of -cftuvSUX nor --sort.\n\
4234 Mandatory arguments to long options are mandatory for short options too.\n\
4237 -a, --all do not ignore entries starting with .\n\
4238 -A, --almost-all do not list implied . and ..\n\
4239 --author with -l, print the author of each file\n\
4240 -b, --escape print octal escapes for nongraphic characters\n\
4243 --block-size=SIZE use SIZE-byte blocks\n\
4244 -B, --ignore-backups do not list implied entries ending with ~\n\
4245 -c with -lt: sort by, and show, ctime (time of last\n\
4246 modification of file status information)\n\
4247 with -l: show ctime and sort by name\n\
4248 otherwise: sort by ctime\n\
4251 -C list entries by columns\n\
4252 --color[=WHEN] control whether color is used to distinguish file\n\
4253 types. WHEN may be `never', `always', or `auto'\n\
4254 -d, --directory list directory entries instead of contents,\n\
4255 and do not dereference symbolic links\n\
4256 -D, --dired generate output designed for Emacs' dired mode\n\
4259 -f do not sort, enable -aU, disable -ls --color\n\
4260 -F, --classify append indicator (one of */=>@|) to entries\n\
4261 --file-type likewise, except do not append `*'\n\
4262 --format=WORD across -x, commas -m, horizontal -x, long -l,\n\
4263 single-column -1, verbose -l, vertical -C\n\
4264 --full-time like -l --time-style=full-iso\n\
4267 -g like -l, but do not list owner\n\
4270 --group-directories-first\n\
4271 group directories before files\n\
4274 -G, --no-group in a long listing, don't print group names\n\
4275 -h, --human-readable with -l, print sizes in human readable format\n\
4276 (e.g., 1K 234M 2G)\n\
4277 --si likewise, but use powers of 1000 not 1024\n\
4278 -H, --dereference-command-line\n\
4279 follow symbolic links listed on the command line\n\
4280 --dereference-command-line-symlink-to-dir\n\
4281 follow each command line symbolic link\n\
4282 that points to a directory\n\
4283 --hide=PATTERN do not list implied entries matching shell PATTERN\n\
4284 (overridden by -a or -A)\n\
4287 --indicator-style=WORD append indicator with style WORD to entry names:\n\
4288 none (default), slash (-p),\n\
4289 file-type (--file-type), classify (-F)\n\
4290 -i, --inode print the index number of each file\n\
4291 -I, --ignore=PATTERN do not list implied entries matching shell PATTERN\n\
4292 -k like --block-size=1K\n\
4295 -l use a long listing format\n\
4296 -L, --dereference when showing file information for a symbolic\n\
4297 link, show information for the file the link\n\
4298 references rather than for the link itself\n\
4299 -m fill width with a comma separated list of entries\n\
4302 -n, --numeric-uid-gid like -l, but list numeric user and group IDs\n\
4303 -N, --literal print raw entry names (don't treat e.g. control\n\
4304 characters specially)\n\
4305 -o like -l, but do not list group information\n\
4306 -p, --indicator-style=slash\n\
4307 append / indicator to directories\n\
4310 -q, --hide-control-chars print ? instead of non graphic characters\n\
4311 --show-control-chars show non graphic characters as-is (default\n\
4312 unless program is `ls' and output is a terminal)\n\
4313 -Q, --quote-name enclose entry names in double quotes\n\
4314 --quoting-style=WORD use quoting style WORD for entry names:\n\
4315 literal, locale, shell, shell-always, c, escape\n\
4318 -r, --reverse reverse order while sorting\n\
4319 -R, --recursive list subdirectories recursively\n\
4320 -s, --size with -l, print size of each file, in blocks\n\
4323 -S sort by file size\n\
4324 --sort=WORD sort by WORD instead of name: none -U,\n\
4325 extension -X, size -S, time -t, version -v\n\
4326 --time=WORD with -l, show time as WORD instead of modification\n\
4327 time: atime -u, access -u, use -u, ctime -c,\n\
4328 or status -c; use specified time as sort key\n\
4332 --time-style=STYLE with -l, show times using style STYLE:\n\
4333 full-iso, long-iso, iso, locale, +FORMAT.\n\
4334 FORMAT is interpreted like `date'; if FORMAT is\n\
4335 FORMAT1<newline>FORMAT2, FORMAT1 applies to\n\
4336 non-recent files and FORMAT2 to recent files;\n\
4337 if STYLE is prefixed with `posix-', STYLE\n\
4338 takes effect only outside the POSIX locale\n\
4339 -t sort by modification time\n\
4340 -T, --tabsize=COLS assume tab stops at each COLS instead of 8\n\
4343 -u with -lt: sort by, and show, access time\n\
4344 with -l: show access time and sort by name\n\
4345 otherwise: sort by access time\n\
4346 -U do not sort; list entries in directory order\n\
4347 -v sort by version\n\
4350 -w, --width=COLS assume screen width instead of current value\n\
4351 -x list entries by lines instead of by columns\n\
4352 -X sort alphabetically by entry extension\n\
4353 -1 list one file per line\n\
4355 fputs (HELP_OPTION_DESCRIPTION, stdout);
4356 fputs (VERSION_OPTION_DESCRIPTION, stdout);
4358 SIZE may be (or may be an integer optionally followed by) one of following:\n\
4359 kB 1000, K 1024, MB 1000*1000, M 1024*1024, and so on for G, T, P, E, Z, Y.\n\
4363 By default, color is not used to distinguish types of files. That is\n\
4364 equivalent to using --color=none. Using the --color option without the\n\
4365 optional WHEN argument is equivalent to using --color=always. With\n\
4366 --color=auto, color codes are output only if standard output is connected\n\
4367 to a terminal (tty). The environment variable LS_COLORS can influence the\n\
4368 colors, and can be set easily by the dircolors command.\n\
4372 Exit status is 0 if OK, 1 if minor problems, 2 if serious trouble.\n\
4374 printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);