GNU text utilities

This manual documents version 2.0 of the GNU text utilities.

1. Introduction		Caveats, overview, and authors.
2. Common options
3. Output of entire files		cat tac nl od
4. Formatting file contents		fmt pr fold
5. Output of parts of files		head tail split csplit
6. Summarizing files		wc sum cksum md5sum
7. Operating on sorted files		sort uniq comm ptx tsort
8. Operating on fields within a line		cut paste join
9. Operating on characters		tr expand unexpand
10. Opening the software toolbox		The software tools philosophy.
Index		General index.

 -- The Detailed Node Listing ---

Output of entire files

3.1 cat: Concatenate and write files		Concatenate and write files.
3.2 tac: Concatenate and write files in reverse		Concatenate and write files in reverse.
3.3 nl: Number lines and write files		Number lines and write files.
3.4 od: Write files in octal or other formats		Write files in octal or other formats.

Formatting file contents

4.1 fmt: Reformat paragraph text		Reformat paragraph text.
4.2 pr: Paginate or columnate files for printing		Paginate or columnate files for printing.
4.3 fold: Wrap input lines to fit in specified width		Wrap input lines to fit in specified width.

Output of parts of files

5.1 head: Output the first part of files		Output the first part of files.
5.2 tail: Output the last part of files		Output the last part of files.
5.3 split: Split a file into fixed-size pieces		Split a file into fixed-size pieces.
5.4 csplit: Split a file into context-determined pieces		Split a file into context-determined pieces.

Summarizing files

6.1 wc: Print byte, word, and line counts		Print byte, word, and line counts.
6.2 sum: Print checksum and block counts		Print checksum and block counts.
6.3 cksum: Print CRC checksum and byte counts		Print CRC checksum and byte counts.
6.4 md5sum: Print or check message-digests		Print or check message-digests.

Operating on sorted files

7.1 sort: Sort text files		Sort text files.
7.2 uniq: Uniquify files		Uniquify files.
7.3 comm: Compare two sorted files line by line		Compare two sorted files line by line.
7.5 ptx: Produce permuted indexes		Produce a permuted index of file contents.
7.4 tsort: Topological sort		Topological sort.

ptx: Produce permuted indexes

7.5.1 General options		Options which affect general program behavior.
7.5.2 Charset selection		Underlying character set considerations.
7.5.3 Word selection and input processing		Input fields, contexts, and keyword selection.
7.5.4 Output formatting		Types of output format, and sizing the fields.
7.5.5 The GNU extensions to ptx

Operating on fields within a line

8.1 cut: Print selected parts of lines		Print selected parts of lines.
8.2 paste: Merge lines of files		Merge lines of files.
8.3 join: Join lines on a common field		Join lines on a common field.

Operating on characters

9.1 tr: Translate, squeeze, and/or delete characters		Translate, squeeze, and/or delete characters.
9.2 expand: Convert tabs to spaces		Convert tabs to spaces.
9.3 unexpand: Convert spaces to tabs		Convert spaces to tabs.

tr: Translate, squeeze, and/or delete characters

9.1.1 Specifying sets of characters
9.1.2 Translating		Changing one characters to another.
9.1.3 Squeezing repeats and deleting
9.1.4 Warning messages

Opening the software toolbox

Toolbox introduction
I/O redirection
The who command
The cut command
The sort command
The uniq command
Putting the tools together

1. Introduction

This manual is incomplete: No attempt is made to explain basic concepts in a way suitable for novices. Thus, if you are interested, please get involved in improving this manual. The entire GNU community will benefit.

The GNU text utilities are mostly compatible with the POSIX.2 standard.

Please report bugs to bug-textutils@gnu.org. Remember to include the version number, machine architecture, input files, and any other information needed to reproduce the bug: your input, what you expected, what you got, and why it is wrong. Diffs are welcome, but please include a description of the problem as well, since this is sometimes difficult to infer. See section `Bugs' in GNU CC.

This manual was originally derived from the Unix man pages in the distribution, which were written by David MacKenzie and updated by Jim Meyering. What you are reading now is the authoritative documentation for these utilities; the man pages are no longer being maintained. The original fmt man page was written by Ross Paterson. François Pinard did the initial conversion to Texinfo format. Karl Berry did the indexing, some reorganization, and editing of the results. Richard Stallman contributed his usual invaluable insights to the overall process.

2. Common options

Certain options are available in all these programs. Rather than writing identical descriptions for each of the programs, they are described here. (In fact, every GNU program accepts (or should accept) these options.)

A few of these programs take arbitrary strings as arguments. In those cases, `--help' and `--version' are taken as these options only if there is one and exactly one command line argument.

`--help'

Print a usage message listing all available options, then exit successfully.

`--version'

Print the version number, then exit successfully.

3. Output of entire files

These commands read and write entire files, possibly transforming them in some way.

3.1 cat: Concatenate and write files		Concatenate and write files.
3.2 tac: Concatenate and write files in reverse		Concatenate and write files in reverse.
3.3 nl: Number lines and write files		Number lines and write files.
3.4 od: Write files in octal or other formats		Write files in octal or other formats.

3.1 cat: Concatenate and write files

cat copies each file (`-' means standard input), or standard input if none are given, to standard output. Synopsis:

cat [option] [file]...

The program accepts the following options. Also see 2. Common options.

`-A'

`--show-all'

Equivalent to `-vET'.

`-B'

`--binary'

On MS-DOS and MS-Windows only, read and write the files in binary mode. By default, cat on MS-DOS/MS-Windows uses binary mode only when standard output is redirected to a file or a pipe; this option overrides that. Binary file I/O is used so that the files retain their format (Unix text as opposed to DOS text and binary), because cat is frequently used as a file-copying program. Some options (see below) cause cat read and write files in text mode because then the original file contents aren't important (e.g., when lines are numbered by cat, or when line endings should be marked). This is so these options work as DOS/Windows users would expect; for example, DOS-style text files have their lines end with the CR-LF pair of characters which won't be processed as an empty line by `-b' unless the file is read in text mode.

`-b'

`--number-nonblank'

Number all nonblank output lines, starting with 1. On MS-DOS and MS-Windows, this option causes cat to read and write files in text mode.

`-e'

Equivalent to `-vE'.

`-E'

`--show-ends'

Display a `$' after the end of each line. On MS-DOS and MS-Windows, this option causes cat to read and write files in text mode.

`-n'

`--number'

Number all output lines, starting with 1. On MS-DOS and MS-Windows, this option causes cat to read and write files in text mode.

`-s'

`--squeeze-blank'

Replace multiple adjacent blank lines with a single blank line. On MS-DOS and MS-Windows, this option causes cat to read and write files in text mode.

`-t'

Equivalent to `-vT'.

`-T'

`--show-tabs'

Display TAB characters as `^I'.

`-u'

Ignored; for Unix compatibility.

`-v'

`--show-nonprinting'

Display control characters except for LFD and TAB using `^' notation and precede characters that have the high bit set with `M-'. On MS-DOS and MS-Windows, this option causes cat to read files and standard input in DOS binary mode, so the CR characters at the end of each line are also visible.

3.2 tac: Concatenate and write files in reverse

tac copies each file (`-' means standard input), or standard input if none are given, to standard output, reversing the records (lines by default) in each separately. Synopsis:

tac [option]... [file]...

Records are separated by instances of a string (newline by default). By default, this separator string is attached to the end of the record that it follows in the file.

The program accepts the following options. Also see 2. Common options.

`-b'

`--before'

The separator is attached to the beginning of the record that it precedes in the file.

`-r'

`--regex'

Treat the separator string as a regular expression. Users of tac on MS-DOS/MS-Windows should note that, since tac reads files in binary mode, each line of a text file might end with a CR/LF pair instead of the Unix-style LF.

`-s separator'

`--separator=separator'

Use separator as the record separator, instead of newline.

3.3 nl: Number lines and write files

nl writes each file (`-' means standard input), or standard input if none are given, to standard output, with line numbers added to some or all of the lines. Synopsis:

nl [option]... [file]...

nl decomposes its input into (logical) pages; by default, the line number is reset to 1 at the top of each logical page. nl treats all of the input files as a single document; it does not reset line numbers or logical pages between files.

A logical page consists of three sections: header, body, and footer. Any of the sections can be empty. Each can be numbered in a different style from the others.

The beginnings of the sections of logical pages are indicated in the input file by a line containing exactly one of these delimiter strings:

`\:\:\:'

start of header;

`\:\:'

start of body;

`\:'

start of footer.

The two characters from which these strings are made can be changed from `\' and `:' via options (see below), but the pattern and length of each string cannot be changed.

A section delimiter is replaced by an empty line on output. Any text that comes before the first section delimiter string in the input file is considered to be part of a body section, so nl treats a file that contains no section delimiters as a single body section.

The program accepts the following options. Also see 2. Common options.

`-b style'

`--body-numbering=style'

Select the numbering style for lines in the body section of each logical page. When a line is not numbered, the current line number is not incremented, but the line number separator character is still prepended to the line. The styles are:

`a'

number all lines,

`t'

number only nonempty lines (default for body),

`n'

do not number lines (default for header and footer),

`pregexp'

number only lines that contain a match for regexp.

`-d cd'

`--section-delimiter=cd'

Set the section delimiter characters to cd; default is `\:'. If only c is given, the second remains `:'. (Remember to protect `\' or other metacharacters from shell expansion with quotes or extra backslashes.)

`-f style'

`--footer-numbering=style'

Analogous to `--body-numbering'.

`-h style'

`--header-numbering=style'

Analogous to `--body-numbering'.

`-i number'

`--page-increment=number'

Increment line numbers by number (default 1).

`-l number'

`--join-blank-lines=number'

Consider number (default 1) consecutive empty lines to be one logical line for numbering, and only number the last one. Where fewer than number consecutive empty lines occur, do not number them. An empty line is one that contains no characters, not even spaces or tabs.

`-n format'

`--number-format=format'

Select the line numbering format (default is rn):

`ln'

left justified, no leading zeros;

`rn'

right justified, no leading zeros;

`rz'

right justified, leading zeros.

`-p'

`--no-renumber'

Do not reset the line number at the start of a logical page.

`-s string'

`--number-separator=string'

Separate the line number from the text line in the output with string (default is the TAB character).

`-v number'

`--starting-line-number=number'

Set the initial line number on each logical page to number (default 1).

`-w number'

`--number-width=number'

Use number characters for line numbers (default 6).

3.4 od: Write files in octal or other formats

od writes an unambiguous representation of each file (`-' means standard input), or standard input if none are given. Synopsis:

od [option]... [file]... od -C [file] [[+]offset [[+]label]]

Each line of output consists of the offset in the input, followed by groups of data from the file. By default, od prints the offset in octal, and each group of file data is two bytes of input printed as a single octal number.

The program accepts the following options. Also see 2. Common options.

`-A radix'

`--address-radix=radix'

Select the base in which file offsets are printed. radix can be one of the following:

`d'

decimal;

`o'

octal;

`x'

hexadecimal;

`n'

none (do not print offsets).

The default is octal.

`-j bytes'

`--skip-bytes=bytes'

Skip bytes input bytes before formatting and writing. If bytes begins with `0x' or `0X', it is interpreted in hexadecimal; otherwise, if it begins with `0', in octal; otherwise, in decimal. Appending `b' multiplies bytes by 512, `k' by 1024, and `m' by 1048576.

`-N bytes'

`--read-bytes=bytes'

Output at most bytes bytes of the input. Prefixes and suffixes on bytes are interpreted as for the `-j' option.

`-s [n]'

`--strings[=n]'

Instead of the normal output, output only string constants: at least n (3 by default) consecutive ASCII graphic characters, followed by a null (zero) byte.

`-t type'

`--format=type'

Select the format in which to output the file data. type is a string of one or more of the below type indicator characters. If you include more than one type indicator character in a single type string, or use this option more than once, od writes one copy of each output line using each of the data types that you specified, in the order that you specified.

Adding a trailing "z" to any type specification appends a display of the ASCII character representation of the printable characters to the output line generated by the type specification.

`a'

named character,

`c'

ASCII character or backslash escape,

`d'

signed decimal,

`f'

floating point,

`o'

octal,

`u'

unsigned decimal,

`x'

hexadecimal.

The type a outputs things like `sp' for space, `nl' for newline, and `nul' for a null (zero) byte. Type c outputs ` ', `\n', and \0, respectively.

Except for types `a' and `c', you can specify the number of bytes to use in interpreting each number in the given data type by following the type indicator character with a decimal integer. Alternately, you can specify the size of one of the C compiler's built-in data types by following the type indicator character with one of the following characters. For integers (`d', `o', `u', `x'):

`C'

char,

`S'

short,

`I'

int,

`L'

long.

For floating point (f):

F

float,

D

double,

L

long double.

`-v'

`--output-duplicates'

Output consecutive lines that are identical. By default, when two or more consecutive output lines would be identical, od outputs only the first line, and puts just an asterisk on the following line to indicate the elision.

`-w[n]'

`--width[=n]'

Dump n input bytes per output line. This must be a multiple of the least common multiple of the sizes associated with the specified output types. If n is omitted, the default is 32. If this option is not given at all, the default is 16.

The next several options map the old, pre-POSIX format specification options to the corresponding POSIX format specs. GNU od accepts any combination of old- and new-style options. Format specification options accumulate.

`-a'

Output as named characters. Equivalent to `-ta'.

`-b'

Output as octal bytes. Equivalent to `-toC'.

`-c'

Output as ASCII characters or backslash escapes. Equivalent to `-tc'.

`-d'

Output as unsigned decimal shorts. Equivalent to `-tu2'.

`-f'

Output as floats. Equivalent to `-tfF'.

`-h'

Output as hexadecimal shorts. Equivalent to `-tx2'.

`-i'

Output as decimal shorts. Equivalent to `-td2'.

`-l'

Output as decimal longs. Equivalent to `-td4'.

`-o'

Output as octal shorts. Equivalent to `-to2'.

`-x'

Output as hexadecimal shorts. Equivalent to `-tx2'.

`-C'

`--traditional'

Recognize the pre-POSIX non-option arguments that traditional od accepted. The following syntax:

od --traditional [file] [[+]offset[.][b] [[+]label[.][b]]]

can be used to specify at most one file and optional arguments specifying an offset and a pseudo-start address, label. By default, offset is interpreted as an octal number specifying how many input bytes to skip before formatting and writing. The optional trailing decimal point forces the interpretation of offset as a decimal number. If no decimal is specified and the offset begins with `0x' or `0X' it is interpreted as a hexadecimal number. If there is a trailing `b', the number of bytes skipped will be offset multiplied by 512. The label argument is interpreted just like offset, but it specifies an initial pseudo-address. The pseudo-addresses are displayed in parentheses following any normal address.

4. Formatting file contents

These commands reformat the contents of files.

4.1 fmt: Reformat paragraph text		Reformat paragraph text.
4.2 pr: Paginate or columnate files for printing		Paginate or columnate files for printing.
4.3 fold: Wrap input lines to fit in specified width		Wrap input lines to fit in specified width.

4.1 fmt: Reformat paragraph text

fmt fills and joins lines to produce output lines of (at most) a given number of characters (75 by default). Synopsis:

fmt [option]... [file]...

fmt reads from the specified file arguments (or standard input if none are given), and writes to standard output.

By default, blank lines, spaces between words, and indentation are preserved in the output; successive input lines with different indentation are not joined; tabs are expanded on input and introduced on output.

fmt prefers breaking lines at the end of a sentence, and tries to avoid line breaks after the first word of a sentence or before the last word of a sentence. A sentence break is defined as either the end of a paragraph or a word ending in any of `.?!', followed by two spaces or end of line, ignoring any intervening parentheses or quotes. Like TeX, fmt reads entire "paragraphs" before choosing line breaks; the algorithm is a variant of that in "Breaking Paragraphs Into Lines" (Donald E. Knuth and Michael F. Plass, Software--Practice and Experience, 11 (1981), 1119--1184).

The program accepts the following options. Also see 2. Common options.

`-c'

`--crown-margin'

Crown margin mode: preserve the indentation of the first two lines within a paragraph, and align the left margin of each subsequent line with that of the second line.

`-t'

`--tagged-paragraph'

Tagged paragraph mode: like crown margin mode, except that if indentation of the first line of a paragraph is the same as the indentation of the second, the first line is treated as a one-line paragraph.

`-s'

`--split-only'

Split lines only. Do not join short lines to form longer ones. This prevents sample lines of code, and other such "formatted" text from being unduly combined.

`-u'

`--uniform-spacing'

Uniform spacing. Reduce spacing between words to one space, and spacing between sentences to two spaces.

`-width'

`-w width'

`--width=width'

Fill output lines up to width characters (default 75). fmt initially tries to make lines about 7% shorter than this, to give it room to balance line lengths.

`-p prefix'

`--prefix=prefix'

Only lines beginning with prefix (possibly preceded by whitespace) are subject to formatting. The prefix and any preceding whitespace are stripped for the formatting and then re-attached to each formatted output line. One use is to format certain kinds of program comments, while leaving the code unchanged.

4.2 pr: Paginate or columnate files for printing

pr writes each file (`-' means standard input), or standard input if none are given, to standard output, paginating and optionally outputting in multicolumn format; optionally merges all files, printing all in parallel, one per column. Synopsis:

pr [option]... [file]...

By default, a 5-line header is printed at each page: two blank lines; a line with the date, the filename, and the page count; and two more blank lines. A footer of five blank lines is also printed. With the `-F' option, a 3-line header is printed: the leading two blank lines are omitted; no footer is used. The default page_length in both cases is 66 lines. The default number of text lines changes from 56 (without `-F') to 63 (with `-F'). The text line of the header takes up the full page_width in the form `yyyy-mm-dd HH:MM string Page nnnn'. String is a centered header string.

Form feeds in the input cause page breaks in the output. Multiple form feeds produce empty pages.

Columns are of equal width, separated by an optional string (default is `space'). For multicolumn output, lines will always be truncated to page_width (default 72), unless you use the `-J' option. For single column output no line truncation occurs by default. Use `-W' option to truncate lines in that case.

Including version 1.22i:

Some small letter options (`-s', `-w') has been redefined with the object of a better posix compliance. The output of some further cases has been adapted to other unixes. A violation of downward compatibility has to be accepted.

Some new capital letter options (`-J', `-S', `-W') has been introduced to turn off unexpected interferences of small letter options. The `-N' option and the second argument last_page of `+FIRST_PAGE' offer more flexibility. The detailed handling of form feeds set in the input files requires `-T' option.

Capital letter options dominate small letter ones.

Some of the option-arguments (compare `-s', `-S', `-e', `-i', `-n') cannot be specified as separate arguments from the preceding option letter (already stated in the posix specification).

The program accepts the following options. Also see 2. Common options.

`+first_page[:last_page]'

`--pages=first_page[:last_page]'

Begin printing with page first_page and stop with last_page. Missing `:last_page' implies end of file. While estimating the number of skipped pages each form feed in the input file results in a new page. Page counting with and without `+first_page' is identical. By default, counting starts with the first page of input file (not first page printed). Line numbering may be altered by `-N' option.

`-column'

`--columns=column'

With each single file, produce column columns of output (default is 1) and print columns down, unless `-a' is used. The column width is automatically decreased as column increases; unless you use the `-W/-w' option to increase page_width as well. This option might well cause some lines to be truncated. The number of lines in the columns on each page are balanced. The options `-e' and `-i' are on for multiple text-column output. Together with `-J' option column alignment and line truncation is turned off. Lines of full length are joined in a free field format and `-S' option may set field separators. `-column' may not be used with `-m' option.

`-a'

`--across'

With each single file, print columns across rather than down. The `-column' option must be given with column greater than one. If a line is too long to fit in a column, it is truncated.

`-c'

`--show-control-chars'

Print control characters using hat notation (e.g., `^G'); print other unprintable characters in octal backslash notation. By default, unprintable characters are not changed.

`-d'

`--double-space'

Double space the output.

`-e[in-tabchar[in-tabwidth]]'

`--expand-tabs[=in-tabchar[in-tabwidth]]'

Expand tabs to spaces on input. Optional argument in-tabchar is the input tab character (default is the TAB character). Second optional argument in-tabwidth is the input tab character's width (default is 8).

`-f'

`-F'

`--form-feed'

Use a form feed instead of newlines to separate output pages. The default page length of 66 lines is not altered. But the number of lines of text per page changes from default 56 to 63 lines.

`-h HEADER'

`--header=HEADER'

Replace the filename in the header with the centered string header. Left-hand-side truncation (marked by a `*') may occur if the total header line `yyyy-mm-dd HH:MM HEADER Page nnnn' becomes larger than page_width. `-h ""' prints a blank line header. Don't use `-h""'. A space between the `-h' option and the argument is always indispensable.

`-i[out-tabchar[out-tabwidth]]'

`--output-tabs[=out-tabchar[out-tabwidth]]'

Replace spaces with tabs on output. Optional argument out-tabchar is the output tab character (default is the TAB character). Second optional argument out-tabwidth is the output tab character's width (default is 8).

`-J'

`--join-lines'

Merge lines of full length. Used together with the column options `-column', `-a -column' or `-m'. Turns off `-W/-w' line truncation; no column alignment used; may be used with `-S[string]'. `-J' has been introduced (together with `-W' and `-S') to disentangle the old (posix compliant) options `-w' and `-s' along with the three column options.

`-l page_length'

`--length=page_length'

Set the page length to page_length (default 66) lines, including the lines of the header [and the footer]. If page_length is less than or equal 10 (and <= 3 with `-F'), the header and footer are omitted, and all form feeds set in input files are eliminated, as if the `-T' option had been given.

`-m'

`--merge'

Merge and print all files in parallel, one in each column. If a line is too long to fit in a column, it is truncated, unless `-J' option is used. `-S[string]' may be used. Empty pages in some files (form feeds set) produce empty columns, still marked by string. The result is a continuous line numbering and column marking throughout the whole merged file. Completely empty merged pages show no separators or line numbers. The default header becomes `yyyy-mm-dd HH:MM <blanks> Page nnnn'; may be used with `-h header' to fill up the middle blank part.

`-n[number-separator[digits]]'

`--number-lines[=number-separator[digits]]'

Provide digits digit line numbering (default for digits is 5). With multicolumn output the number occupies the first digits column positions of each text column or only each line of `-m' output. With single column output the number precedes each line just as `-m' does. Default counting of the line numbers starts with 1st line of the input file (not the 1st line printed, compare the `--page' option and `-N' option). Optional argument number-separator is the character appended to the line number to separate it from the text followed. The default separator is the TAB character. In a strict sense a TAB is always printed with single column output only. The TAB-width varies with the TAB-position, e.g. with the left margin specified by `-o' option. With multicolumn output priority is given to `equal width of output columns' (a posix specification). The TAB-width is fixed to the value of the 1st column and does not change with different values of left margin. That means a fixed number of spaces is always printed in the place of the number-separator tab. The tabification depends upon the output position.

`-N line_number'

`--first-line-number=line_number'

Start line counting with the number line_number at first line of first page printed (in most cases not the first line of the input file).

`-o margin'

`--indent=margin'

Indent each line with a margin margin spaces wide (default is zero). The total page width is the size of the margin plus the page_width set with the `-W/-w' option. A limited overflow may occur with numbered single column output (compare `-n' option).

`-r'

`--no-file-warnings'

Do not print a warning message when an argument file cannot be opened. (The exit status will still be nonzero, however.)

`-s[char]'

`--separator[=char]'

Separate columns by a single character char. Default for char is the TAB character without `-w' and `no character' with `-w'. Without `-s' default separator `space' is set. `-s[char]' turns off line truncation of all three column options (`-COLUMN'|`-a -COLUMN'|`-m') except `-w' is set. That is a posix compliant formulation.

`-S[string]'

`--sep-string[=string]'

Use string to separate output columns. The `-S' option doesn't affect the `-W/-w' option, unlike the `-s' option which does. It does not affect line truncation or column alignment. Without `-S', and with `-J', pr uses the default output separator, TAB. Without `-S' or `-J', pr uses a `space' (same as `-S" "'). Using `-S' with no string is equivalent to `-S""'. Note that for some of pr's options the single-letter option character must be followed immediately by any corresponding argument; there may not be any intervening white space. `-S/-s' is one of them. Don't use `-S "STRING"'. POSIX requires this.

`-t'

`--omit-header'

Do not print the usual header [and footer] on each page, and do not fill out the bottom of pages (with blank lines or a form feed). No page structure is produced, but form feeds set in the input files are retained. The predefined pagination is not changed. `-t' or `-T' may be useful together with other options; e.g.: `-t -e4', expand TAB characters in the input file to 4 spaces but don't make any other changes. Use of `-t' overrides `-h'.

`-T'

`--omit-pagination'

Do not print header [and footer]. In addition eliminate all form feeds set in the input files.

`-v'

`--show-nonprinting'

Print unprintable characters in octal backslash notation.

`-w page_width'

`--width=page_width'

Set page width to page_width characters for multiple text-column output only (default for page_width is 72). `-s[CHAR]' turns off the default page width and any line truncation and column alignment. Lines of full length are merged, regardless of the column options set. No page_width setting is possible with single column output. A posix compliant formulation.

`-W page_width'

`--page_width=page_width'

Set the page width to page_width characters. That's valid with and without a column option. Text lines are truncated, unless `-J' is used. Together with one of the three column options (`-column', `-a -column' or `-m') column alignment is always used. The separator options `-S' or `-s' don't affect the `-W' option. Default is 72 characters. Without `-W page_width' and without any of the column options NO line truncation is used (defined to keep downward compatibility and to meet most frequent tasks). That's equivalent to `-W 72 -J'. With and without `-W page_width' the header line is always truncated to avoid line overflow.

4.3 fold: Wrap input lines to fit in specified width

fold writes each file (`-' means standard input), or standard input if none are given, to standard output, breaking long lines. Synopsis:

fold [option]... [file]...

By default, fold breaks lines wider than 80 columns. The output is split into as many lines as necessary.

fold counts screen columns by default; thus, a tab may count more than one column, backspace decreases the column count, and carriage return sets the column to zero.

The program accepts the following options. Also see 2. Common options.

`-b'

`--bytes'

Count bytes rather than columns, so that tabs, backspaces, and carriage returns are each counted as taking up one column, just like other characters.

`-s'

`--spaces'

Break at word boundaries: the line is broken after the last blank before the maximum line length. If the line contains no such blanks, the line is broken at the maximum line length as usual.

`-w width'

`--width=width'

Use a maximum line length of width columns instead of 80.

5. Output of parts of files

These commands output pieces of the input.

5.1 head: Output the first part of files		Output the first part of files.
5.2 tail: Output the last part of files		Output the last part of files.
5.3 split: Split a file into fixed-size pieces		Split a file into fixed-size pieces.
5.4 csplit: Split a file into context-determined pieces		Split a file into context-determined pieces.

5.1 head: Output the first part of files

head prints the first part (10 lines by default) of each file; it reads from standard input if no files are given or when given a file of `-'. Synopses:

head [option]... [file]... head -number [option]... [file]...

If more than one file is specified, head prints a one-line header consisting of

==> file name <==

before the output for each file.

head accepts two option formats: the new one, in which numbers are arguments to the options (`-q -n 1'), and the old one, in which the number precedes any option letters (`-1q').

The program accepts the following options. Also see 2. Common options.

`-countoptions'

This option is only recognized if it is specified first. count is a decimal number optionally followed by a size letter (`b', `k', `m') as in -c, or `l' to mean count by lines, or other option letters (`cqv').

`-c bytes'

`--bytes=bytes'

Print the first bytes bytes, instead of initial lines. Appending `b' multiplies bytes by 512, `k' by 1024, and `m' by 1048576.

`-n n'

`--lines=n'

Output the first n lines.

`-q'

`--quiet'

`--silent'

Never print file name headers.

`-v'

`--verbose'

Always print file name headers.

5.2 tail: Output the last part of files

tail prints the last part (10 lines by default) of each file; it reads from standard input if no files are given or when given a file of `-'. Synopses:

tail [option]... [file]... tail -number [option]... [file]... tail +number [option]... [file]...

If more than one file is specified, tail prints a one-line header consisting of

==> file name <==

before the output for each file.

GNU tail can output any amount of data (some other versions of tail cannot). It also has no `-r' option (print in reverse), since reversing a file is really a different job from printing the end of a file; BSD tail (which is the one with -r) can only reverse files that are at most as large as its buffer, which is typically 32k. A more reliable and versatile way to reverse files is the GNU tac command.

tail accepts two option formats: the new one, in which numbers are arguments to the options (`-n 1'), and the old one, in which the number precedes any option letters (`-1' or `+1').

If any option-argument is a number n starting with a `+', tail begins printing with the nth item from the start of each file, instead of from the end.

The program accepts the following options. Also see 2. Common options.

`-count'

`+count'

This option is only recognized if it is specified first. count is a decimal number optionally followed by a size letter (`b', `k', `m') as in -c, or `l' to mean count by lines, or other option letters (`cfqv').

`-c bytes'

`--bytes=bytes'

Output the last bytes bytes, instead of final lines. Appending `b' multiplies bytes by 512, `k' by 1024, and `m' by 1048576.

`-f'

`--follow[=how]'

Loop forever trying to read more characters at the end of the file, presumably because the file is growing. This option is ignored when reading from a pipe. If more than one file is given, tail prints a header whenever it gets output from a different file, to indicate which file that output is from.

There are two ways to specify how you'd like to track files with this option, but that difference is noticeable only when a followed file is removed or renamed. If you'd like to continue to track the end of a growing file even after it has been unlinked, use `--follow=descriptor'. This is the default behavior, but it is not useful if you're tracking a log file that may be rotated (removed or renamed, then reopened). In that case, use `--follow=name' to track the named file by reopening it periodically to see if it has been removed and recreated by some other program.

No matter which method you use, if the tracked file is determined to have shrunk, tail prints a message saying the file has been truncated and resumes tracking the end of the file from the newly-determined endpoint.

When a file is removed, tail's behavior depends on whether it is following the name or the descriptor. When following by name, tail can detect that a file has been removed and gives a message to that effect, and if `--retry' has been specified it will continue checking periodically to see if the file reappears. When following a descriptor, tail does not detect that the file has been unlinked or renamed and issues no message; even though the file may no longer be accessible via its original name, it may still be growing.

The option values `descriptor' and `name' may be specified only with the long form of the option, not with `-f'.

`--retry'

This option is meaningful only when following by name. Without this option, when tail encounters a file that doesn't exist or is otherwise inaccessible, it reports that fact and never checks it again.

`--sleep-interval=n'

Change the number of seconds to wait between iterations (the default is 1). During one iteration, every specified file is checked to see if it has changed size.

`--pid=pid'

When following by name or by descriptor, you may specify the process ID, pid, of the sole writer of all file arguments. Then, shortly after that process terminates, tail will also terminate. This will work properly only if the writer and the tailing process are running on the same machine. For example, to save the output of a build in a file and to watch the file grow, if you invoke make and tail like this then the tail process will stop when your build completes. Without this option, you would have had to kill the tail -f process yourself.

$ make >& makerr & tail --pid=$! -f makerr

If you specify a pid that is not in use or that does not correspond to the process that is writing to the tailed files, then tail may terminate long before any files stop growing or it may not terminate until long after the real writer has terminated.

`--max-consecutive-size-changes=n'

This option is meaningful only when following by name. Use it to control how long tail follows the descriptor of a file that continues growing at a rapid pace even after it is deleted or renamed. After detecting n consecutive size changes for a file, open/fstat the file to determine if that file name is still associated with the same device/inode-number pair as before. See the output of tail --help for the default value.

`--max-unchanged-stats=n'

When tailing a file by name, if there have been this many consecutive iterations for which the size has remained the same, then open/fstat the file to determine if that file name is still associated with the same device/inode-number pair as before. When following a log file that is rotated this is approximately the number of seconds between when tail prints the last pre-rotation lines and when it prints the lines that have accumulated in the new log file. See the output of tail --help for the default value. This option is meaningful only when following by name.

`-n n'

`--lines=n'

Output the last n lines.

`-q'

`-quiet'

`--silent'

Never print file name headers.

`-v'

`--verbose'

Always print file name headers.

5.3 split: Split a file into fixed-size pieces

split creates output files containing consecutive sections of input (standard input if none is given or input is `-'). Synopsis:

split [option] [input [prefix]]

By default, split puts 1000 lines of input (or whatever is left over for the last section), into each output file.

The output files' names consist of prefix (`x' by default) followed by a group of letters `aa', `ab', and so on, such that concatenating the output files in sorted order by file name produces the original input file. (If more than 676 output files are required, split uses `zaa', `zab', etc.)

The program accepts the following options. Also see 2. Common options.

`-lines'

`-l lines'

`--lines=lines'

Put lines lines of input into each output file.

`-b bytes'

`--bytes=bytes'

Put the first bytes bytes of input into each output file. Appending `b' multiplies bytes by 512, `k' by 1024, and `m' by 1048576.

`-C bytes'

`--line-bytes=bytes'

Put into each output file as many complete lines of input as possible without exceeding bytes bytes. For lines longer than bytes bytes, put bytes bytes into each output file until less than bytes bytes of the line are left, then continue normally. bytes has the same format as for the `--bytes' option.

`--verbose'

Write a diagnostic to standard error just before each output file is opened.

5.4 csplit: Split a file into context-determined pieces

csplit creates zero or more output files containing sections of input (standard input if input is `-'). Synopsis:

csplit [option]... input pattern...

The contents of the output files are determined by the pattern arguments, as detailed below. An error occurs if a pattern argument refers to a nonexistent line of the input file (e.g., if no remaining line matches a given regular expression). After every pattern has been matched, any remaining input is copied into one last output file.

By default, csplit prints the number of bytes written to each output file after it has been created.

The types of pattern arguments are:

`n'

Create an output file containing the input up to but not including line n (a positive integer). If followed by a repeat count, also create an output file containing the next line lines of the input file once for each repeat.

`/regexp/[offset]'

Create an output file containing the current line up to (but not including) the next line of the input file that contains a match for regexp. The optional offset is a `+' or `-' followed by a positive integer. If it is given, the input up to the matching line plus or minus offset is put into the output file, and the line after that begins the next section of input.

`%regexp%[offset]'

Like the previous type, except that it does not create an output file, so that section of the input file is effectively ignored.

`{repeat-count}'

Repeat the previous pattern repeat-count additional times. repeat-count can either be a positive integer or an asterisk, meaning repeat as many times as necessary until the input is exhausted.

The output files' names consist of a prefix (`xx' by default) followed by a suffix. By default, the suffix is an ascending sequence of two-digit decimal numbers from `00' and up to `99'. In any case, concatenating the output files in sorted order by filename produces the original input file.

By default, if csplit encounters an error or receives a hangup, interrupt, quit, or terminate signal, it removes any output files that it has created so far before it exits.

The program accepts the following options. Also see 2. Common options.

`-f prefix'

`--prefix=prefix'

Use prefix as the output file name prefix.

`-b suffix'

`--suffix=suffix'

Use suffix as the output file name suffix. When this option is specified, the suffix string must include exactly one printf(3)-style conversion specification, possibly including format specification flags, a field width, a precision specifications, or all of these kinds of modifiers. The format letter must convert a binary integer argument to readable form; thus, only `d', `i', `u', `o', `x', and `X' conversions are allowed. The entire suffix is given (with the current output file number) to sprintf(3) to form the file name suffixes for each of the individual output files in turn. If this option is used, the `--digits' option is ignored.

`-n digits'

`--digits=digits'

Use output file names containing numbers that are digits digits long instead of the default 2.

`-k'

`--keep-files'

Do not remove output files when errors are encountered.

`-z'

`--elide-empty-files'

Suppress the generation of zero-length output files. (In cases where the section delimiters of the input file are supposed to mark the first lines of each of the sections, the first output file will generally be a zero-length file unless you use this option.) The output file sequence numbers always run consecutively starting from 0, even when this option is specified.

`-s'

`-q'

`--silent'

`--quiet'

Do not print counts of output file sizes.

6. Summarizing files

These commands generate just a few numbers representing entire contents of files.

6.1 wc: Print byte, word, and line counts		Print byte, word, and line counts.
6.2 sum: Print checksum and block counts		Print checksum and block counts.
6.3 cksum: Print CRC checksum and byte counts		Print CRC checksum and byte counts.
6.4 md5sum: Print or check message-digests		Print or check message-digests.

6.1 wc: Print byte, word, and line counts

wc counts the number of bytes, whitespace-separated words, and newlines in each given file, or standard input if none are given or for a file of `-'. Synopsis:

wc [option]... [file]...

wc prints one line of counts for each file, and if the file was given as an argument, it prints the file name following the counts. If more than one file is given, wc prints a final line containing the cumulative counts, with the file name `total'. The counts are printed in this order: newlines, words, bytes. By default, each count is output right-justified in a 7-byte field with one space between fields so that the numbers and file names line up nicely in columns. However, POSIX requires that there be exactly one space separating columns. You can make wc use the POSIX-mandated output format by setting the POSIXLY_CORRECT environment variable.

By default, wc prints all three counts. Options can specify that only certain counts be printed. Options do not undo others previously given, so

wc --bytes --words

prints both the byte counts and the word counts.

With the --max-line-length option, wc prints the length of the longest line per file, and if there is more than one file it prints the maximum (not the sum) of those lengths.

The program accepts the following options. Also see 2. Common options.

`-c'

`--bytes'

`--chars'

Print only the byte counts.

`-w'

`--words'

Print only the word counts.

`-l'

`--lines'

Print only the newline counts.

`-L'

`--max-line-length'

Print only the maximum line lengths.

6.2 sum: Print checksum and block counts

sum computes a 16-bit checksum for each given file, or standard input if none are given or for a file of `-'. Synopsis:

sum [option]... [file]...

sum prints the checksum for each file followed by the number of blocks in the file (rounded up). If more than one file is given, file names are also printed (by default). (With the `--sysv' option, corresponding file name are printed when there is at least one file argument.)

By default, GNU sum computes checksums using an algorithm compatible with BSD sum and prints file sizes in units of 1024-byte blocks.

The program accepts the following options. Also see 2. Common options.

`-r'

Use the default (BSD compatible) algorithm. This option is included for compatibility with the System V sum. Unless `-s' was also given, it has no effect.

`-s'

`--sysv'

Compute checksums using an algorithm compatible with System V sum's default, and print file sizes in units of 512-byte blocks.

sum is provided for compatibility; the cksum program (see next section) is preferable in new applications.

6.3 cksum: Print CRC checksum and byte counts

cksum computes a cyclic redundancy check (CRC) checksum for each given file, or standard input if none are given or for a file of `-'. Synopsis:

cksum [option]... [file]...

cksum prints the CRC checksum for each file along with the number of bytes in the file, and the filename unless no arguments were given.

cksum is typically used to ensure that files transferred by unreliable means (e.g., netnews) have not been corrupted, by comparing the cksum output for the received files with the cksum output for the original files (typically given in the distribution).

The CRC algorithm is specified by the POSIX.2 standard. It is not compatible with the BSD or System V sum algorithms (see the previous section); it is more robust.

The only options are `--help' and `--version'. See section 2. Common options.

6.4 md5sum: Print or check message-digests

md5sum computes a 128-bit checksum (or fingerprint or message-digest) for each specified file. If a file is specified as `-' or if no files are given md5sum computes the checksum for the standard input. md5sum can also determine whether a file and checksum are consistent. Synopses:

md5sum [option]... [file]... md5sum [option]... --check [file]

For each file, `md5sum' outputs the MD5 checksum, a flag indicating a binary or text input file, and the filename. If file is omitted or specified as `-', standard input is read.

The program accepts the following options. Also see 2. Common options.

`-b'

`--binary'

Treat all input files as binary. This option has no effect on Unix systems, since they don't distinguish between binary and text files. This option is useful on systems that have different internal and external character representations. On MS-DOS and MS-Windows, this is the default.

`-c'

`--check'

Read filenames and checksum information from the single file (or from stdin if no file was specified) and report whether each named file and the corresponding checksum data are consistent. The input to this mode of md5sum is usually the output of a prior, checksum-generating run of `md5sum'. Each valid line of input consists of an MD5 checksum, a binary/text flag, and then a filename. Binary files are marked with `*', text with ` '. For each such line, md5sum reads the named file and computes its MD5 checksum. Then, if the computed message digest does not match the one on the line with the filename, the file is noted as having failed the test. Otherwise, the file passes the test. By default, for each valid line, one line is written to standard output indicating whether the named file passed the test. After all checks have been performed, if there were any failures, a warning is issued to standard error. Use the `--status' option to inhibit that output. If any listed file cannot be opened or read, if any valid line has an MD5 checksum inconsistent with the associated file, or if no valid line is found, md5sum exits with nonzero status. Otherwise, it exits successfully.

`--status'

This option is useful only when verifying checksums. When verifying checksums, don't generate the default one-line-per-file diagnostic and don't output the warning summarizing any failures. Failures to open or read a file still evoke individual diagnostics to standard error. If all listed files are readable and are consistent with the associated MD5 checksums, exit successfully. Otherwise exit with a status code indicating there was a failure.

`-t'

`--text'

Treat all input files as text files. This is the reverse of `--binary'.

`-w'

`--warn'

When verifying checksums, warn about improperly formatted MD5 checksum lines. This option is useful only if all but a few lines in the checked input are valid.

7. Operating on sorted files

These commands work with (or produce) sorted files.

7.1 sort: Sort text files		Sort text files.
7.2 uniq: Uniquify files		Uniquify files.
7.3 comm: Compare two sorted files line by line		Compare two sorted files line by line.
7.5 ptx: Produce permuted indexes		Produce a permuted index of file contents.
7.4 tsort: Topological sort		Topological sort.

7.1 sort: Sort text files

sort sorts, merges, or compares all the lines from the given files, or standard input if none are given or for a file of `-'. By default, sort writes the results to standard output. Synopsis:

sort [option]... [file]...

sort has three modes of operation: sort (the default), merge, and check for sortedness. The following options change the operation mode:

`-c'

Check whether the given files are already sorted: if they are not all sorted, print an error message and exit with a status of 1. Otherwise, exit successfully.

`-m'

Merge the given files by sorting them as a group. Each input file must always be individually sorted. It always works to sort instead of merge; merging is provided because it is faster, in the case where it works.

A pair of lines is compared as follows: if any key fields have been specified, sort compares each pair of fields, in the order specified on the command line, according to the associated ordering options, until a difference is found or no fields are left. Unless otherwise specified, all comparisons use the character collating sequence specified by the LC_COLLATE locale.

If any of the global options `Mbdfinr' are given but no key fields are specified, sort compares the entire lines according to the global options.

Finally, as a last resort when all keys compare equal (or if no ordering options were specified at all), sort compares the entire lines. The last resort comparison honors the `-r' global option. The `-s' (stable) option disables this last-resort comparison so that lines in which all fields compare equal are left in their original relative order. If no fields or global options are specified, `-s' has no effect.

GNU sort (as specified for all GNU utilities) has no limits on input line length or restrictions on bytes allowed within lines. In addition, if the final byte of an input file is not a newline, GNU sort silently supplies one. A line's trailing newline is part of the line for comparison purposes; for example, with no options in an ASCII locale, a line starting with a tab sorts before an empty line because tab precedes newline in the ASCII collating sequence.

Upon any error, sort exits with a status of `2'.

If the environment variable TMPDIR is set, sort uses its value as the directory for temporary files instead of `/tmp'. The `-T tempdir' option in turn overrides the environment variable.

The following options affect the ordering of output lines. They may be specified globally or as part of a specific key field. If no key fields are specified, global options apply to comparison of entire lines; otherwise the global options are inherited by key fields that do not specify any special options of their own. The `-b', `-d', `-f' and `-i' options classify characters according to the LC_CTYPE locale.

`-b'

Ignore leading blanks when finding sort keys in each line.

`-d'

Sort in phone directory order: ignore all characters except letters, digits and blanks when sorting.

`-f'

Fold lowercase characters into the equivalent uppercase characters when sorting so that, for example, `b' and `B' sort as equal.

`-g'

Sort numerically, using the standard C function strtod to convert a prefix of each line to a double-precision floating point number. This allows floating point numbers to be specified in scientific notation, like 1.0e-34 and 10e100. Do not report overflow, underflow, or conversion errors. Use the following collating sequence:

• Lines that do not start with numbers (all considered to be equal).
• NaNs ("Not a Number" values, in IEEE floating point arithmetic) in a consistent but machine-dependent order.
• Minus infinity.
• Finite numbers in ascending numeric order (with -0 and +0 equal).
• Plus infinity.

Use this option only if there is no alternative; it is much slower than `-n' and it can lose information when converting to floating point.

`-i'

Ignore unprintable characters.

`-M'

An initial string, consisting of any amount of whitespace, followed by a month name abbreviation, is folded to UPPER case and compared in the order `JAN' < `FEB' < ... < `DEC'. Invalid names compare low to valid names. The LC_TIME locale determines the month spellings.

`-n'

Sort numerically: the number begins each line; specifically, it consists of optional whitespace, an optional `-' sign, and zero or more digits possibly separated by thousands separators, optionally followed by a radix character and zero or more digits. The LC_NUMERIC locale specifies the radix character and thousands separator.

sort -n uses what might be considered an unconventional method to compare strings representing floating point numbers. Rather than first converting each string to the C double type and then comparing those values, sort aligns the radix characters in the two strings and compares the strings a character at a time. One benefit of using this approach is its speed. In practice this is much more efficient than performing the two corresponding string-to-double (or even string-to-integer) conversions and then comparing doubles. In addition, there is no corresponding loss of precision. Converting each string to double before comparison would limit precision to about 16 digits on most systems.

Neither a leading `+' nor exponential notation is recognized. To compare such strings numerically, use the `-g' option.

`-r'

Reverse the result of comparison, so that lines with greater key values appear earlier in the output instead of later.

Other options are:

`-o output-file'

Write output to output-file instead of standard output. If output-file is one of the input files, sort copies it to a temporary file before sorting and writing the output to output-file.

`-t separator'

Use character separator as the field separator when finding the sort keys in each line. By default, fields are separated by the empty string between a non-whitespace character and a whitespace character. That is, given the input line ` foo bar', sort breaks it into fields ` foo' and ` bar'. The field separator is not considered to be part of either the field preceding or the field following.

`-u'

For the default case or the `-m' option, only output the first of a sequence of lines that compare equal. For the `-c' option, check that no pair of consecutive lines compares equal.

`-k pos1[,pos2]'

The recommended, POSIX, option for specifying a sort field. The field consists of the part of the line between pos1 and pos2 (or the end of the line, if pos2 is omitted), inclusive. Fields and character positions are numbered starting with 1. So to sort on the second field, you'd use `-k 2,2' See below for more examples.

`-z'

Treat the input as a set of lines, each terminated by a zero byte (ASCII NUL (Null) character) instead of an ASCII LF (Line Feed). This option can be useful in conjunction with `perl -0' or `find -print0' and `xargs -0' which do the same in order to reliably handle arbitrary pathnames (even those which contain Line Feed characters.)

`+pos1[-pos2]'

The obsolete, traditional option for specifying a sort field. The field consists of the line between pos1 and up to but not including pos2 (or the end of the line if pos2 is omitted). Fields and character positions are numbered starting with 0. See below.

In addition, when GNU sort is invoked with exactly one argument, options `--help' and `--version' are recognized. See section 2. Common options.

Historical (BSD and System V) implementations of sort have differed in their interpretation of some options, particularly `-b', `-f', and `-n'. GNU sort follows the POSIX behavior, which is usually (but not always!) like the System V behavior. According to POSIX, `-n' no longer implies `-b'. For consistency, `-M' has been changed in the same way. This may affect the meaning of character positions in field specifications in obscure cases. The only fix is to add an explicit `-b'.

A position in a sort field specified with the `-k' or `+' option has the form `f.c', where f is the number of the field to use and c is the number of the first character from the beginning of the field (for `+pos') or from the end of the previous field (for `-pos'). If the `.c' is omitted, it is taken to be the first character in the field. If the `-b' option was specified, the `.c' part of a field specification is counted from the first nonblank character of the field (for `+pos') or from the first nonblank character following the previous field (for `-pos').

A sort key option may also have any of the option letters `Mbdfinr' appended to it, in which case the global ordering options are not used for that particular field. The `-b' option may be independently attached to either or both of the `+pos' and `-pos' parts of a field specification, and if it is inherited from the global options it will be attached to both. Keys may span multiple fields.

Here are some examples to illustrate various combinations of options. In them, the POSIX `-k' option is used to specify sort keys rather than the obsolete `+pos1-pos2' syntax.

• Sort in descending (reverse) numeric order.

  sort -nr

  Sort alphabetically, omitting the first and second fields. This uses a single key composed of the characters beginning at the start of field three and extending to the end of each line.

  sort -k3

• Sort numerically on the second field and resolve ties by sorting alphabetically on the third and fourth characters of field five. Use `:' as the field delimiter.

  sort -t : -k 2,2n -k 5.3,5.4

  Note that if you had written `-k 2' instead of `-k 2,2' `sort' would have used all characters beginning in the second field and extending to the end of the line as the primary numeric key. For the large majority of applications, treating keys spanning more than one field as numeric will not do what you expect.

  Also note that the `n' modifier was applied to the field-end specifier for the first key. It would have been equivalent to specify `-k 2n,2' or `-k 2n,2n'. All modifiers except `b' apply to the associated field, regardless of whether the modifier character is attached to the field-start and/or the field-end part of the key specifier.

• Sort the password file on the fifth field and ignore any leading white space. Sort lines with equal values in field five on the numeric user ID in field three.

  sort -t : -k 5b,5 -k 3,3n /etc/passwd

  An alternative is to use the global numeric modifier `-n'.

  sort -t : -n -k 5b,5 -k 3,3 /etc/passwd

• Generate a tags file in case insensitive sorted order.

  find src -type f -print0 | sort -t / -z -f | xargs -0 etags --append

  The use of `-print0', `-z', and `-0' in this case mean that pathnames that contain Line Feed characters will not get broken up by the sort operation.

  Finally, to ignore both leading and trailing white space, you could have applied the `b' modifier to the field-end specifier for the first key,

  sort -t : -n -k 5b,5b -k 3,3 /etc/passwd

  or by using the global `-b' modifier instead of `-n' and an explicit `n' with the second key specifier.

  sort -t : -b -k 5,5 -k 3,3n /etc/passwd