## 4.2. Syntax

This section describes the many symbols peculiar to the Bourne and Korn shells. The topics are arranged as follows:

- Special files

- Filename metacharacters

- Quoting

- Command forms

- Redirection forms

- Coprocesses (Korn shell only)

### 4.2.1. Special Files

`/etc/profile`
  Executed automatically at login, first.
`$HOME/.profile`
  Executed automatically at login, second.
$ENV
  Specifies the name of a file to read when a new Korn shell is created. (`ksh88`: all shells. `ksh93`: interactive shells only.) The value is variable (`ksh93`: and command and arithmetic) substituted in order to determine the actual file name. Login shells read $ENV after processing `/etc/profile` and `$HOME/.profile`.
`/etc/passwd`
  Source of home directories for `~`name abbreviations. (On networked systems, this information may come from NIS or NIS+, not your workstation password file.)

### 4.2.2. Filename Metacharacters

`*` | Match any string of zero or more characters.
`?` | Match any single character.
`[``abc`...`]` | Match any one of the enclosed characters; a hyphen can specify a range (e.g., a–z, A–Z, 0–9).
`[!``abc`...`]` | Match any character not enclosed as above.

In the Korn shell:

`?(``pattern``)` | Match zero or one instance of pattern.
`*(``pattern``)` | Match zero or more instances of pattern.
`+(``pattern``)` | Match one or more instances of pattern.
`@(``pattern``)` | Match exactly one instance of pattern.
`!(``pattern``)` | Match any strings that don't match pattern.
`\``n` | Match the text matched by the n'th subpattern in `(...)`. `ksh93` only.
`~` | Home directory of the current user.
`~``name` | Home directory of user name.
`~+` | Current working directory ($PWD).
`~-` | Previous working directory ($OLDPWD).

This pattern can be a sequence of patterns separated by `|`, meaning that the match applies to any of the patterns. If `&` is used instead of `|`, all the patterns must match. `&` has higher precedence than `|`. This extended syntax resembles that available in `egrep` and `awk`.

`ksh93` supports the POSIX `[[=``c``=]]` notation for matching characters that have the same weight, and `[[.``c``.]]` for specifying collating sequences. In addition, character classes, of the form `[[:``class``:]]`, allow you to match the following classes of characters.

Class | Characters Matched
--- | ---
`alnum` | Alphanumeric characters
`alpha` | Alphabetic characters
`blank` | Space or tab
`cntrl` | Control characters
`digit` | Decimal digits
`graph` | Nonspace characters
`lower` | Lowercase characters
`print` | Printable characters
`space` | Whitespace characters
`upper` | Uppercase characters
`xdigit` | Hexadecimal digits

### 4.2.2.1. Examples

>     $ ls new*                 List new and new.1
>     $ cat ch?                 Match ch9 but not ch10
>     $ vi [D-R]*               Match files that begin with uppercase D through R
>     $ pr !(*.o|core) | lp     Korn shell only; print files that are not object files or core dumps

### 4.2.3. Quoting

Quoting disables a character's special meaning and allows it to be used literally, as itself. The following table displays characters have special meaning to the Bourne and Korn shells.

Character | Meaning
--- | ---
`;` | Command separator
`&` | Background execution
`( )` | Command grouping
`|` | Pipe
`< > &` | Redirection symbols
`* ? [ ] ~ + - @ !` | Filename metacharacters
`" ' \` | Used in quoting other characters
`‘` | Command substitution
`$` | Variable substitution (or command or arithmetic substitution)
`space` `tab` `newline` | Word separators

These characters can be used for quoting:

`" "`
  Everything between `"` and `"` is taken literally, except for the following characters that keep their special meaning:
  `$`
    Variable (or Korn shell command and arithmetic) substitution will occur.
  `‘`
    Command substitution will occur.
  `"`
    This marks the end of the double quote.
`' '`
  Everything between `'` and `'` is taken literally except for another `'`. You cannot embed another `'` within such a quoted string.
`\`
  The character following a `\` is taken literally. Use within `" "` to escape `"`, `$`, and `‘`. Often used to escape itself, spaces, or newlines.
`$" "`
  `ksh93` only. Just like `""`, except that locale translation is done.
`$' '`
  `ksh93` only. Similar to `''`, but the quoted text is processed for the following escape sequences:

Sequence | Value | Sequence | Value
--- | --- | --- | ---
`\a` | Alert | `\``nnn` | Octal value nnn
`\b` | Backspace | `\x` `nn` | Hexadecimal value nn
`\f` | Form feed | `\'` | Single quote
`\n` | Newline | `\"` | Double quote
`\r` | Carriage return | `\\` | Backslash
`\t` | Tab | `\E` | Escape
`\v` | Vertical tab |  |

### 4.2.3.1. Examples

>     $ echo 'Single quotes "protect" double quotes'
>     Single quotes "protect" double quotes
>     $ echo "Well, isn't that \"special\"?"
>     Well, isn't that "special"?
>     $ echo "You have `ls | wc -l` files in `pwd`"
>     You have      43 files in /home/bob
>     $ echo "The value of \$x is $x"
>     The value of $x is 100

### 4.2.4. Command Forms

`cmd` `&` | Execute cmd in background.
`cmd1` `;` cmd2 | Command sequence; execute multiple cmds on the same line.
`{` `cmd1` `;` cmd2 `; }` | Execute commands as a group in the current shell.
`(``cmd1` `;` cmd2`)` | Execute commands as a group in a subshell.
`cmd1` `|` cmd2 | Pipe; use output from cmd1 as input to cmd2.
`cmd1` `‘`cmd2`‘` | Command substitution; use cmd2 output as arguments to cmd1.
`cmd1` `$(`cmd2`)` | Korn shell command substitution; nesting is allowed.
`cmd` `$((`expression`))` | Korn shell arithmetic substitution. Use the result of expression as argument to cmd.
`cmd1` `&&` cmd2 | AND; execute cmd1 and then (if cmd1 succeeds) cmd2. This is a “short-circuit” operation; cmd2 is never executed if cmd1 fails.
`cmd1` `||` cmd2 | OR; execute either cmd1 or (if cmd1 fails) cmd2. This is a “short-circuit” operation; cmd2 is never executed if cmd1 succeeds.

### 4.2.4.1. Examples

>     $ nroff file > file.txt &             Format in the background
>     $ cd; ls                              Execute sequentially
>     $ (date; who; pwd) > logfile          All output is redirected
>     $ sort file | pr -3 | lp              Sort file, page output, then print
>     $ vi `grep -l ifdef *.c`              Edit files found by grep
>     $ egrep '(yes|no)' `cat list`         Specify a list of files to search
>     $ egrep '(yes|no)' $(cat list)        Korn shell version of previous
>     $ egrep '(yes|no)' $(<list)           Same, but faster
>     $ grep XX file && lp file             Print file if it contains the pattern;
>     $ grep XX file || echo "XX not found" otherwise, echo an error message

### 4.2.5. Redirection Forms

File Descriptor | Name | Common Abbreviation | Typical Default
--- | --- | --- | ---
0 | Standard input | stdin | Keyboard
1 | Standard output | stdout | Terminal
2 | Standard error | stderr | Terminal

The usual input source or output destination can be changed, as seen in the following sections.

### 4.2.5.1. Simple redirection

``cmd`` `>` `file`
  Send output of cmd to file (overwrite).
``cmd`` `>>` `file`
  Send output of cmd to file (append).
``cmd`` `<` `file`
  Take input for cmd from file.
``cmd`` `<<` `text`
  The contents of the shell script up to a line identical to text become the standard input for cmd (text can be stored in a shell variable). This command form is sometimes called a Here document. Input is usually typed at the keyboard or in the shell program. Commands that typically use this syntax include `cat`, `ex`, and `sed`. (If `<<-` is used, leading tabs are ignored when comparing input with the end-of-input text marker.) If text is quoted, the input is passed through verbatim. Otherwise, the contents are processed for variable and command substitutions. The Korn shell also processes the input for arithmetic substitution.
``cmd`` `<>` `file`
  Korn shell only. Open file for reading and writing on the standard input. The contents are not destroyed.[5]

  > [5]With `<`, the file is opened read-only, and writes on the file descriptor will fail. With `<>`, the file is opened read-write; it is up to the application to actually take advantage of this.

### 4.2.5.2. Redirection using file descriptors

``cmd`` `>&``n` | Send cmd output to file descriptor n.
``cmd`` `m``>&``n` | Same, except that output that would normally go to file descriptor m is sent to file descriptor n instead.
``cmd`` `>&-` | Close standard output.
``cmd`` `<&``n` | Take input for cmd from file descriptor n.
``cmd`` `m``<&``n` | Same, except that input that would normally come from file descriptor m comes from file descriptor n instead.
``cmd`` `<&-` | Close standard input.
``cmd`` `<&``n``-` | Move input file descriptor n instead of duplicating it. `ksh93` only.
``cmd`` `>&``n``-` | Move output file descriptor n instead of duplicating it. `ksh93` only.

### 4.2.5.3. Multiple redirection

``cmd`` `2>``file` | Send standard error to file; standard output remains the same (e.g., the screen).
``cmd`` `>` `file` `2>&1` | Send both standard error and standard output to file.
``cmd`` `>` `f1` `2>``f2` | Send standard output to file f1, standard error to file f2.
``cmd`` `| tee` `files` | Send output of cmd to standard output (usually the terminal) and to files. (See the Example in Chapter 2, under tee.)
``cmd`` `2>&1 | tee` `files` | Send standard output and error output of cmd to standard output (usually the terminal) and to files.

No space should appear between file descriptors and a redirection symbol; spacing is optional in the other cases.

### 4.2.5.4. Examples

>     $ cat part1 > book
>     $ cat part2 part3 >> book
>     $ mail tim < report
>     $ sed 's/^/XX /g' << END_ARCHIVE
>     > This is often how a shell archive is "wrapped",
>     > bundling text for distribution.  You would normally
>     > run sed from a shell program, not from the command line.
>     > END_ARCHIVE
>     XX This is often how a shell archive is "wrapped",
>     XX bundling text for distribution.  You would normally
>     XX run sed from a shell program, not from the command line.

To redirect standard output to standard error:

>     $ echo "Usage error:  see administrator" 1>&2

The following command sends output (files found) to `filelist` and error messages (inaccessible files) to file `no_access`:

>     $ find / -print > filelist 2>no_access

### 4.2.6. Coprocesses

Coprocesses are a feature of the Korn shell only.

``cmd1`` `|` `cmd2` `|&` | Coprocess; execute the pipeline in the background. The shell sets up a two-way pipe, allowing redirection of both standard input and standard output.
`read -p` ``var`` | Read coprocess output into variable var.
`print -p` ``string`` | Write string to the coprocess.
``cmd`` `<&p` | Take input for cmd from the coprocess.
``cmd`` `>&p` | Send output of cmd to the coprocess.
`exec` ``n```<&p` | Move input for coprocess to file descriptor n.
`exec` ``n```>&p` | Move output from coprocess to file descriptor n.

Moving the coprocess input and output file descriptors to standard file descriptors allows you to open multiple coprocesses.

### 4.2.6.1. Examples

>     $
>     ed - memo |&		        Start coprocess
>     $ print -p /word/		Send ed command to coprocess
>     $ read -p search		Read output of ed command into variable search
>     $ print "$search"		Show the line on standard output
>     A word to the wise.

Copyright © 2003 O'Reilly & Associates. All rights reserved.