sh man page on Xenix

Man page or keyword search:  
man Server   1130 pages
apropos Keyword Search (all sections)
Output format
Xenix logo
[printable version]



     SH(C)		      XENIX System V			 SH(C)

     Name
	  sh - Invokes the shell command interpreter.

     Syntax
	  sh [ -aceiknrstuvx ] [ args ]

     Description
	  The shell is the standard command programming language that
	  executes commands read from a terminal or a file.  See
	  Invocation below for the meaning of arguments to the shell.

	Commands
	  A simple-command is a sequence of nonblank words separated
	  by blanks (a blank is a tab or a space).  The first word
	  specifies the name of the command to be executed.  Except as
	  specified below, the remaining words are passed as arguments
	  to the invoked command.  The command name is passed as
	  argument 0 (see exec(S)).  The value of a simple-command is
	  its exit status if it terminates normally, or (octal)
	  1000+status if it terminates abnormally.  See signal(S) for
	  a list of status values.

	  A pipeline is a sequence of one or more commands separated
	  by a vertical bar (  |  ).  (The caret (  ^  ), is an
	  obsolete synonym for the vertical bar and should not be used
	  in a pipeline; scripts that use a caret to represent a pipe
	  will be incompatible with ksh(C).)  The standard output of
	  each command but the last is connected by a pipe(S) to the
	  standard input of the next command.  Each command is run as
	  a separate process; the shell waits for the last command to
	  terminate.

	  A list is a sequence of one or more pipelines separated
	  by ;, &, &&, or || , and optionally terminated by ; or &.
	  Of these four symbols, ; and & have equal precedence, which
	  is lower than that of && and ||.  The symbols && and || also
	  have equal precedence.  A semicolon (;) causes sequential
	  execution of the preceding pipeline; an ampersand (&) causes
	  asynchronous execution of the preceding pipeline (i.e., the
	  shell does not wait for that pipeline to finish).  The
	  symbol && (|| ) causes the list following it to be executed
	  only if the preceding pipeline returns a zero (nonzero) exit
	  status.  An arbitrary number of newlines may appear in a
	  list, instead of semicolons, to delimit commands.

     Page 1					      (printed 2/7/91)

     SH(C)		      XENIX System V			 SH(C)

	  A command is either a simple-command or one of the following
	  commands.  Unless otherwise stated, the value returned by a
	  command is that of the last simple-command executed in the
	  command:

     for name [ in word ... ]
     do
       list
     done

       Each time a for command is executed, name is set to the next
       word taken from the in word list.  If in word is omitted, then
       the for command executes the do list once for each positional
       parameter that is set (see Parameter Substitution below).
       Execution ends when there are no more words in the list.

     case word in
     [ pattern [ | pattern ] ... ) list
				   ;;  ] ...
     esac
       A case command executes the list associated with the first
       pattern that matches word.  The form of the patterns is the
       same as that used for filename generation (see Filename
       Generation below).

     if list then
       list
     [ elif list then
       list ]
     [ else list ]
     fi
       The list following if is executed and, if it returns a zero
       exit status, the list following the first then is executed.
       Otherwise, the list following elif is executed and, if its
       value is zero, the list following the next then is executed.
       Failing that, the else list is executed.	 If no else list or
       then list is executed, then the if command returns a zero exit
       status.

     while list
     do
       list
     done
       A while command repeatedly executes the while list and, if the
       exit status of the last command in the list is zero, executes
       the do list; otherwise the loop terminates.  If no commands in
       the do list are executed, then the while command returns a zero
       exit status; until may be used in place of while to negate the
       loop termination test.

	  (list)
	       Executes list in a subshell.

     Page 2					      (printed 2/7/91)

     SH(C)		      XENIX System V			 SH(C)

	  {list;}
	       list is simply executed.

	  name () {list;}
	       Define a function which is referenced by name. The body
	       of functions is the list of commands between { and }.
	       Execution of functions is described later (see
	       Execution.)

	  The following words are recognized only as the first word of
	  a command and when not quoted:

	  if then else elif fi case esac for while until do done { }

	Comments
	  A word beginning with # causes that word and all the
	  following characters up to a newline to be ignored.

	Command Substitution
	  The standard output from a command enclosed in a pair of
	  grave accents (``) may be used as part or all of a word;
	  trailing newlines are removed.

	  No interpretation is done on the command string before the
	  string is read, except to remove backslashes (\) used to
	  escape other characters.  Backslashes may be used to escape
	  grave accents (`) or other backslashes and are removed
	  before the command string is read.  Escaping grave accents
	  allows nested command substitution.  If the command
	  substitution lies within a pair of double quotes (" `
	  ...` "), backslashes used to escape a double quote (\") will
	  be removed; otherwise, they will be left intact.

	  If a backslash is used to escape a newline character, both
	  the backslash and the newline are removed (see the section
	  on ``Quoting'').  In addition, backslashes used to escape
	  dollar signs (\$) are removed.  Since no interpretation is
	  done on the command string before it is read, inserting a
	  backslash to escape a dollar sign has no effect.
	  Backslashes that precede characters other than \, `, ",
	  newline, and $ are left intact.

	Parameter Substitution
	  The character $ is used to introduce substitutable
	  parameters.  There are two types of parameters, positional
	  and keyword.	If parameter is a digit, it is a positional
	  parameter. Positional parameters may be assigned values by
	  set.	Keyword parameters, (also known as variables) may be
	  assigned values by writing:

	       name=value [ name=value ] ...

     Page 3					      (printed 2/7/91)

     SH(C)		      XENIX System V			 SH(C)

	  Pattern-matching is not performed on value.  There cannot be
	  a function and a variable with the same name.

	  ${parameter}
	       A parameter is a sequence of letters, digits, or
	       underscores (a name), a digit, or any of the
	       characters *, @, #, ?, -, $, and !.  The value, if any,
	       of the parameter is substituted.	 The braces are
	       required only when parameter is followed by a letter,
	       digit, or underscore that is not to be interpreted as
	       part of its name.  A name must begin with a letter or
	       underscore.  If parameter is a digit then it is a
	       positional parameter.  If parameter is * or @, then all
	       the positional parameters, starting with $1, are
	       substituted (separated by spaces).  Parameter $0 is set
	       from argument zero when the shell is invoked.

	  ${parameter:-word}
	       If parameter is set and is not a null argument,
	       substitute its value; otherwise substitute word.

	  ${parameter:=word}
	       If parameter is not set or is null, then set it to
	       word; the value of the parameter is then substituted.
	       Positional parameters may not be assigned to in this
	       way.

	  ${parameter:?word}
	       If parameter is set and is not a null argument,
	       substitute its value; otherwise, print word and exit
	       from the shell.	If word is omitted, the message
	       ``parameter null or not set'' is printed.

	  ${parameter:+word}
	       If parameter is set and is not a null argument,
	       substitute word; otherwise substitute nothing.  In the
	       above, word is not evaluated unless it is to be used as
	       the substituted string, so that in the following
	       example, pwd is executed only if d is not set or is
	       null:

		 echo ${d:-`pwd`}

	  If the colon (:)  is omitted from the above expressions,
	  then the shell only checks whether parameter is set.

	  The following parameters are automatically set by the shell:

	  #    The number of positional parameters in decimal

	  -    Flags supplied to the shell on invocation or by the set
	       command

     Page 4					      (printed 2/7/91)

     SH(C)		      XENIX System V			 SH(C)

	  ?    The decimal value returned by the last synchronously
	       executed command

	  $    The process number of this shell

	  !    The process number of the last background command
	       invoked

	  The following parameters are used by the shell:

	  CDPATH
	       Defines search path for the cd command.	See the
	       section Special Commands, ``cd''.

	  HOME The default argument (home directory) for the cd
	       command

	  PATH The search path for commands (see Execution below)

	  MAIL If this variable is set to the name of a mail file,
	       then the shell informs the user of the arrival of mail
	       in the specified file

	  MAILCHECK
	       This parameter specifies how often (in seconds) the
	       shell will check for the arrival	 of mail  in
	       the files specified by the MAILPATH or MAIL parameters.
	       The default value is 600 seconds (10 minutes).  If set
	       to 0, the shell will check before each prompt.

	  MAILPATH
	       A colon (:) separated list of file names.  If this
	       parameter is set, the shell informs the user of the
	       arrival of mail in any of the specified files.  Each
	       file name can be followed by % and a message that will
	       be printed when the modification time changes.  The
	       default message is you have mail.

	  PS1  Primary prompt string, by default ``$ ''

	  PS2  Secondary prompt string, by default ``> ''

	  IFS  Internal field separators, normally space, tab, and
	       newline

	  SHELL
	       When the shell is invoked, it scans the environment
	       (see Environment below) for this name.  If it is found
	       and there is an `r' in the file name part of its value,
	       the shell becomes a restricted shell.

	  The shell gives default values to PATH, PS1, PS2, and IFS,

     Page 5					      (printed 2/7/91)

     SH(C)		      XENIX System V			 SH(C)

	  while HOME and MAIL are not set at all by the shell
	  (although HOME is set by login(M)).

	Blank Interpretation
	  After parameter and command substitution, the results of
	  substitution are scanned for internal field separator
	  characters (those found in IFS) and split into distinct
	  arguments where such characters are found.  Explicit null
	  arguments ("" or '') are retained.  Implicit null arguments
	  (those resulting from parameters that have no values) are
	  removed.

	Filename Generation
	  Following substitution, each command word is scanned for the
	  characters *, ?, and [.  If one of these characters appears,
	  the word is regarded as a pattern.  The word is replaced
	  with alphabetically sorted filenames that match the pattern.
	  If no filename is found that matches the pattern, the word
	  is left unchanged.  The character . at the start of a
	  filename or immediately following a /, as well as the
	  character / itself, must be matched explicitly. These
	  characters and their matching patterns are:

	  *    Matches any string, including the null string.

	  ?    Matches any single character.

	  [...]
	       Matches any one of the enclosed characters.  A pair of
	       characters separated by - matches any character
	       lexically between the pair, inclusive.  If the first
	       character following the opening bracket ([) is an
	       exclamation mark (!), then any character not enclosed
	       is matched.

	Quoting
	  The following characters have a special meaning to the shell
	  and cause termination of a word unless quoted:

	       ;  &  (	)  |  ^	 <  >  newline	space  tab

	  A character may be quoted (i.e., made to stand for itself)
	  by preceding it with a \.  The pair \newline is ignored.
	  All characters enclosed between a pair of single quotation
	  marks (''), except a single quotation mark, are quoted.
	  Inside double quotation marks (""), parameter and command
	  substitution occurs and \ quotes the characters \, `, ", and
	  $.  "$*" is equivalent to "$1 $2 ...", whereas ``$@'' is
	  equivalent to "$1" "$2" ...

	Prompting
	  When used interactively, the shell prompts with the value of

     Page 6					      (printed 2/7/91)

     SH(C)		      XENIX System V			 SH(C)

	  PS1 before reading a command.	 If at any time a newline is
	  typed and further input is needed to complete a command, the
	  secondary prompt (i.e., the value of PS2) is issued.

	Spelling Checker
	  When using cd(C) the shell checks spelling.  For example, if
	  you change to a different directory using cd and misspell
	  the directory name, the shell responds with an alternative
	  spelling of an existing directory.  Enter ``y'' and press
	  RETURN (or just press RETURN) to change to the offered
	  directory.  If the offered spelling is incorrect, enter
	  ``n'', then retype the command line.	In this example the
	  sh(C) response is boldfaced:

	       $ cd /usr/spol/uucp
	       cd /usr/spool/uucp? y
	       ok

	Input/Output
	  Before a command is executed, its input and output may be
	  redirected using a special notation interpreted by the
	  shell.  The following may appear anywhere in a
	  simple-command or may precede or follow a command. They are
	  not passed on to the invoked command; substitution occurs
	  before word or digit is used:

	  <word		Use file word as standard input (file
			descriptor 0).

	  >word		Use file word as standard output (file
			descriptor 1).	If the file does not exist, it
			is created; otherwise, it is truncated to zero
			length.

	  >>word	Use file word as standard output.  If the file
			exists, output is appended to it (by first
			seeking the end-of-file); otherwise, the file
			is created.

	  <<[-]word	The shell input is read up to a line that is
			the same as word, or to an end-of-file.	 The
			resulting document becomes the standard input.
			If any character of word is quoted, no
			interpretation is placed upon the characters
			of the document; otherwise, parameter and
			command substitution occurs, (unescaped)
			\newline is ignored, and \ must be used to
			quote the characters \, $, `, and the first
			character of word.  If - is appended to <<,
			all leading tabs are stripped from word and
			from the document.

     Page 7					      (printed 2/7/91)

     SH(C)		      XENIX System V			 SH(C)

	  <&digit	The standard input is duplicated from file
			descriptor digit (see dup(S)).	Similarly for
			the standard output using >.

	  <&-		The standard input is closed.  Similarly for
			the standard output using >.

	  If one of the above is preceded by a digit, the file
	  descriptor created is that specified by the digit (instead
	  of the default 0 or 1).  For example:

	       ... 2>&1

	  creates file descriptor 2 that is a duplicate of file
	  descriptor 1.

	  If a command is followed by &, 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.

	Environment
	  The environment (see environ(M)) is a list of name-value
	  pairs that is passed to an executed program in the same way
	  as a normal argument list.  The shell interacts with the
	  environment in several ways.	On invocation, the shell scans
	  the environment and creates a parameter for each name found,
	  giving it the corresponding value.  Executed commands
	  inherit the same environment.	 If the user modifies the
	  values of these parameters or creates new ones, none of
	  these affect the environment unless the export command is
	  used to bind the shell's parameter to the environment.  The
	  environment seen by any executed command is composed of any
	  unmodified name-value pairs originally inherited by the
	  shell, minus any pairs removed by unset, plus any
	  modifications or additions, all of which must be noted in
	  export commands.

	  The environment for any simple-command may be augmented by
	  prefixing it with one or more assignments to parameters.
	  Thus:

	       TERM=wy60 cmd args

	  and

	       (export TERM; TERM=wy60; cmd args)

	  are equivalent (as far as the above execution of cmd is
	  concerned).

     Page 8					      (printed 2/7/91)

     SH(C)		      XENIX System V			 SH(C)

	  If the -k flag is set, all keyword arguments are placed in
	  the environment, even if they occur after the command name.

	Signals
	  The INTERRUPT and QUIT signals for an invoked command are
	  ignored if the command is followed by &; otherwise signals
	  have the values inherited by the shell from its parent, with
	  the exception of signal 11.  See the trap command below.

	Execution
	  Each time a command is executed, the above substitutions are
	  carried out.	If the command name does not match a Special
	  Command, but matches the name of a defined function, the
	  function is executed in the shell process (note how this
	  differs from the execution of shell procedures). The
	  positional parameters $1, $2, ... are set to the arguments
	  of the function. If the command name matches neither a
	  Special Command nor the name of a defined function, a new
	  process is created and an attempt is made to execute the
	  command via exec(S).

	  The shell parameter PATH defines the search path for the
	  directory containing the command.  Alternative directory
	  names are separated by a colon (:).  The default path is
	  :/bin:/usr/bin (specifying the current directory, /bin, and
	  /usr/bin, in that order).  Note that the current directory
	  is specified by a null pathname, which can appear
	  immediately after the equal sign or between the colon
	  delimiters anywhere else in the path list.  If the command
	  name contains a /, then the search path is not used.
	  Otherwise, each directory in the path is searched for an
	  executable file.  If the file has execute permission but is
	  not an a.out file, it is assumed to be a file containing
	  shell commands.  A subshell (i.e., a separate process) is
	  spawned to read it.  A parenthesized command is also
	  executed in a subshell.

	  Shell procedures are often used by users running the csh.
	  However, if the first character of the procedure is a #
	  (comment character), csh assumes the procedure is a csh
	  script, and invokes /bin/csh to execute it. Always start sh
	  procedures with some other character if csh users are to run
	  the procedure at any time.  This invokes the standard shell
	  /bin/sh.

	  The location in the search path where a command was found is
	  remembered by the shell (to help avoid unnecessary execs
	  later).  If the command was found in a relative directory,
	  its location must be re-determined whenever the current
	  directory changes.  The shell forgets all remembered
	  locations whenever the PATH variable is changed or the
	  hash -r command is executed (see hash in next section).

     Page 9					      (printed 2/7/91)

     SH(C)		      XENIX System V			 SH(C)

	Special Commands
	  Input/output redirection is permitted for these commands:

	  :    No effect; the command does nothing.  A zero exit code
	       is returned.

	  . file
	       Reads and executes commands from file and returns.  The
	       search path specified by PATH is used to find the
	       directory containing file.

	  break [ n ]
	       Exits from the enclosing for, while, or until loop, if
	       any.  If n is specified, it breaks n levels.

	  continue [ n ]
	       Resumes the next iteration of the enclosing for, while,
	       or until loop.  If n is specified, it resumes at the
	       n-th enclosing loop.

	  cd [ arg ]
	       Changes the current directory to arg.  The shell
	       parameter HOME is the default arg.  The shell parameter
	       CDPATH defines the search path for the directory
	       containing arg.	Alternative directory names are
	       separated by a colon (:).  The default path is <null>
	       (specifying the current directory).  Note that the
	       current directory is specified by a null path name,
	       which can appear immediately after the equal sign or
	       between the colon delimiters anywhere else in the path
	       list.  If arg begins with a /, the search path is not
	       used.  Otherwise, each directory in the path is
	       searched for arg.

	       If the shell is reading its commands from a terminal,
	       and the specified directory does not exist (or some
	       component cannot be searched), spelling correction is
	       applied to each component of directory, in a search for
	       the ``correct'' name.  The shell then asks whether or
	       not to try and change directory to the corrected
	       directory name; an answer of n means ``no'', and
	       anything else is taken as ``yes''.

	  echo [ arg ]
	       Writes arguments separated by blanks and terminated by
	       a newline on the standard output.  Arguments may be
	       enclosed in quotes.  Quotes are required so that the
	       shell correctly interprets these special escape
	       sequences:

	    \b	 Backspace

       Page 10						(printed 2/7/91)

       SH(C)			XENIX System V			   SH(C)

	    \c	 Prints line without newline.
	    \f	 Form feed

	    \n	 Newline
	    \r	 Carriage return

	    \t	 Tab
	    \v	 Vertical tab

	    \\	 Backslash
	    \n	 The 8-bit character whose ASCII code is the 1, 2 or 3-
	      digit octal number n which must start with a zero

	 eval [ arg ... ]
	      The arguments are read as input to the shell and the
	      resulting command(s) executed.
	 exec [ arg ... ]
	      The command specified by the arguments is executed in
	      place of this shell without creating a new process.
	      Input/output arguments may appear and, if no other
	      arguments are given, cause the shell input/output to be
	      modified.

	 exit [ n ]
	      Causes the shell to exit with the exit status specified
	      by n.  If n is omitted, the exit status is that of the
	      last command executed.  An end-of-file will also cause
	      the shell to exit.
	 export [ name ... ]
	      The given names are marked for automatic export to the
	      environment of subsequently executed commands.  If no
	      arguments are given, a list of all names that are
	      exported in this shell is printed.

	 getopts
	      Used in shell scripts to support command syntax
	      standards (see intro(C)); it parses positional
	      parameters and checks for legal options.	See
	      getopts(C) for usage and description.
	 hash [ -r ] [ name ... ]
	      For each name, the location in the search path of the
	      command specified by name is determined and remembered
	      by the shell.  The -r option causes the shell to forget
	      all remembered locations.	 If no arguments are given,
	      information about remembered commands is presented.
	      Hits is the number of times a command has been invoked
	      by the shell process.  Cost is a measure of the work
	      required to locate a command in the search path.	There
	      are certain situations which require that the stored
	      location of a command be recalculated.  Commands for
	      which this will be done are indicated by an asterisk
	      (*) adjacent to the hits information.  Cost will be

    Page 11					     (printed 2/7/91)

    SH(C)		     XENIX System V			SH(C)

	      incremented when the recalculation is done.

	 newgrp [ arg ... ]
	      Equivalent to exec newgrp arg ...
	 pwd  Print the current working directory.  See pwd(C) for
	      usage and description.

	 read [ name ... ]
	      One line is read from the standard input and the first
	      word is assigned to the first name, the second word to
	      the second name, etc., with leftover words assigned to
	      the last name.  The return code is 0 unless an
	      end-of-file is encountered.
	 readonly [ name ... ]
	      The given names are marked readonly and the values of
	      these names may not be changed by subsequent
	      assignment.  If no arguments are given, a list of all
	      readonly names is printed.

	 return [ n ]
	      Causes a function to exit with the return value
	      specified by n.  If n is omitted, the return status is
	      that of the last command executed.
	 set [ -aefhknuvx [ arg ... ] ]
	      -a   Mark variables which are modified or created for
		   export.
	      -e   If the shell is noninteractive, exits immediately
		   if a command exits with a nonzero exit status.

	      -f   Disables file name generation.
	      -h   Locates and remembers function commands as
		   functions are defined (function commands are
		   normally located when the function is executed).
		   For example, /bin/tty would be added to the hash
		   table if, say,  showtty() { tty } is declared.  If
		   -h was unset, it would not be added to the hash
		   table until showtty is called.

	      -k   Places all keyword arguments in the environment
		   for a command, not just those that precede the
		   command name.
	      -n   Reads commands but does not execute them.

	      -u   Treats unset variables as an error when
		   substituting.
	      -v   Prints shell input lines as they are read.

	      -x   Prints commands and their arguments as they are
		   executed.  Although this flag is passed to
		   subshells, it does not enable tracing in those
		   subshells.
	      --   Does not change any of the flags; useful in

    Page 12					     (printed 2/7/91)

    SH(C)		     XENIX System V			SH(C)

		   setting $1 to -.

		   Using + rather than - causes these flags to be
		   turned off.	These flags can also be used upon
		   invocation of the shell.  The current set of flags
		   may be found in $-.	The remaining arguments are
		   positional parameters and are assigned, in order,
		   to $1, $2, ...  If no arguments are given, the
		   values of all names are printed.

	 shift [n]
	      The positional parameters from $2 ...  are renamed $1
	      ...  If n is specified, shift them by  places.  shift
	      is the only way to access positional parameters above
	      $9.

	 test
	      Evaluates conditional expressions. See test(C) for
	      usage and description.

	 times
	      Prints the accumulated user and system times for
	      processes run from the shell.

	 trap [ arg ] [ n ] ...
	      arg is a command to be read and executed when the shell
	      receives signal(s) n.  (Note that arg is scanned once
	      when the trap is set and once when the trap is taken.)
	      Trap commands are executed in order of signal number.
	      The highest signal number allowed is 16.	Any attempt
	      to set a trap on a signal that was ignored on entry to
	      the current shell is ineffective.	 An attempt to trap
	      on signal 11 (memory fault) produces an error.  If arg
	      is absent, all trap(s) n are reset to their original
	      values.  If arg is the null string, this signal is
	      ignored by the shell and by the commands it invokes.
	      If n is 0, the command arg is executed on exit from the
	      shell.  The trap command with no arguments prints a
	      list of commands associated with each signal number.

	 type [ name ... ]
	      For each name, indicate how it would be interpreted if
	      used as a command name.

	 ulimit [ n ]
	      imposes a size limit of n blocks on files written by
	      the shall and its child processes (files of any size
	      may be read). Any user may decrease the file size
	      limit, but only the super-user (root) can increase the
	      limit.  With no argument, the current limit is printed.

	 unset [ name ... ]

    Page 13					     (printed 2/7/91)

    SH(C)		     XENIX System V			SH(C)

	      For each name, remove the corresponding variable or
	      function.	 The variables PATH, PS1, PS2, MAILCHECK and
	      IFS cannot be unset.

	 umask [ ooo ]
	      The user file-creation mask is set to the octal number
	      ooo where o is an octal digit (see umask(C)).  If ooo
	      is omitted, the current value of the mask is printed.

	 wait [ n ]
	      Waits for the specified process to terminate, and
	      reports the termination status.  If n is not given, all
	      currently active child processes are waited for.	The
	      return code from this command is always 0.

       Invocation
	 If the shell is invoked through exec(S) and the first
	 character of argument 0 is -, commands are initially read
	 from /etc/profile and then from $HOME/.profile, if such
	 files exist.  Thereafter, commands are read as described
	 below, which is also the case when the shell is invoked as
	 /bin/sh.  The flags below are interpreted by the shell on
	 invocation only; note that unless the -c or -s flag is
	 specified, the first argument is assumed to be the name of a
	 file containing commands, and the remaining arguments are
	 passed as positional parameters to that command file:

	 -c string If the -c flag is present, commands are read from
		   string.

	 -s	   If the -s flag is present or if no arguments
		   remain, commands are read from the standard input.
		   Any remaining arguments specify the positional
		   parameters.	Shell output is written to file
		   descriptor 2.

	 -t	   If the -t flag is present, a single command is
		   read and executed, and the shell exits.  This flag
		   is intended for use by C programs only and is not
		   useful interactively.

	 -i	   If the -i flag is present or if the shell input
		   and output are attached to a terminal, this shell
		   is interactive.  In this case, TERMINATE is
		   ignored (so that kill 0 does not kill an
		   interactive shell) and INTERRUPT is caught and
		   ignored (so that wait is interruptible).  In all
		   cases, QUIT is ignored by the shell.

	 -r	   If the -r flag is present, the shell is a
		   restricted shell (see rsh(C)).

    Page 14					     (printed 2/7/91)

    SH(C)		     XENIX System V			SH(C)

	 The remaining flags and arguments are described under the
	 set command above.

    Exit Status
	 Errors detected by the shell, such as syntax errors, cause
	 the shell to return a nonzero exit status.  If the shell is
	 being used noninteractively, execution of the shell file is
	 abandoned.  Otherwise, the shell returns the exit status of
	 the last command executed. See the exit command above.

    Files
	 /etc/profile	  system default profile
	 $HOME/.profile	  read by login shell at login
	 /tmp/sh*	  temporary file for <<
	 /dev/null	  source of empty file

    See Also
	 cd(C), env(C), login(M), newgrp(C), rsh(C), test(C),
	 umask(C), dup(S), exec(S), fork(S), pipe(S), signal(S),
	 umask(S), wait(S), a.out(F), profile(M), environ(M)

    Notes
	 If << is used to provide standard input to an asynchronous
	 process invoked by &, the shell gets mixed up about naming
	 the input document; a garbage file /tmp/sh* is created and
	 the shell complains about not being able to find that file
	 by another name.

	 If a command is executed, and a command with the same name
	 is installed in a directory in the search path before the
	 directory where the original command was found, the shell
	 will continue to exec the original command.  Use the hash
	 command to correct this situation.

	 If you move the current directory or one above it, pwd may
	 not give the correct response.	 Use the cd command with a
	 full path name to correct this situation.

	 When a sh(C) user logs in, the system reads and executes
	 commands in /etc/profile before executing commands in the
	 user's $HOME/.profile.	 You can, therefore, modify the
	 environment for all sh(C) users on the system by editing
	 /etc/profile.

	 The shell doesn't treat the high (eighth) bit in the
	 characters of a command line argument specially, nor does it
	 strip the eighth bit from the characters of error messages.
	 Previous versions of the shell used the eighth bit as a
	 quoting mechanism.

	 Existing programs that set the eighth bit of characters in
	 order to quote them as part of the shell command line should

    Page 15					     (printed 2/7/91)

    SH(C)		     XENIX System V			SH(C)

	 be changed to use of the standard shell quoting mechanisms
	 (see the section on ``Quoting'').

	 Words used to filenames in input/output redirection are not
	 interpreted for filename generation (see the section on
	 ``File Name Generation'').  For example, cat file1 > a* will
	 create a file named a*.

	 Because commands in pipelines are run as separate processes,
	 variables set in a pipeline have no effect on the parent
	 shell.

	 If you get the error message:

	      fork failed - too many processes

	 try using the wait(C) command to clean up your background
	 processes.  If this doesn't help, the system process table
	 is probably full or you have too many active foreground
	 processes (there is a limit to the number of processes that
	 can associated with your login, and to the number the system
	 can keep track of).  These limits are associated with the
	 kernel parameters NPROC and MAXUPRC.

    Warnings
	 Not all processes of a 3- or more-stage pipeline are
	 children of the shell, and thus cannot be waited for.

	 For wait n, if n is not an active process id, all your
	 shell's currently active background processes are waited for
	 and the return code will be zero.

    Page 16					     (printed 2/7/91)

[top]
                             _         _         _ 
                            | |       | |       | |     
                            | |       | |       | |     
                         __ | | __ __ | | __ __ | | __  
                         \ \| |/ / \ \| |/ / \ \| |/ /  
                          \ \ / /   \ \ / /   \ \ / /   
                           \   /     \   /     \   /    
                            \_/       \_/       \_/ 
More information is available in HTML format for server Xenix

List of man pages available for Xenix

Copyright (c) for man pages and the logo by the respective OS vendor.

For those who want to learn more, the polarhome community provides shell access and support.

[legal] [privacy] [GNU] [policy] [cookies] [netiquette] [sponsors] [FAQ]
Tweet
Polarhome, production since 1999.
Member of Polarhome portal.
Based on Fawad Halim's script.
....................................................................
Vote for polarhome
Free Shell Accounts :: the biggest list on the net