(zsh.info.gz) Redirection

Info Catalog (zsh.info.gz) Shell Grammar (zsh.info.gz) Top (zsh.info.gz) Command Execution
 
 7 Redirection
 *************
 
 If a command is followed by & and job control is not active, then the
 default standard input for the command is the empty file /dev/null.
 Otherwise, the environment for the execution of a command contains the
 file descriptors of the invoking shell as modified by input/output
 specifications.
 
 The following may appear anywhere in a simple command or may precede or
 follow a complex command.  Expansion occurs before WORD or DIGIT is used
 except as noted below.  If the result of substitution on WORD produces
 more than one filename, redirection occurs for each separate filename in
 turn.
 
 < WORD
      Open file WORD for reading as standard input.
 
 <> WORD
      Open file WORD for reading and writing as standard input.  If the
      file does not exist then it is created.
 
 > WORD
      Open file WORD for writing as standard output.  If the file does
      not exist then it is created.  If the file exists, and the CLOBBER
      option is unset, this causes an error; otherwise, it is truncated
      to zero length.
 
 >| WORD
 >! WORD
      Same as >, except that the file is truncated to zero length if it
      exists, even if CLOBBER is unset.
 
 >> WORD
      Open file WORD for writing in append mode as standard output.  If
      the file does not exist, and the CLOBBER option is unset, this
      causes an error; otherwise, the file is created.
 
 >>| WORD
 >>! WORD
      Same as >>, except that the file is created if it does not exist,
      even if CLOBBER is unset.
 
 <<[-] WORD
      The shell input is read up to a line that is the same as WORD, or
      to an end-of-file.  No parameter expansion, command substitution or
      filename generation is performed on WORD.  The resulting document,
      called a _here-document_, becomes the standard input.
 
      If any character of WORD is quoted with single or double quotes or
      a '\', no interpretation is placed upon the characters of the
      document.  Otherwise, parameter and command substitution occurs,
      '\' followed by a newline is removed, and '\' must be used to quote
      the characters '\', '$', '`' and the first character of WORD.
 
      Note that WORD itself does not undergo shell expansion.  Backquotes
      in WORD do not have their usual effect; instead they behave
      similarly to double quotes, except that the backquotes themselves
      are passed through unchanged.  (This information is given for
      completeness and it is not recommended that backquotes be used.)
      Quotes in the form $'...' have their standard effect of expanding
      backslashed references to special characters.
 
      If <<- is used, then all leading tabs are stripped from WORD and
      from the document.
 
 <<< WORD
      Perform shell expansion on WORD and pass the result to standard
      input.  This is known as a _here-string_.  Compare the use of WORD
      in here-documents above, where WORD does not undergo shell
      expansion.
 
 <& NUMBER
 >& NUMBER
      The standard input/output is duplicated from file descriptor NUMBER
      (see man page dup2(2)).
 
 <& -
 >& -
      Close the standard input/output.
 
 <& p
 >& p
      The input/output from/to the coprocess is moved to the standard
      input/output.
 
 >& WORD
 &> WORD
      (Except where '>& WORD' matches one of the above syntaxes; '&>' can
      always be used to avoid this ambiguity.)  Redirects both standard
      output and standard error (file descriptor 2) in the manner of '>
      WORD'.  Note that this does _not_ have the same effect as '> WORD
      2>&1' in the presence of multios (see the section below).
 
 >&| WORD
 >&! WORD
 &>| WORD
 &>! WORD
      Redirects both standard output and standard error (file descriptor
      2) in the manner of '>| WORD'.
 
 >>& WORD
 &>> WORD
      Redirects both standard output and standard error (file descriptor
      2) in the manner of '>> WORD'.
 
 >>&| WORD
 >>&! WORD
 &>>| WORD
 &>>! WORD
      Redirects both standard output and standard error (file descriptor
      2) in the manner of '>>| WORD'.
 
 If one of the above is preceded by a digit, then the file descriptor
 referred to is that specified by the digit instead of the default 0 or
 1.  The order in which redirections are specified is significant.  The
 shell evaluates each redirection in terms of the (_file descriptor_,
 _file_) association at the time of evaluation.  For example:
 
      ...  1>FNAME 2>&1
 
 first associates file descriptor 1 with file FNAME.  It then associates
 file descriptor 2 with the file associated with file descriptor 1 (that
 is, FNAME).  If the order of redirections were reversed, file descriptor
 2 would be associated with the terminal (assuming file descriptor 1 had
 been) and then file descriptor 1 would be associated with file FNAME.
 
 The '|&' command separator described in  Simple Commands &
 Pipelines is a shorthand for '2>&1 |'.
 
 The various forms of process substitution, '<(LIST)', and '=(LIST())'
 for input and '>(LIST)' for output, are often used together with
 redirection.  For example, if WORD in an output redirection is of the
 form '>(LIST)' then the output is piped to the command represented by
 LIST.  See  Process Substitution.
 
 7.1 Opening file descriptors using parameters
 =============================================
 
 When the shell is parsing arguments to a command, and the shell option
 IGNORE_BRACES is not set, a different form of redirection is allowed:
 instead of a digit before the operator there is a valid shell identifier
 enclosed in braces.  The shell will open a new file descriptor that is
 guaranteed to be at least 10 and set the parameter named by the
 identifier to the file descriptor opened.  No whitespace is allowed
 between the closing brace and the redirection character.  For example:
 
      ...  {myfd}>&1
 
 This opens a new file descriptor that is a duplicate of file descriptor
 1 and sets the parameter myfd to the number of the file descriptor,
 which will be at least 10.  The new file descriptor can be written to
 using the syntax >&$myfd.
 
 The syntax {VARID}>&-, for example {myfd}>&-, may be used to close a
 file descriptor opened in this fashion.  Note that the parameter given
 by VARID must previously be set to a file descriptor in this case.
 
 It is an error to open or close a file descriptor in this fashion when
 the parameter is readonly.  However, it is not an error to read or write
 a file descriptor using <&$PARAM or >&$PARAM if PARAM is readonly.
 
 If the option CLOBBER is unset, it is an error to open a file descriptor
 using a parameter that is already set to an open file descriptor
 previously allocated by this mechanism.  Unsetting the parameter before
 using it for allocating a file descriptor avoids the error.
 
 Note that this mechanism merely allocates or closes a file descriptor;
 it does not perform any redirections from or to it.  It is usually
 convenient to allocate a file descriptor prior to use as an argument to
 exec.  The syntax does not in any case work when used around complex
 commands such as parenthesised subshells or loops, where the opening
 brace is interpreted as part of a command list to be executed in the
 current shell.
 
 The following shows a typical sequence of allocation, use, and closing
 of a file descriptor:
 
      integer myfd
      exec {myfd}>~/logs/mylogfile.txt
      print This is a log message. >&$myfd
      exec {myfd}>&-
 
 Note that the expansion of the variable in the expression >&$myfd occurs
 at the point the redirection is opened.  This is after the expansion of
 command arguments and after any redirections to the left on the command
 line have been processed.
 
 7.2 Multios
 ===========
 
 If the user tries to open a file descriptor for writing more than once,
 the shell opens the file descriptor as a pipe to a process that copies
 its input to all the specified outputs, similar to 'tee', provided the
 MULTIOS option is set, as it is by default.  Thus:
 
      date >foo >bar
 
 writes the date to two files, named 'foo' and 'bar'.  Note that a pipe
 is an implicit redirection; thus
 
      date >foo | cat
 
 writes the date to the file 'foo', and also pipes it to cat.
 
 If the MULTIOS option is set, the word after a redirection operator is
 also subjected to filename generation (globbing).  Thus
 
      : > *
 
 will truncate all files in the current directory, assuming there's at
 least one.  (Without the MULTIOS option, it would create an empty file
 called '*'.)  Similarly, you can do
 
      echo exit 0 >> *.sh
 
 If the user tries to open a file descriptor for reading more than once,
 the shell opens the file descriptor as a pipe to a process that copies
 all the specified inputs to its output in the order specified, similar
 to 'cat', provided the MULTIOS option is set.  Thus
 
      sort <foo <fubar
 
 or even
 
      sort <f{oo,ubar}
 
 is equivalent to 'cat foo fubar | sort'.
 
 Expansion of the redirection argument occurs at the point the
 redirection is opened, at the point described above for the expansion of
 the variable in >&$myfd.
 
 Note that a pipe is an implicit redirection; thus
 
      cat bar | sort <foo
 
 is equivalent to 'cat bar foo | sort' (note the order of the inputs).
 
 If the MULTIOS option is _un_set, each redirection replaces the previous
 redirection for that file descriptor.  However, all files redirected to
 are actually opened, so
 
      echo foo > bar > baz
 
 when MULTIOS is unset will truncate bar, and write 'foo' into baz.
 
 There is a problem when an output multio is attached to an external
 program.  A simple example shows this:
 
      cat file >file1 >file2
      cat file1 file2
 
 Here, it is possible that the second 'cat' will not display the full
 contents of file1 and file2 (i.e.  the original contents of file
 repeated twice).
 
 The reason for this is that the multios are spawned after the cat
 process is forked from the parent shell, so the parent shell does not
 wait for the multios to finish writing data.  This means the command as
 shown can exit before file1 and file2 are completely written.  As a
 workaround, it is possible to run the cat process as part of a job in
 the current shell:
 
      { cat file } >file >file2
 
 Here, the {...} job will pause to wait for both files to be written.
 
 7.3 Redirections with no command
 ================================
 
 When a simple command consists of one or more redirection operators and
 zero or more parameter assignments, but no command name, zsh can behave
 in several ways.
 
 If the parameter NULLCMD is not set or the option CSH_NULLCMD is set, an
 error is caused.  This is the 'csh' behavior and CSH_NULLCMD is set by
 default when emulating 'csh'.
 
 If the option SH_NULLCMD is set, the builtin ':' is inserted as a
 command with the given redirections.  This is the default when emulating
 'sh' or 'ksh'.
 
 Otherwise, if the parameter NULLCMD is set, its value will be used as a
 command with the given redirections.  If both NULLCMD and READNULLCMD
 are set, then the value of the latter will be used instead of that of
 the former when the redirection is an input.  The default for NULLCMD is
 'cat' and for READNULLCMD is 'more'.  Thus
 
      < file
 
 shows the contents of file on standard output, with paging if that is a
 terminal.  NULLCMD and READNULLCMD may refer to shell functions.
 
Info Catalog (zsh.info.gz) Shell Grammar (zsh.info.gz) Top (zsh.info.gz) Command Execution
automatically generated by info2html