Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
ksh(1)									ksh(1)

NAME
       ksh,  rksh  -  KornShell, a standard/restricted command and programming
       language

SYNOPSIS
       /usr/bin/ksh [ +- abCefhikmnoprstuvx] [ +- o  option] ... [arg...]

       /usr/bin/ksh -c	[ +- abCefhikmnoprstuvx] [ +-  o   option]  ...	  com-
       mand_string [command_name [ arg...]]

       /usr/xpg4/bin/sh	 [ +- abCefhikmnoprstuvx] [ +- o  option] ... [arg...]

       /usr/xpg4/bin/sh	-c  [ +- abCefhikmnoprstuvx] [ +- o  option] ...  com-
       mand_string [command_name [ arg...]]

       /usr/bin/rksh [ +- abCefhikmnoprstuvx] [	+- o  option] ... [arg...]

       /usr/bin/rksh  -c   [  +- abCefhikmnoprstuvx] [ +- o  option] ...  com-
       mand_string [command_name [ arg...]]

       The /usr/xpg4/bin/sh utility is a standards compliant shell. This util-
       ity  provides  all  the	functionality of /usr/bin/ksh, except in cases
       where differences in behavior exist. See	Arithmetic Expansions  section
       for details.

       /usr/bin/ksh  is	 a command and programming language that executes com-
       mands read from a terminal or a file. rksh is a restricted  version  of
       the  command interpreter	ksh; it	is used	to set up login	names and exe-
       cution environments whose capabilities are more controlled  than	 those
       of  the	standard  shell. See the Invocation section for	the meaning of
       arguments to the	shell.

   Definitions
       A metacharacter is one of the following characters:

       ; & (   )   |   <   >	  NEWLINE   SPACE   TAB

       A blank is a TAB	or a SPACE. An identifier is a	sequence  of  letters,
       digits,	or  underscores	 starting with a letter	or underscore. Identi-
       fiers are used as names for  functions  and  variables.	A  word	 is  a
       sequence	 of characters separated by one	or more	non-quoted metacharac-
       ters.

       A command is a sequence of characters in	the syntax of the  shell  lan-
       guage.  The shell reads each command and	carries	out the	desired	action
       either directly or by invoking separate utilities. A special-command is
       a  command that is carried out by the shell without creating a separate
       process.	Except for documented side effects, most special commands  can
       be implemented as separate utilities.

   Commands
       A  simple-command  is  a	sequence of blank-separated words which	can be
       preceded	by a variable assignment list.	See  Environment.   The	 first
       word specifies the name of the command to be executed. Except as	speci-
       fied, the remaining words are passed as arguments to the	 invoked  com-
       mand. The command name is passed	as argument 0 (see exec(2)). The value
       of a simple-command is its exit status if it terminates normally. If it
       terminates abnormally due to receipt of a signal, the value is the sig-
       nal number plus 128. See	signal.h(3HEAD)	for a list of  signal  values.
       Obviously, normal exit status values 129	to 255 cannot be distinguished
       from abnormal exit caused by receiving signal numbers 1 to 127.

       A pipeline is a sequence	of one or more commands	separated  by  |.  The
       standard	 output	of each	command	but the	last is	connected by a pipe(2)
       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.
       The exit	status of a pipeline is	the exit status	of the last command.

       A list is a sequence of one or more pipelines separated by ;, &,	&&, or
       ||, and optionally terminated by	;, &, or |&. Of	these five 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 (that is, the
       shell does not wait for that pipeline to	finish). The symbol |&	causes
       asynchronous execution of the preceding command or pipeline with	a two-
       way pipe	established to the parent shell.

       The standard input and output of	the spawned command can	be written  to
       and  read  from	by the parent shell using the -p option	of the special
       commands	read and print described in Special Commands.  The  symbol  &&
       (||)  causes the	list following it to be	executed only if the preceding
       pipeline	returns	0 (or a	non-zero) value. An arbitrary number  of  new-
       lines  can  appear in a list, instead of	a semicolon, to	delimit	a com-
       mand.

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

       for identifier [	in word	... ] ;	do list	; done

	   Each	time a for command is executed,	identifier 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.	Execution ends
	   when	there are no more words	in the list.

       select identifier [ in word ... ] ; do list ; done

	   A select command prints to standard error (file descriptor 2),  the
	   set of words, each preceded by a number. If in word ... is omitted,
	   then	the positional parameters are used instead. See	Parameter Sub-
	   stitution.  The  PS3	 prompt	is printed and a line is read from the
	   standard input. If this line	consists of the	number of one  of  the
	   listed  words,  then	the value of the variable identifier is	set to
	   the word corresponding to this number. If this line	is  empty  the
	   selection  list  is printed again. Otherwise	the value of the vari-
	   able	identifier is set to NULL.  (See  Blank	 Interpretation	 about
	   NULL).  The	contents of the	line read from standard	input is saved
	   in the shell	variable REPLY.	The list is executed for  each	selec-
	   tion	 until a break or EOF is encountered. If the REPLY variable is
	   set to NULL by the execution	of list, then the  selection  list  is
	   printed before displaying the PS3 prompt for	the next selection.

       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 file-name generation. See File Name	Generation.

       if  list	 ; then	list ; [ elif list ; then list ; ... ] [ else list ; ]
       fi

	   The list following if is executed and, if it	returns	an exit	status
	   of 0, the list following the	first then is executed.	Otherwise, the
	   list	following elif is executed and,	if its value is	 0,  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 0 exit status.

       while list ; do list ; done
       until 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 0,	executes the do	 list;
	   otherwise  the  loop	 terminates. If	no commands in the do list are
	   executed, then the while command returns 0 exit status.  until  can
	   be used in place of while to	negate the loop	termination test.

       (list)

	   Execute list	in a separate environment. If two adjacent open	paren-
	   theses are needed for nesting, a space must be  inserted  to	 avoid
	   arithmetic evaluation.

       {list}

	   list	is simply executed. Unlike the metacharacters (	and ), { and }
	   are reserved	words and must occur at	the beginning  of  a  line  or
	   after a ; in	order to be recognized.

       [[expression]]

	   Evaluates  expression  and returns 0	exit status when expression is
	   true. See Conditional Expressions for a description of  expression.

       function	identifier { list ;}
       identifier( ) { list ;}

	   Define  a  function	which is referenced by identifier. The body of
	   the function	is the list of commands	between	{  and	}.  See	 Func-
	   tions.

       time pipeline

	   The	pipeline  is executed and the elapsed time as well as the user
	   and system time are printed to standard error.

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

       !	  if	   then	    else    elif    fi	    case
       esac	  for	   while    until   do	    done    {	}
       function	  select   time	    [[	]]

   Comments
       A  word beginning with #	causes that word and all the following charac-
       ters up to a new-line to	be ignored.

   Aliasing
       The first word of each command is replaced by the text of an  alias  if
       an  alias for this word has been	defined. An alias name consists	of any
       number of characters excluding metacharacters, quoting characters, file
       expansion  characters,  parameter  and command substitution characters,
       and =. The replacement  string  can  contain  any  valid	 shell	script
       including  the metacharacters listed above. The first word of each com-
       mand in the replaced text, other	than any that are in  the  process  of
       being  replaced,	 is  tested  for aliases. If the last character	of the
       alias value is a	blank then the word following the  alias  is  also  be
       checked for alias substitution. Aliases can be used to redefine special
       builtin commands	but cannot be used  to	redefine  the  reserved	 words
       listed  above.  Aliases	can  be	created, listed, and exported with the
       alias command and can be	removed	with  the  unalias  command.  Exported
       aliases	remain	in  effect  for	 scripts  invoked by name, but must be
       reinitialized for separate invocations of the shell. See	Invocation. To
       prevent	infinite loops in recursive aliasing, if the shell is not cur-
       rently processing an alias of the same name, the	word  is  replaced  by
       the value of the	alias; otherwise, it is	not be replaced.

       Aliasing	 is  performed	when scripts are read, not while they are exe-
       cuted. Therefore, for an	alias to take  effect,	the  alias  definition
       command	has  to	 be  executed  before the command which	references the
       alias is	read.

       Aliases are frequently used as a	short hand for	full  path  names.  An
       option  to  the	aliasing  facility allows the value of the alias to be
       automatically set to the	full pathname of  the  corresponding  command.
       These  aliases are called tracked aliases. The value of a tracked alias
       is defined the first time the corresponding command is  looked  up  and
       becomes	undefined  each	time the PATH variable is reset. These aliases
       remain tracked so that the  next	 subsequent  reference	redefines  the
       value.  Several	tracked	 aliases  are  compiled	into the shell.	The -h
       option of the set command makes each referenced	command	 name  into  a
       tracked alias.

       The  following exported aliases are compiled into (and built-in to) the
       shell but can be	unset or redefined:

       autoload='typeset -fu'
       functions='typeset -f'
       history='fc -l'
       integer='typeset	-i'
       nohup='nohup '
       r='fc -e	-'

       An example concerning trailing blank characters and reserved words fol-
       lows. If	the user types:

       $ alias foo="/bin/ls "
       $ alias while="/"

       the effect of executing:

       $ while true
       > do
       > echo "Hello, World"
       > done

       is  a never-ending sequence of Hello, World strings to the screen. How-
       ever, if	the user types:

       $ foo while

       the result is an	ls listing of /. Since the alias substitution for  foo
       ends in a space character, the next word	is checked for alias substitu-
       tion. The next word, while, has also been aliased, so it	is substituted
       as  well.  Since	it is not in the proper	position as a command word, it
       is not recognized as a reserved word.

       If the user types:

       $ foo; while

       while retains its normal	reserved-word properties.

   Tilde Substitution
       After alias substitution	is performed, each word	is checked to  see  if
       it  begins  with	 an unquoted ~.	If it does, then the word up to	a / is
       checked to see if it matches a user name. If a match is	found,	the  ~
       and  the	 matched login name are	replaced by the	login directory	of the
       matched user. This is called a  tilde  substitution.  If	 no  match  is
       found,  the original text is left unchanged. A ~	by itself, or in front
       of a /, is replaced by $HOME. A ~ followed by a + or - is  replaced  by
       $PWD and	$OLDPWD, respectively.

       In  addition, tilde substitution	is attempted when the value of a vari-
       able assignment begins with a ~.

   Tilde Expansion
       A tilde-prefix consists of an unquoted tilde character at the beginning
       of  a  word,  followed  by  all	of  the	characters preceding the first
       unquoted	slash in the word, or all the characters in the	word if	 there
       is  no slash. In	an assignment, multiple	tilde-prefixes can be used: at
       the beginning of	the word (that is, following the  equal	 sign  of  the
       assignment), following any unquoted colon or both. A tilde-prefix in an
       assignment is terminated	by the first unquoted colon or slash. If  none
       of the characters in the	tilde-prefix are quoted, the characters	in the
       tilde-prefix following the tilde	are treated as a possible  login  name
       from the	user database.

       A  portable  login name cannot contain characters outside the set given
       in the description of the LOGNAME environment variable.	If  the	 login
       name  is	 null (that is,	the tilde-prefix contains only the tilde), the
       tilde-prefix is replaced	by the value of	the variable HOME.  If HOME is
       unset,  the  results  are  unspecified.	Otherwise, the tilde-prefix is
       replaced	by a pathname of the home directory associated with the	 login
       name  obtained using the	getpwnam function. If the system does not rec-
       ognize the login	name, the results are undefined.

       Tilde expansion generally occurs	only at	the beginning of words,	but an
       exception based on historical practice has been included:

       PATH=/posix/bin:~dgk/bin

       is  eligible for	tilde expansion	because	tilde follows a	colon and none
       of the relevant characters is quoted. Consideration was given  to  pro-
       hibiting	this behavior because any of the following are reasonable sub-
       stitutes:

       PATH=$(printf %s	~karels/bin : ~bostic/bin)
       for Dir in ~maart/bin ~srb/bin .
       do
	    PATH=${PATH:+$PATH:}$Dir
       done

       With the	first command, explicit	colons are used	for each directory. In
       all cases, the shell performs tilde expansion on	each directory because
       all are separate	words to the shell.

       Expressions in operands such as:

       make -k mumble LIBDIR=~chet/lib

       do not qualify as shell variable	assignments and	tilde expansion	is not
       performed (unless the command does so itself, which make	does not).

       The  special sequence $~	has been designated for	future implementations
       to evaluate as a	means of forcing tilde expansion in any	word.

       Because of the requirement that the word	not be quoted,	the  following
       are not equivalent; only	the last causes	tilde expansion:

       \~hlj/	~h\lj/	 ~"hlj"/   ~hlj\/   ~hlj/

       The  results  of	 giving	tilde with an unknown login name are undefined
       because the KornShell ~+	and ~- constructs make use of this  condition,
       but,  in	 general  it  is an error to give an incorrect login name with
       tilde. The results of having HOME unset are  unspecified	 because  some
       historical shells treat this as an error.

   Command Substitution
       The  standard output from a command enclosed in parenthesis preceded by
       a dollar	sign (that is, $(command)) or a	pair of	grave accents (``) can
       be  used	 as  part or all of a word. Trailing new-lines are removed. In
       the second (archaic) form, the string between the quotes	 is  processed
       for  special  quoting  characters  before  the command is executed. See
       Quoting.	The command substitution $(cat file) can be  replaced  by  the
       equivalent  but	faster	$(<file). Command substitution of most special
       commands	that do	not perform input/output redirection are  carried  out
       without creating	a separate process.

       Command	substitution  allows the output	of a command to	be substituted
       in place	of the command name itself. Command substitution  occurs  when
       the command is enclosed as follows:

       $(command)

       or (backquoted version):

       `command`

       The  shell  expands  the	command	substitution by	executing command in a
       subshell	environment and	replacing the command substitution  (the  text
       of command plus the enclosing $() or backquotes)	with the standard out-
       put of the command, removing sequences of one or	more  newline  charac-
       ters at the end of the substitution. Embedded newline characters	before
       the end of the output is	not be removed;	however, they can  be  treated
       as field	delimiters and eliminated during field splitting, depending on
       the value of IFS	and quoting that is in effect.

       Within the backquoted style of command  substitution,  backslash	 shall
       retain its literal meaning, except when followed	by:

       $     `	   \

       (dollar-sign,  backquote, backslash). The search	for the	matching back-
       quote is	satisfied by the first backquote  found	 without  a  preceding
       backslash.  During  this	 search, if a non-escaped backquote is encoun-
       tered within a shell comment, a here-document, an embedded command sub-
       stitution of the	$(command) form, or a quoted string, undefined results
       occur. A	single-	or double-quoted string	that begins, but does not end,
       within the `...`	sequence produces undefined results.

       With the	$(command) form, all characters	following the open parenthesis
       to the matching closing parenthesis constitute the command.  Any	 valid
       shell script can	be used	for command, except:

	 o  A  script  consisting  solely of redirections produces unspecified
	    results.

	 o  See	the restriction	on single subshells.

       The results of command substitution are not field splitting  and	 path-
       name  expansion processed for further tilde expansion, parameter	expan-
       sion, command substitution or arithmetic	expansion. If a	 command  sub-
       stitution  occurs  inside  double-quotes, it is not be performed	on the
       results of the substitution.

       Command substitution can	be nested. To specify nesting within the back-
       quoted  version,	the application	must precede the inner backquotes with
       backslashes; for	example:

       `\`command\``

       The $() form of command substitution solves a problem  of  inconsistent
       behavior	when using backquotes. For example:

       +-----------------------------------------------------------+
       |	  Command			 Output		   |
       |echo '\$x'		      \$x			   |
       |echo `echo '\$x'`	      $x			   |
       |echo $(echo '\$x')	      \$x			   |
       +-----------------------------------------------------------+

       Additionally,  the backquoted syntax has	historical restrictions	on the
       contents	of the embedded	command. While the new $()  form  can  process
       any  kind  of  valid embedded script, the backquoted form cannot	handle
       some valid scripts that include backquotes. For example,	 these	other-
       wise valid embedded scripts do not work in the left column, but do work
       on the right:

       +-----------------------------------------------------------+
       |echo `			      echo $(			   |
       |cat <<eeof		      cat <<eeof		   |
       |a here-doc with	`	      a	here-doc with )		   |
       |eof			      eof			   |
       |`			      )				   |
       |echo `			      echo $(			   |
       |echo abc # a comment with `   echo abc # a comment with	)  |
       |`			      )				   |
       |echo `			      echo $(			   |
       |echo '`'		      echo ')'			   |
       |`			      )				   |
       +-----------------------------------------------------------+

       Because of these	inconsistent behaviors,	the backquoted variety of com-
       mand  substitution  is  not  recommended	for new	applications that nest
       command substitutions or	attempt	to embed complex scripts.

       If the command substitution consists of a single	subshell, such as:

       $( (command) )

       a portable application must separate the	$( and ( into two tokens (that
       is,  separate  them  with  white	 space). This is required to avoid any
       ambiguities with	arithmetic expansion.

   Arithmetic Expansion
       An arithmetic expression	enclosed in double parentheses preceded	 by  a
       dollar  sign ( $((arithmetic-expression)) ) is replaced by the value of
       the arithmetic expression within	 the  double  parenthesis.  Arithmetic
       expansion  provides a mechanism for evaluating an arithmetic expression
       and substituting	its value. The format for arithmetic expansion	is  as
       follows:

       $((expression))

       The expression is treated as if it were in double-quotes, except	that a
       double-quote inside the expression is not treated specially. The	 shell
       expands	all  tokens in the expression for parameter expansion, command
       substitution and	quote removal.

       Next, the shell treats this as an arithmetic expression and  substitute
       the  value  of  the  expression.	The arithmetic expression is processed
       according to the	rules of the ISO C with	the following exceptions:

	 o  Only integer arithmetic is required.

	 o  The	sizeof() operator and the prefix and postfix ++	and --	opera-
	    tors are not required.

	 o  Selection, iteration, and jump statements are not supported.

	 o  /usr/bin/ksh and /usr/bin/rksh treat prefix	0 through 9 as decimal
	    constants. See the following examples:

	    Command		   Result in /bin/ksh	Result in /usr/xpg4/bin/sh
	    echo $((010+10))	   20			18
	    echo $((019+10))	   29			error
	    [ 10 --le $((011)) ]   true			false

       As an extension,	the shell can recognize	arithmetic expressions	beyond
       those listed. If	the expression is invalid, the expansion fails and the
       shell writes a message to standard error	indicating the failure.

       A simple	example	using arithmetic expansion:

       # repeat	a command 100 times
       x=100
       while [ $x -gt 0	]
       do
	    command
	    x=$(($x-1))
       done

   Process Substitution
       This feature is available in SunOS and only on  versions	 of  the  UNIX
       operating  system  that	support	 the /dev/fd directory for naming open
       files. Each command argument  of	 the  form  <(list)  or	 >(list)  runs
       process list asynchronously connected to	some file in /dev/fd. The name
       of this file becomes the	argument to the	command. If the	form with > is
       selected,  then	writing	 on this file provides input for list. If < is
       used, then the file passed as an	argument contains the  output  of  the
       list process. For example:

       paste <(cut -f1 file1) <(cut -f3	file2) | tee >(process1) >(process2)

       cuts  fields  1	and  3	from  the files	file1 and file2, respectively,
       pastes the results together, and	sends it to the	processes process1 and
       process2,  as  well  as	putting	it onto	the standard output. The file,
       which is	passed as an argument to the command, is  a  UNIX  pipe(2)  so
       programs	that expect to lseek(2)	on the file does not work.

   Parameter Substitution
       A parameter is an identifier, one or more digits, or any	of the charac-
       ters *, @, #, ?,	-, $, and !. A variable	(a  parameter  denoted	by  an
       identifier)  has	 a value and zero or more attributes. variables	can be
       assigned	values and attributes by using the  typeset  special  command.
       The  attributes	supported  by  the  shell are described	later with the
       typeset special command.	Exported variables pass	values and  attributes
       to the environment.

       The  shell  supports a one-dimensional array facility. An element of an
       array variable is referenced by a subscript. A subscript	is denoted  by
       a  [, followed by an arithmetic expression, followed by a ]. See	Arith-
       metic Evaluation. To assign values to an	array, use set -A  name	 value
       ....  The  value	 of  all  subscripts must be in	the range of 0 through
       4095.  Arrays need not be declared. Any reference to a variable with  a
       valid  subscript	 is legal and an array is created if necessary.	Refer-
       encing an array without a subscript is equivalent  to  referencing  the
       element	0.  If an array	identifier with	subscript * or @ is used, then
       the value for each of the elements is substituted (separated by a field
       separator character).

       The value of a variable can be assigned by writing:

       name=value [ name=value ] ...

       If  the integer attribute, -i, is set for name, the value is subject to
       arithmetic evaluation.

       Positional parameters, parameters denoted by a number, can be  assigned
       values  with the	set special command. Parameter $0 is set from argument
       zero when the shell is invoked. If parameter is one or more digits then
       it  is  a positional parameter. A positional parameter of more than one
       digit must be enclosed in braces.

   Parameter Expansion
       The format for parameter	expansion is as	follows:

       ${expression}

       where expression	consists of all	characters until the matching }. Any }
       escaped	by  a  backslash  or within a quoted string, and characters in
       embedded	arithmetic  expansions,	 command  substitutions	 and  variable
       expansions, are not examined in determining the matching	}.

       The simplest form for parameter expansion is:

       ${parameter}

       The value, if any, of parameter is substituted.

       The  parameter  name  or	 symbol	 can  be enclosed in braces, which are
       optional	except for positional parameters with more than	one  digit  or
       when  parameter is followed by a	character that could be	interpreted as
       part of the name. The matching closing brace are	determined by counting
       brace levels, skipping over enclosed quoted strings and command substi-
       tutions.

       If the parameter	name or	symbol is not enclosed in braces,  the	expan-
       sion  uses the longest valid name whether or not	the symbol represented
       by that name exists. When the shell is scanning its input to  determine
       the  boundaries	of  a  name,  it is not	bound by its knowledge of what
       names are already defined.  For example,	if F is	a defined shell	 vari-
       able, the command:

       echo $Fred

       does  not  echo the value of $F followed	by red;	it selects the longest
       possible	valid name, Fred, which	in this	case might be unset.

       If a parameter expansion	occurs inside double-quotes:

	 o  Pathname expansion is not be  performed  on	 the  results  of  the
	    expansion.

	 o  Field  splitting is	not performed on the results of	the expansion,
	    with the exception of @.

       In addition, a parameter	expansion can be modified by using one of  the
       following  formats.  In each case that a	value of word is needed	(based
       on the state of parameter),  word  is  subjected	 to  tilde  expansion,
       parameter  expansion, command substitution and arithmetic expansion. If
       word is not needed, it is not expanded. The } character	that  delimits
       the  following  parameter  expansion  modifications  is	determined  as
       described previously in this  section  and  in  dquote.	(For  example,
       ${foo-bar}xyz}  would  result  in  the expansion	of foo followed	by the
       string xyz} if foo is set, else the string barxyz}).

       ${parameter:-word}      Use Default Values. If parameter	 is  unset  or
			       null,  the  expansion  of  word is substituted.
			       Otherwise, the value of	parameter  is  substi-
			       tuted.

       ${parameter:=word}      Assign Default Values. If parameter is unset or
			       null, the expansion  of	word  is  assigned  to
			       parameter.  In  all  cases,  the	final value of
			       parameter is substituted. Only  variables,  not
			       positional  parameters  or  special parameters,
			       can be assigned in this way.

       ${parameter:?[word]}    Indicate	Error if Null or Unset.	 If  parameter
			       is  unset  or null, the expansion of word (or a
			       message indicating it is	unset if word is omit-
			       ted) is written to standard error and the shell
			       exits with a non-zero exit  status.  Otherwise,
			       the  value  of  parameter  is  substituted.  An
			       interactive shell need not exit.

       ${parameter:+[word]}    Use Alternative Value. If parameter is unset or
			       null,   null  is	 substituted.  Otherwise,  the
			       expansion of word is substituted.

       In the parameter	expansions shown previously, use of the	colon  in  the
       format  results	in a test for a	parameter that is unset	or null. Omis-
       sion of the colon results in a test for a parameter that	is only	unset.
       The following two tables	summarize the effect of	the colon:

			   |				|
			   |parameter set and not null	|parameter set and null
       ${parameter:-word}  |substitute parameter	|substitute word
       ${parameter-word}   |substitute parameter	|substitute null
       ${parameter:=word}  |substitute parameter	|assign	word
       ${parameter=word}   |substitute parameter	|substitute parameter
       ${parameter:?word}  |substitute parameter	|error,	exit
       ${parameter?word}   |substitute parameter	|substitute null
       ${parameter:+word}  |substitute word		|substitute null
       ${parameter+word}   |substitute word		|substitute word

				    |
				    |parameter unset
       ${parameter:-word}	    |substitute	word
       ${parameter-word}	    |substitute	word
       ${parameter:=word}	    |assign word
       ${parameter=word}	    |assign null
       ${parameter:?word}	    |error, exit
       ${parameter?word}	    |error,exit
       ${parameter:+word}	    |substitute	null
       ${parameter+word}	    |substitute	null

       In  all	cases shown with "substitute", the expression is replaced with
       the value shown.	 In  all  cases	 shown	with  "assign",	 parameter  is
       assigned	that value, which also replaces	the expression.

       ${#parameter}	       String  Length. The length in characters	of the
			       value of	parameter. If parameter	 is  *	or  @,
			       then  all  the  positional parameters, starting
			       with $1,	are substituted	(separated by a	 field
			       separator character).

       The  following  four  varieties of parameter expansion provide for sub-
       string processing. In each case,	pattern	matching  notation  (see  pat-
       mat),  rather than regular expression notation, is used to evaluate the
       patterns. If parameter is * or @, then all the  positional  parameters,
       starting	with $1, are substituted (separated by a field separator char-
       acter). Enclosing the full parameter expansion string in	 double-quotes
       does not	cause the following four varieties of pattern characters to be
       quoted, whereas quoting characters within the braces has	this effect.

       ${parameter%word}       Remove Smallest Suffix  Pattern.	 The  word  is
			       expanded	 to  produce  a	pattern. The parameter
			       expansion then results in parameter,  with  the
			       smallest	 portion  of the suffix	matched	by the
			       pattern deleted.

       ${parameter%%word}      Remove Largest  Suffix  Pattern.	 The  word  is
			       expanded	 to  produce  a	pattern. The parameter
			       expansion then results in parameter,  with  the
			       largest	portion	 of  the suffix	matched	by the
			       pattern deleted.

       ${parameter#word}       Remove Smallest Prefix  Pattern.	 The  word  is
			       expanded	 to  produce  a	pattern. The parameter
			       expansion then results in parameter,  with  the
			       smallest	 portion  of the prefix	matched	by the
			       pattern deleted.

       ${parameter##word}      Remove Largest  Prefix  Pattern.	 The  word  is
			       expanded	 to  produce  a	pattern. The parameter
			       expansion then results in parameter,  with  the
			       largest	portion	 of  the prefix	matched	by the
			       pattern deleted.

       Examples:

       ${parameter:-word}

       In this example,	ls is executed only if x is null or unset. (The	 $(ls)
       command	substitution  notation	is  explained  in Command Substitution
       above.)

       ${x:-$(ls)}

       ${parameter:=word}

       unset X
       echo ${X:=abc}
       abc

       ${parameter:?word}

       unset posix
       echo ${posix:?}
       sh: posix: parameter null or not	set

       ${parameter:+word}

       set a b c
       echo ${3:+posix}
       posix

       ${#parameter}

       HOME=/usr/posix
       echo ${#HOME}
       10

       ${parameter%word}

       x=file.c
       echo ${x%.c}.o
       file.o

       ${parameter%%word}

       x=posix/src/std
       echo ${x%%/*}
       posix

       ${parameter#word}

       x=$HOME/src/cmd
       echo ${x#$HOME}
       /src/cmd

       ${parameter##word}

       x=/one/two/three
       echo ${x##*/}
       three

   Parameters Set by Shell
       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.

       ?	       The  decimal  value  returned by	the last executed com-
		       mand.

       $	       The process number of this shell.

       _	       Initially, the value of _ is an	absolute  pathname  of
		       the  shell  or  script  being executed as passed	in the
		       environment. Subsequently it is assigned	the last argu-
		       ment of the previous command. This parameter is not set
		       for commands which are asynchronous. This parameter  is
		       also  used  to  hold the	name of	the matching MAIL file
		       when checking for mail.

       !	       The process  number  of	the  last  background  command
		       invoked.

       ERRNO	       The  value  of errno as set by the most recently	failed
		       system call. This value	is  system  dependent  and  is
		       intended	for debugging purposes.

       LINENO	       The  line  number of the	current	line within the	script
		       or function being executed.

       OLDPWD	       The previous working directory set by the cd command.

       OPTARG	       The value of the	last option argument processed by  the
		       getopts special command.

       OPTIND	       The  index of the last option argument processed	by the
		       getopts special command.

       PPID	       The process number of the parent	of the shell.

       PWD	       The present working directory set by the	cd command.

       RANDOM	       Each time this variable is referenced, a	 random	 inte-
		       ger, uniformly distributed between 0 and	32767, is gen-
		       erated. The sequence of random numbers can be  initial-
		       ized by assigning a numeric value to RANDOM.

       REPLY	       This variable is	set by the select statement and	by the
		       read special command when no arguments are supplied.

       SECONDS	       Each time this variable is referenced,  the  number  of
		       seconds	since  shell  invocation  is returned. If this
		       variable	is assigned a value, then the  value  returned
		       upon  reference is the value that was assigned plus the
		       number of seconds since the assignment.

   Variables Used by Shell
       The following variables are used	by the shell:

       CDPATH	       The search path for the cd command.

       COLUMNS	       If this variable	is set,	the value is  used  to	define
		       the  width  of the edit window for the shell edit modes
		       and for printing	select lists.

       EDITOR	       If the value of this variable ends in emacs, gmacs,  or
		       vi  and the VISUAL variable is not set, then the	corre-
		       sponding	option is turned on. See the set special  com-
		       mand.

       ENV	       This  variable, when and	only when an interactive shell
		       is invoked, is subjected	to parameter expansion by  the
		       shell  and the resulting	value is used as a pathname of
		       a file containing shell commands	  to  execute  in  the
		       current	environment.  The file need not	be executable.
		       If the expanded value of	ENV is not an  absolute	 path-
		       name,  the  results  are	unspecified. ENV is ignored if
		       the user's real and effective  user  IDs	 or  real  and
		       effective group IDs are different.

		       This  variable  can  be	used  to set aliases and other
		       items local to the invocation  of  a  shell.  The  file
		       referred	to by ENV differs from $HOME/.profile  in that
		       .profile	is  typically  executed	 at  session  startup,
		       whereas	the  ENV  file is executed at the beginning of
		       each shell invocation. The ENV value is interpreted  in
		       a  manner similar to a dot script, in that the commands
		       are executed in the current environment	and  the  file
		       needs  to  be  readable,	 but  not executable. However,
		       unlike dot scripts, no  PATH  searching	is  performed.
		       This  is	 used as a guard against Trojan	Horse security
		       breaches.

       FCEDIT	       The default editor name for the fc command.

       FPATH	       The search path for function definitions.  By  default,
		       the FPATH directories are searched after	the PATH vari-
		       able. If	an executable file is found, then it  is  read
		       and  executed  in  the  current	environment.  FPATH is
		       searched	before	PATH  when  a  function	 with  the  -u
		       attribute  is  referenced.  The	preset	alias autoload
		       causes a	function with the -u attribute to be  created.

       HISTFILE	       If this variable	is set when the	shell is invoked, then
		       the value is the	pathname of the	file that is  used  to
		       store the command history. See Command re-entry.

       HISTSIZE	       If this variable	is set when the	shell is invoked, then
		       the number of  previously  entered  commands  that  are
		       accessible  by  this  shell is greater than or equal to
		       this number. The	default	is 128.

       HOME	       The default argument (home directory) for the  cd  com-
		       mand.

       IFS	       Internal	 field	separators,  normally  space, tab, and
		       new-line	that are used to separate command words	 which
		       result  from  command or	parameter substitution and for
		       separating words	with the  special  command  read.  The
		       first character of the IFS variable is used to separate
		       arguments for the $* substitution. See Quoting.

       LANG	       Provide a default value	for  the  internationalization
		       variables  that are unset or null. If any of the	inter-
		       nationalization variables contains an invalid  setting,
		       the  utility  behaves  as  if none of the variables had
		       been defined.

       LC_ALL	       This variable provides a	default	 value	for  the  LC_*
		       variables.

       LC_COLLATE      This  variable determines the behavior of range expres-
		       sions, equivalence  classes  and	 multi-byte  character
		       collating elements within pattern matching.

       LC_CTYPE	       Determines  how	the  shell  handles  characters.  When
		       LC_CTYPE	is set to a valid value, the shell can display
		       and  handle text	and filenames containing valid charac-
		       ters for	that locale. If	LC_CTYPE (see  environ(5))  is
		       not set in the environment, the operational behavior of
		       the shell is determined by the value of the LANG	 envi-
		       ronment	variable.  If  LC_ALL is set, its contents are
		       used to override	both the LANG and the other LC_* vari-
		       ables.

       LC_MESSAGES     This variable determines	the language in	which messages
		       should be written.

       LINENO	       This variable is	set by the shell to a  decimal	number
		       representing  the  current sequential line number (num-
		       bered starting with 1)  within  a  script  or  function
		       before  it executes each	command. If the	user unsets or
		       resets LINENO, the variable can lose its	special	 mean-
		       ing for the life	of the shell. If the shell is not cur-
		       rently executing	a script or  function,	the  value  of
		       LINENO is unspecified.

       LINES	       If this variable	is set,	the value is used to determine
		       the column length for  printing	select	lists.	Select
		       lists  print vertically until about two-thirds of LINES
		       lines are filled.

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

       MAILCHECK       This  variable  specifies  how  often  (in seconds) the
		       shell checks for	changes	in the	modification  time  of
		       any  of	the  files  specified  by the MAILPATH or MAIL
		       variables. The default value is 600 seconds.  When  the
		       time  has  elapsed  the shell checks before issuing the
		       next prompt.

       MAILPATH	       A colon (:) separated list of file names. If this vari-
		       able  is	 set,  then  the shell informs the user	of any
		       modifications to	the specified files that have occurred
		       within  the  last MAILCHECK seconds. Each file name can
		       be followed by a	? and a	message	that is	 printed.  The
		       message undergoes parameter substitution	with the vari-
		       able $_ defined as  the	name  of  the  file  that  has
		       changed.	The default message is you have	mail in	$_.

       NLSPATH	       Determine  the  location	 of message catalogues for the
		       processing of LC_MESSAGES.

       PATH	       The search path for commands. See Execution.  The  user
		       cannot  change  PATH if executing under rksh (except in
		       .profile).

       PPID	       This variable is	 set  by  the  shell  to  the  decimal
		       process	ID of the process that invoked the shell. In a
		       subshell, PPID is set to	the same value as that of  the
		       parent  of  the	current	shell. For example, echo $PPID
		       and (echo $PPID)	would produce the same value.

       PS1	       The value of this variable is  expanded	for  parameter
		       substitution  to	define the primary prompt string which
		       by default is ``$ ''. The character !  in  the  primary
		       prompt  string  is  replaced by the command number. See
		       Command Re-entry. Two successive	occurrences of !  pro-
		       duces a single !	when the prompt	string is printed.

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

       PS3	       Selection  prompt  string used within a select loop, by
		       default ``#? ''.

       PS4	       The value of this variable is  expanded	for  parameter
		       substitution  and  precedes  each  line of an execution
		       trace. If omitted, the execution	trace  prompt  is  ``+
		       ''.

       PWD		Set  by	 the  shell  to	be an absolute pathname	of the
		       current working directory, containing no	components  of
		       type  symbolic link, no components that are dot,	and no
		       components that are dot-dot when	the shell is  initial-
		       ized.  If  an  application  sets	or unsets the value of
		       PWD, the	behaviors of the  cd  and  pwd	utilities  are
		       unspecified

       SHELL	       The  pathname  of the shell is kept in the environment.
		       At invocation, if the basename of this variable is rsh,
		       rksh, or	krsh, then the shell becomes restricted.

       TMOUT	       If  set	to a value greater than	zero, the shell	termi-
		       nates if	a command is not entered within	the prescribed
		       number  of  seconds  after  issuing the PS1 prompt. The
		       shell can be compiled with a  maximum  bound  for  this
		       value which cannot be exceeded.

       VISUAL	       If  the value of	this variable ends in emacs, gmacs, or
		       vi, then	the corresponding option  is  turned  on.  See
		       Special Command set.

       The  shell gives	default	values to PATH,	PS1, PS2, PS3, PS4, MAILCHECK,
       FCEDIT, TMOUT, and IFS, while HOME, SHELL, ENV, and MAIL	are not	set at
       all  by	the  shell (although HOME is set by login(1)). On some systems
       MAIL and	SHELL are also set by login.

   Blank Interpretation
       After parameter and command substitution, the results of	 substitutions
       are scanned for the 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.

   File	Name Generation
       Following substitution, each command word is scanned for	the characters
       *,  ?, and [ unless the -f option has been set. If one of these charac-
       ters appears, the word is regarded as a pattern.	The word  is  replaced
       with  lexicographically sorted file names that match the	pattern. If no
       file name  is  found  that  matches  the	 pattern,  the	word  is  left
       unchanged. When a pattern is used for file name generation, the charac-
       ter period (.) at the start of a	file name or immediately  following  a
       /,  as  well  as	 the character / itself, must be matched explicitly. A
       file name beginning with	a period is not	matched	with  a	 pattern  with
       the  period  inside parentheses.	That is, ls .@(r*) would locate	a file
       named .restore, but ls @(.r*) would not.	In other instances of  pattern
       matching, the / and . are not treated specially.

       *	       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	 lexi-
		       cally between the pair, inclusive. If the first charac-
		       ter following the opening "[" is	a "! ",	then any char-
		       acter  not  enclosed is matched.	A - can	be included in
		       the character set by putting it as the  first  or  last
		       character.

       A  pattern-list	is  a list of one or more patterns separated from each
       other with a |. Composite patterns can be formed	with one  or  more  of
       the following:

       ?(pattern-list)	       Optionally  matches  any	 one of	the given pat-
			       terns.

       *(pattern-list)	       Matches zero or more occurrences	of  the	 given
			       patterns.

       +(pattern-list)	       Matches	one  or	 more occurrences of the given
			       patterns.

       @(pattern-list)	       Matches exactly one of the given	patterns.

       !(pattern-list)	       Matches anything, except	one of the given  pat-
			       terns.

   Quoting
       Each of the metacharacters listed above (see Definitions) has a special
       meaning to the shell and	causes termination of a	word unless quoted.  A
       character  can be quoted	(that is, made to stand	for itself) by preced-
       ing it with a \.	The pair \NEWLINE is removed. All characters  enclosed
       between	a pair of single quote marks ( ' ') are	quoted.	A single quote
       cannot appear within single quotes. Inside  double  quote  marks	 (""),
       parameter and command substitution occur	and \ quotes the characters \,
       `, ", and $. The	meaning	of $* and $@ is	identical when not  quoted  or
       when  used  as a	parameter assignment value or as a file	name. However,
       when used as a command argument,	$*  is	equivalent  to	``$1d$2d...'',
       where  d	 is  the  first	 character  of the IFS variable, whereas $@ is
       equivalent to $1	$2 ....	 Inside	grave quote marks (``),	\  quotes  the
       characters \, ',	and $. If the grave quotes occur within	double quotes,
       then \ also quotes the character	".

       The special meaning of reserved words or	 aliases  can  be  removed  by
       quoting any character of	the reserved word. The recognition of function
       names or	special	command	names listed  cannot  be  altered  by  quoting
       them.

   Arithmetic Evaluation
       An  ability  to perform integer arithmetic is provided with the special
       command let. Evaluations	are performed using long arithmetic. Constants
       are  of the form	[ base#	] n where base is a decimal number between two
       and thirty-six representing the arithmetic base and n is	 a  number  in
       that base. If base is omitted then base 10 is used.

       An arithmetic expression	uses the same syntax, precedence, and associa-
       tivity of expression as the C language.	All  the  integral  operators,
       other than ++, -;, ?:, and , are	supported. Variables can be referenced
       by name within an arithmetic expression	without	 using	the  parameter
       substitution syntax. When a variable is referenced, its value is	evalu-
       ated as an arithmetic expression.

       An internal integer representation of a variable	can be specified  with
       the  -i option of the typeset special command. Arithmetic evaluation is
       performed on the	value of each assignment to a  variable	 with  the  -i
       attribute.  If you do not specify an arithmetic base, the first assign-
       ment to the variable determines the arithmetic base. This base is  used
       when parameter substitution occurs.

       Since  many of the arithmetic operators require quoting,	an alternative
       form of the let command is provided. For	any command which begins  with
       a  ((,  all  the	characters until a matching )) are treated as a	quoted
       expression. More	precisely, ((...)) is equivalent to let	"...".

   Prompting
       When used interactively,	the shell prompts with the parameter  expanded
       value  of  PS1  before  reading a command. If at	any time a new-line is
       typed and further input is needed to complete a command,	then the  sec-
       ondary prompt (that is, the value of PS2) is issued.

   Conditional Expressions
       A  conditional  expression is used with the [[ compound command to test
       attributes of files and to compare strings.  Word  splitting  and  file
       name  generation	are not	performed on the words between [[ and ]]. Each
       expression can be constructed from one or more of the  following	 unary
       or binary expressions:

       -a file		       True, if	file exists.

       -b file		       True,  if  file	exists	and is a block special
			       file.

       -c file		       True, if	file exists and	is a character special
			       file.

       -d file		       True, if	file exists and	is a directory.

       -e file		       True, if	file exists.

       -f file		       True, if	file exists and	is an ordinary file.

       -g file		       True,  if  file	exists	and has	its setgid bit
			       set.

       -h file		       True, if	file exists and	is a symbolic link.

       -k file		       True, if	file exists and	 has  its  sticky  bit
			       set.

       -n string	       True, if	length of string is non-zero.

       -o option	       True, if	option named option is on.

       -p file		       True, if	file exists and	is a fifo special file
			       or a pipe.

       -r file		       True, if	file exists and	is readable by current
			       process.

       -s file		       True,  if file exists and has size greater than
			       zero.

       -t fildes	       True, if	file descriptor	number fildes is  open
			       and associated with a terminal device.

       -u file		       True,  if  file	exists	and has	its setuid bit
			       set.

       -w file		       True, if	file exists and	is writable by current
			       process.

       -x file		       True,  if file exists and is executable by cur-
			       rent process. If	file exists and	 is  a	direc-
			       tory,  then  the	current	process	has permission
			       to search in the	directory.

       -z string	       True, if	length of string is zero.

       -L file		       True, if	file exists and	is a symbolic link.

       -O file		       True, if	file exists and	is owned by the	effec-
			       tive user id of this process.

       -G file		       True,  if file exists and its group matches the
			       effective group id of this process.

       -S file		       True, if	file exists and	is a socket.

       file1 -nt file2	       True, if	file1 exists and is newer than	file2.

       file1 -ot file2	       True,  if file1 exists and is older than	file2.

       file1 -ef file2	       True, if	file1 and file2	exist and refer	to the
			       same file.

       string		       True  if	 the  string  string  is  not the null
			       string.

       string =	pattern	       True, if	string matches pattern.

       string != pattern       True, if	string does not	match pattern.

       string1 < string2       True, if	string1	comes before string2 based  on
			       strings	 interpreted  as  appropriate  to  the
			       locale setting for category LC_COLLATE.

       string1 > string2       True, if	string1	comes after string2  based  on
			       strings	 interpreted  as  appropriate  to  the
			       locale setting for category LC_COLLATE.

       exp1 -eq	 exp2	       True, if	exp1 is	equal to exp2.

       exp1 -ne	exp2	       True, if	exp1 is	not equal to exp2.

       exp1 -lt	exp2	       True, if	exp1 is	less than exp2.

       exp1 -gt	exp2	       True, if	exp1 is	greater	than exp2.

       exp1 -le	exp2	       True, if	exp1 is	less than or equal to exp2.

       exp1 -ge	exp2	       True, if	exp1 is	greater	than or	equal to exp2.

       In  each	 of  the  above	expressions, if	file is	of the form /dev/fd/n,
       where n is an integer, then the test is applied to the open file	 whose
       descriptor number is n.

       A compound expression can be constructed	from these primitives by using
       any of the following, listed in decreasing order	of precedence.

       (expression)		       True, if	expression is  true.  Used  to
				       group expressions.

       ! expression		       True if expression is false.

       expression1 && expression2      True,  if  expression1  and expression2
				       are both	true.

       expression1 || expression2      True, if	either expression1 or  expres-
				       sion2 is	true.

   Input/Output
       Before  a  command  is executed,	its input and output can be redirected
       using a special notation	interpreted by the shell.  The	following  can
       appear  anywhere	in a simple-command or can precede or follow a command
       and are not passed on to	the invoked  command.  Command	and  parameter
       substitution  occur  before word	or digit is used except	as noted. File
       name generation occurs only if the pattern matches a single  file,  and
       blank interpretation is not performed.

       <word		       Use  file word as standard input	(file descrip-
			       tor 0).

       >word		       Use file	word as	standard output	(file descrip-
			       tor  1).	 If the	file does not exist then it is
			       created.	If the file exists, and	the  noclobber
			       option  is on, this causes an error; otherwise,
			       it is truncated to zero length.

       >|word		       Sames  as  >,  except  that  it	overrides  the
			       noclobber option.

       >>word		       Use  file  word as standard output. If the file
			       exists, output is  appended  to	it  (by	 first
			       seeking	to  the	 EOF).	Otherwise, the file is
			       created.

       <>word		       Open file word for reading and writing as stan-
			       dard input.

       << [-]word	       The  shell  input  is read up to	a line that is
			       the same	as word, or to an  EOF.	 No  parameter
			       substitution,  command  substitution,  or  file
			       name  generation	 is  performed	on  word.  The
			       resulting  document,  called  a	here-document,
			       becomes the standard input. If any character of
			       word  is	 quoted,  no  interpretation is	placed
			       upon the	characters of  the  document.	Other-
			       wise, parameter and command substitution	occur,
			       \NEWLINE	is ignored, and	 \  must  be  used  to
			       quote  the  characters  \,  $, `, and the first
			       character of word. If - is appended to <<, then
			       all  leading  tabs  are	stripped from word and
			       from the	document.

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

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

       <&p		       The input from the co-process is	moved to stan-
			       dard input.

       >&p		       The output to the co-process is moved to	 stan-
			       dard output.

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

       ... 2>&1

       means  file  descriptor 2 is to be opened for writing as	a duplicate of
       file descriptor 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.

       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.

   Environment
       The environment (see environ(5))	is a list of name-value	pairs that  is
       passed  to  an  executed	 program  in the same way as a normal argument
       list. The names must  be	 identifiers  and  the	values	are  character
       strings.	 The shell interacts with the environment in several ways.  On
       invocation, the shell scans the environment and creates a variable  for
       each  name  found,  giving  it  the  corresponding value	and marking it
       export. Executed	commands inherit the environment. If the user modifies
       the  values of these variables or creates new ones, using the export or
       typeset -x commands, they become	part of	the environment. The  environ-
       ment  seen  by  any executed command is thus composed of	any name-value
       pairs originally	inherited by the shell,	whose values can  be  modified
       by  the current shell, plus any additions which must be noted in	export
       or typeset -x commands.

       The environment for any simple-command or function can be augmented  by
       prefixing  it with one or more variable assignments. A variable assign-
       ment argument is	a word of the form identifier=value. Thus:

       TERM=450	cmd args

       and

       (export TERM; TERM=450; cmd args)

       are equivalent (as far as the above  execution  of  cmd	is  concerned,
       except for special commands listed that are preceded with an asterisk).

       If the -k flag is set, all variable assignment arguments	are placed  in
       the environment,	even if	they occur after the command name. The follow-
       ing first prints	a=b c and then c:

       echo a=b	c
       set -k echo
       a=b c

       This feature is intended	for use	with scripts written  for  early  ver-
       sions  of the shell and its use in new scripts is strongly discouraged.
       It is likely to disappear someday.

   Functions
       The function reserved word, described in	the Commands section above, is
       used  to	define shell functions.	Shell functions	are read in and	stored
       internally. Alias names are resolved when the function is  read.	 Func-
       tions  are  executed  like  commands with the arguments passed as posi-
       tional parameters. See Execution.

       Functions execute in the	same process as	the caller and share all files
       and  present  working  directory	 with  the caller. Traps caught	by the
       caller are reset	to their default action	inside the  function.  A  trap
       condition  that	is  not	 caught	 or ignored by the function causes the
       function	to terminate and the condition to be passed on to the  caller.

       A  trap	on  EXIT  set inside a function	is executed after the function
       completes in the	environment of the caller. This	is true	only for  non-
       POSIX-style functions, that is, functions declared as

       function	func

       as opposed to POSIX-style functions, declared as

       func()

       Ordinarily,  variables  are  shared between the calling program and the
       function. However, the typeset special command used within  a  function
       defines	local  variables whose scope includes the current function and
       all functions it	calls.

       The special command return is  used  to	return	from  function	calls.
       Errors within functions return control to the caller.

       The  names  of  all  functions can be listed with typeset+f. typeset -f
       lists all function names	as well	as the text of all functions.  typeset
       -f function-names lists the text	of the named functions only. Functions
       can be undefined	with the -f option of the unset	special	command.

       Ordinarily, functions are unset when the	shell executes a shell script.
       The  -xf	option of the typeset command allows a function	to be exported
       to scripts that are executed  without  a	 separate  invocation  of  the
       shell. Functions	that need to be	defined	across separate	invocations of
       the shell should	be specified in	the ENV	file with the  -xf  option  of
       typeset.

   Function Definition Command
       A  function  is a user-defined name that	is used	as a simple command to
       call a compound command with new	positional parameters. A  function  is
       defined with a function definition command.

       The format of a function	definition command is as follows:

       fname() compound-command[io-redirect ...]

       The  function  is named fname; it must be a name. An implementation can
       allow other characters in a function name as an extension.  The	imple-
       mentation maintains separate name spaces	for functions and variables.

       The  ()	in  the	function definition command consists of	two operators.
       Therefore, intermixing blank characters with the	fname,	(,  and	 )  is
       allowed,	but unnecessary.

       The argument compound-command represents	a compound command.

       When  the  function  is	declared, none of the expansions in wordexp is
       performed on the	text in	compound-command or  io-redirect;  all	expan-
       sions  is  performed  as	normal each time the function is called. Simi-
       larly, the optional io-redirect redirections and	any  variable  assign-
       ments  within compound-command is performed during the execution	of the
       function	itself,	not the	function definition.

       When a function is executed, it	has  the  syntax-error	and  variable-
       assignment properties described for the special built-in	utilities.

       The  compound-command  is executed whenever the function	name is	speci-
       fied as the name	of a simple command The	operands to the	command	tempo-
       rarily  becomes	the  positional	parameters during the execution	of the
       compound-command; the special parameter # is also  changed  to  reflect
       the  number of operands.	The special parameter 0	is unchanged. When the
       function	completes, the values of the  positional  parameters  and  the
       special parameter # is restored to the values they had before the func-
       tion was	executed.  If the special built-in return is executed  in  the
       compound-command, the function completes	and execution resumes with the
       next command after the function call.

       An example of how a function definition can be used wherever  a	simple
       command is allowed:

       # If variable i is equal	to "yes",
       # define	function foo to	be ls -l
       #
       [ "$i" =	yes ] && foo() {
	     ls	-l
       }

       The  exit  status  of  a	 function  definition is 0 if the function was
       declared	successfully; otherwise, it is greater	than  zero.  The  exit
       status  of a function invocation	is the exit status of the last command
       executed	by the function.

   Jobs
       If the monitor option of	the set	command	is turned on,  an  interactive
       shell associates	a job with each	pipeline.
	It  keeps  a  table  of	current	jobs, printed by the jobs command, and
       assigns them small  integer  numbers.  When  a  job  is	started	 asyn-
       chronously with &, the shell prints a line which	looks like:

       [1] 1234

       indicating that the job,	which was started asynchronously, was job num-
       ber 1 and had one (top-level) process, whose process id was 1234.

       If you are running a job	and wish to do something else  you  can	 press
       the  key	 ^Z  (Control-Z) which sends a STOP signal to the current job.
       The shell normally indicates that the job has been `Stopped', and print
       another	prompt.	You can	then manipulate	the state of this job, putting
       it in the background with the bg	command, or run	 some  other  commands
       and  then  eventually  bring  the job back into the foreground with the
       foreground command fg. A	^Z takes effect	immediately  and  is  like  an
       interrupt in that pending output	and unread input are discarded when it
       is typed.

       A job being run in the background stops if it tries to  read  from  the
       terminal.  Background  jobs are normally	allowed	to produce output, but
       this can	be disabled by giving the command "stty	tostop".  If  you  set
       this  tty  option,  then	 background jobs stop when they	try to produce
       output as they do when they try to read input.

       There are several ways to refer to jobs in the  shell.  A  job  can  be
       referred	 to  by	 the process id	of any process of the job or by	one of
       the following:

       %number	       The job with the	given number.

       %string	       Any job whose command line begins with string.

       %?string	       Any job whose command line contains string.

       %%	       Current job.

       %+	       Equivalent to %%.

       %-	       Previous	job.

       The shell learns	immediately whenever a process changes state. It  nor-
       mally  informs  you  whenever  a	job becomes blocked so that no further
       progress	is possible, but only just before it prints a prompt. This  is
       done so that it does not	otherwise disturb your work.

       When  the  monitor mode is on, each background job that completes trig-
       gers any	trap set for CHLD.

       When you	try to leave the shell while jobs are running or stopped,  you
       are  warned with	the message, `You have stopped(running)	jobs.' You can
       use the jobs command to see what	they are. If you do  this  or  immedi-
       ately try to exit again,	the shell does not warn	you a second time, and
       the stopped jobs	is terminated. If you have jobs	running	for which  the
       nohup  command  was  invoked and	attempt	to logout, you are warned with
       the message:

       You have	jobs running.

       You need	to logout a second time	 to  actually  logout.	However,  your
       background jobs continue	to run.

   Signals
       The INT and QUIT	signals	for an invoked command are ignored if the com-
       mand is followed	by & and the monitor option is not active.  Otherwise,
       signals have the	values inherited by the	shell from its parent. See the
       trap special command section.

   Execution
       Each time a command is executed,	the above  substitutions  are  carried
       out. If the command name	matches	one of the Special Commands listed, it
       is executed within the current shell process. Next, the command name is
       checked	to  see	if it matches one of the user defined functions. If it
       does, the positional parameters are saved and then reset	to  the	 argu-
       ments  of  the  function	 call. When the	function completes or issues a
       return, the positional parameter	list is	restored and any trap  set  on
       EXIT  within  the  function is executed.	The value of a function	is the
       value of	the last command executed. A function is also executed in  the
       current	shell process. If a command name is not	a special command or a
       user defined function, a	process	is created and an attempt is  made  to
       execute the command using exec(2).

       The  shell variable PATH	defines	the search path	for the	directory con-
       taining the command. Alternative	directory names	 are  separated	 by  a
       colon  (:).  The	 default  path	is  /bin:/usr/bin:  (specifying	 /bin,
       /usr/bin, and the current directory in that order). The current	direc-
       tory  can be specified by two or	more adjacent colons, or by a colon at
       the beginning or	end of 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  a	directory or an	a.out file, it is assumed to be	a file
       containing shell	commands. A sub-shell is spawned to read it. All  non-
       exported	 aliases, functions, and variables are removed in this case. A
       parenthesized command is	executed in a sub-shell	without	removing  non-
       exported	quantities.

   Command Re-entry
       The  text  of  the  last	HISTSIZE (default 128) commands	entered	from a
       terminal	device is saved	in a history file. The file  $HOME/.sh_history
       is  used	if the HISTFILE	variable is not	set or if the file it names is
       not writable. A shell can access	the commands of	all interactive	shells
       which  use  the	same named HISTFILE. The special command fc is used to
       list or edit a portion of this file. The	portion	 of  the  file	to  be
       edited or listed	can be selected	by number or by	giving the first char-
       acter or	characters of the command. A single command or range  of  com-
       mands  can  be specified. If you	do not specify an editor program as an
       argument	to fc then the value of	the variable FCEDIT is used. If	FCEDIT
       is  not defined,	then /bin/ed is	used. The edited command(s) is printed
       and re-executed upon leaving the	editor.	The editor name	- is  used  to
       skip  the  editing  phase and to	re-execute the command.	In this	case a
       substitution parameter of the form old=new can be used  to  modify  the
       command	before	execution.   For example, if r is aliased to 'fc -e -'
       then typing 'r bad=good c' re-executes the most	recent	command	 which
       starts  with the	letter c, replacing the	first occurrence of the	string
       bad with	the string good.

   In-line Editing Option
       Normally, each command line entered from	a terminal  device  is	simply
       typed followed by a new-line (RETURN or LINEFEED). If either the	emacs,
       gmacs, or vi option is active, the user can edit	the command  line.  To
       be in either of these edit modes	set the	corresponding option. An edit-
       ing option is automatically selected each time  the  VISUAL  or	EDITOR
       variable	is assigned a value ending in either of	these option names.

       The  editing features require that the user's terminal accept RETURN as
       carriage	return without line feed and that a space must	overwrite  the
       current character on the	screen.

       The editing modes implement a concept where the user is looking through
       a window	at the current line. The window	width is the value of  COLUMNS
       if  it  is  defined,  otherwise 80. If the window width is too small to
       display the prompt and leave at least 8 columns	to  enter  input,  the
       prompt  is truncated from the left. If the line is longer than the win-
       dow width minus two, a mark is displayed	at the end of  the  window  to
       notify  the user. As the	cursor moves and reaches the window boundaries
       the window are centered about the cursor. The mark is a > if  the  line
       extends	on  the	right side of the window, < if the line	extends	on the
       left, and * if the line extends on both sides of	the window.

       The search commands in each edit	mode provide  access  to  the  history
       file.  Only strings are matched,	not patterns, although a leading caret
       (^) in the string restricts the match to	begin at the  first  character
       in the line.

   emacs Editing Mode
       This  mode is entered by	enabling either	the emacs or gmacs option. The
       only difference between these two modes is the way they handle  ^T.  To
       edit,  move  the	cursor to the point needing correction and then	insert
       or delete characters or words as	needed.	All the	editing	 commands  are
       control	characters or escape sequences.	The notation for control char-
       acters is caret ( ^ ) followed by the character.	For example, ^F	is the
       notation	for control F. This is entered by depressing `f' while holding
       down the	CTRL (control) key. The	SHIFT key is not depressed. (The nota-
       tion ^?	indicates the DEL (delete) key.)

       The  notation  for  escape sequences is M- followed by a	character. For
       example,	M-f (pronounced	Meta f)	is entered by  depressing  ESC	(ascii
       033)  followed  by  `f'.	(M-F would be the notation for ESC followed by
       SHIFT (capital) `F'.)

       All edit	commands operate from any place	on the line (not just  at  the
       beginning).  Neither  the  RETURN nor the LINEFEED key is entered after
       edit commands except when noted.

       ^F	       Move cursor forward (right) one character.

       M-f	       Move cursor forward one word. (The emacs	editor's  idea
		       of  a word is a string of characters consisting of only
		       letters,	digits and underscores.)

       ^B	       Move cursor backward (left) one character.

       M-b	       Move cursor backward one	word.

       ^A	       Move cursor to start of line.

       ^E	       Move cursor to end of line.

       ^]char	       Move cursor forward to character	char on	current	 line.

       M-^]char	       Move cursor backward to character char on current line.

       ^X^X	       Interchange the cursor and mark.

       erase	       (User defined erase character as	defined	by the stty(1)
		       command,	 usually ^H or #.)  Delete previous character.

       ^D	       Delete current character.

       M-d	       Delete current word.

       M-^H	       (Meta-backspace)	Delete previous	word.

       M-h	       Delete previous word.

       M-^?	       (Meta-DEL) Delete  previous  word  (if  your  interrupt
		       character  is  ^?  (DEL,	the default) then this command
		       does not	work).

       ^T	       Transpose current  character  with  next	 character  in
		       emacs  mode. Transpose two previous characters in gmacs
		       mode.

       ^C	       Capitalize current character.

       M-c	       Capitalize current word.

       M-l	       Change the current word to lower	case.

       ^K	       Delete from the cursor to the end of the	line. If  pre-
		       ceded by	a numerical parameter whose value is less than
		       the current cursor position,  then  delete  from	 given
		       position	 up  to	the cursor. If preceded	by a numerical
		       parameter whose value is	greater	than the current  cur-
		       sor  position, then delete from cursor up to given cur-
		       sor position.

       ^W	       Kill from the cursor to the mark.

       M-p	       Push the	region from the	cursor	to  the	 mark  on  the
		       stack.

       kill	       (User  defined kill character as	defined	by the stty(1)
		       command,	usually	^G or @.)   Kill  the  entire  current
		       line. If	two kill characters are	entered	in succession,
		       all kill	characters from	then  on  cause	 a  line  feed
		       (useful when using paper	terminals).

       ^Y	       Restore last item removed from line. (Yank item back to
		       the line.)

       ^L	       Line feed and print current line.

       ^@	       (null character)	Set mark.

       M-space	       (Meta space) Set	mark.

       J	       (New line) Execute the current line.

       M	       (Return)	Execute	the current line.

       eof	       End-of-file character, normally ^D, is processed	as  an
		       End-of-file only	if the current line is null.

       ^P	       Fetch  previous	command.  Each	time ^P	is entered the
		       previous	command	back in	time is	accessed.  Moves  back
		       one  line  when	not  on	the first line of a multi-line
		       command.

       M-<	       Fetch the least recent (oldest) history line.

       M->	       Fetch the most recent (youngest)	history	line.

       ^N	       Fetch next command line.	Each time ^N  is  entered  the
		       next command line forward in time is accessed.

       ^Rstring	       Reverse search history for a previous command line con-
		       taining string. If a parameter of zero  is  given,  the
		       search  is forward. string is terminated	by a RETURN or
		       NEW LINE. If string is preceded by  a  ^,  the  matched
		       line must begin with string. If string is omitted, then
		       the next	command	line containing	the most recent	string
		       is  accessed. In	this case a parameter of zero reverses
		       the direction of	the search.

       ^O	       Operate.	Execute	the current line and  fetch  the  next
		       line relative to	current	line from the history file.

       M-digits	       (Escape)	Define numeric parameter, the digits are taken
		       as a parameter to the next command. The	commands  that
		       accept  a  parameter are	^F, ^B,	erase, ^C, ^D, ^K, ^R,
		       ^P, ^N, ^], M-.,	M-^], M-_, M-b,	M-c, M-d, M-f, M-h, M-
		       l and M-^H.

       M-letter	       Soft-key.  Your	alias list is searched for an alias by
		       the name	_letter	and  if	 an  alias  of	this  name  is
		       defined,	 its value is inserted on the input queue. The
		       letter must not be one of the above meta-functions.

       M-[letter       Soft-key. Your alias list is searched for an  alias  by
		       the  name  __letter  and	 if  an	 alias of this name is
		       defined,	its value is inserted on the input queue.  The
		       can  be	used  to program functions keys	on many	termi-
		       nals.

       M-.	       The last	word of	the previous command  is  inserted  on
		       the line. If preceded by	a numeric parameter, the value
		       of this	parameter  determines  which  word  to	insert
		       rather than the last word.

       M-_	       Same as M-..

       M-*	       An  asterisk  is	 appended to the end of	the word and a
		       file name expansion is attempted.

       M-ESC	       File name completion. Replaces the  current  word  with
		       the longest common prefix of all	filenames matching the
		       current word with an asterisk appended. If the match is
		       unique,	a / is appended	if the file is a directory and
		       a space is appended if the file is not a	directory.

       M-=	       List files matching current word	pattern	if an asterisk
		       were appended.

       ^U	       Multiply	parameter of next command by 4.

       \	       Escape  next  character.	Editing	characters, the	user's
		       erase, kill and interrupt (normally ^?) characters  can
		       be  entered  in a command line or in a search string if
		       preceded	by a \.	 The \ removes	the  next  character's
		       editing features	(if any).

       ^V	       Display version of the shell.

       M-#	       Insert a	# at the beginning of the line and execute it.
		       This causes a comment to	be  inserted  in  the  history
		       file.

   vi Editing Mode
       There are two typing modes. Initially, when you enter a command you are
       in the input mode. To edit, enter control mode by typing	ESC (033)  and
       move  the  cursor  to  the  point needing correction and	then insert or
       delete characters or words as needed. Most control commands  accept  an
       optional	repeat count prior to the command.

       When  in	 vi  mode  on  most systems, canonical processing is initially
       enabled and the command is echoed again if the speed is	1200  baud  or
       greater	and it contains	any control characters or less than one	second
       has elapsed since the prompt was	printed. The ESC character  terminates
       canonical  processing for the remainder of the command and the user can
       then modify the command line. This scheme has the advantages of canoni-
       cal processing with the type-ahead echoing of raw mode.

       If  the	option	viraw  is also set, the	terminal always	have canonical
       processing disabled. This mode is implicit for systems that do not sup-
       port  two alternate end of line delimiters, and can be helpful for cer-
       tain terminals.

   Input Edit Commands
       By default the editor is	in input mode.

       erase	       (User defined erase character as	defined	by the stty(1)
		       command,	usually	^H or #.) Delete previous character.

       ^W	       Delete the previous blank separated word.

       ^D	       Terminate the shell.

       ^V	       Escape  next  character.	 Editing  characters  and  the
		       user's erase or kill characters can  be	entered	 in  a
		       command line or in a search string if preceded by a ^V.
		       The ^V removes the next	character's  editing  features
		       (if any).

       \	       Escape the next erase or	kill character.

   Motion Edit Commands
       The following commands move the cursor:

       [count]l	       Cursor forward (right) one character.

       [count]w	       Cursor forward one alpha-numeric	word.

       [count]W	       Cursor to the beginning of the next word	that follows a
		       blank.

       [count]e	       Cursor to end of	word.

       [count]E	       Cursor to end of	the current blank delimited word.

       [count]h	       Cursor backward (left) one character.

       [count]b	       Cursor backward one word.

       [count]B	       Cursor to preceding blank separated word.

       [count]|	       Cursor to column	count.

       [count]fc       Find the	next character c in the	current	line.

       [count]Fc       Find the	previous character c in	the current line.

       [count]tc       Equivalent to f followed	by h.

       [count]Tc       Equivalent to F followed	by l.

       [count];	       Repeats count times, the	 last  single  character  find
		       command,	f, F, t, or T.

       [count],	       Reverses	 the  last single character find command count
		       times.

       0	       Cursor to start of line.

       ^	       Cursor to first non-blank character in line.

       $	       Cursor to end of	line.

       %	       Moves to	balancing (, ),	{, }, [, or ].	If  cursor  is
		       not  on	one  of	the above characters, the remainder of
		       the line	is searched for	the first occurrence of	one of
		       the above characters first.

   Search Edit Commands
       These commands access your command history.

       [count]k	       Fetch previous command. Each time k is entered the pre-
		       vious command back in time is accessed.

       [count]-	       Equivalent to k.

       [count]j	       Fetch next command. Each	time j is  entered,  the  next
		       command forward in time is accessed.

       [count]+	       Equivalent to j.

       [count]G	       The command number count	is fetched. The	default	is the
		       least recent history command.

       /string	       Search backward through history for a previous  command
		       containing  string. string is terminated	by a RETURN or
		       NEWLINE.	If string is preceded by a ^, the matched line
		       must begin with string. If string is NULL, the previous
		       string is used.

       ?string	       Same as / except	that search is in the  forward	direc-
		       tion.

       n	       Search  for  next  match	 of the	last pattern to	/ or ?
		       commands.

       N	       Search for next match of	the last pattern to  /	or  ?,
		       but in reverse direction. Search	history	for the	string
		       entered by the previous / command.

   Text	Modification Edit Commands
       These commands modifies the line.

       a		       Enter input mode	and enter text after the  cur-
			       rent character.

       A		       Append  text to the end of the line. Equivalent
			       to $a.

       [count]cmotion	       Delete current character	through	the  character
       c[count]motion	       that  motion would move the cursor to and enter
			       input mode. If motion is	c, the entire line  is
			       deleted and input mode entered.

       C		       Delete the current character through the	end of
			       line and	enter input mode. Equivalent to	c$.

       [count]s		       Delete count characters and enter input mode.

       S		       Equivalent to cc.

       D		       Delete the current character through the	end of
			       line. Equivalent	to d$.

       [count]dmotion	       Delete  current character through the character
       d[count]motion	       that motion would move to. If motion is d,  the
			       entire line is deleted.

       i		       Enter  input  mode  and	insert text before the
			       current character.

       I		       Insert text before the beginning	of  the	 line.
			       Equivalent to 0i.

       [count]P		       Place the previous text modification before the
			       cursor.

       [count]p		       Place the previous text modification after  the
			       cursor.

       R		       Enter  input mode and replace characters	on the
			       screen with characters you type	overlay	 fash-
			       ion.

       [count]rc	       Replace	the count character(s) starting	at the
			       current cursor position with c, and advance the
			       cursor.

       [count]x		       Delete current character.

       [count]X		       Delete preceding	character.

       [count].		       Repeat  the previous text modification command.

       [count]~		       Invert  the  case  of  the  count  character(s)
			       starting	 at  the  current  cursor position and
			       advance the cursor.

       [count]_		       Causes the count	word of	the  previous  command
			       to be appended and input	mode entered. The last
			       word is used if count is	omitted.

       *		       Causes an * to be appended to the current  word
			       and file	name generation	attempted. If no match
			       is found, it rings  the	bell.  Otherwise,  the
			       word  is	 replaced  by the matching pattern and
			       input mode is entered.

       \		       Filename	completion. Replaces the current  word
			       with the	longest	common prefix of all filenames
			       matching	the  current  word  with  an  asterisk
			       appended.  If  the  match  is  unique,  a  / is
			       appended	if the file is a directory and a space
			       is appended if the file is not a	directory.

   Other Edit Commands
       Miscellaneous commands.

       [count]ymotion	       Yank  current  character	through	character that
       y[count]motion	       motion would move the cursor to and  puts  them
			       into the	delete buffer. The text	and cursor are
			       unchanged.

       Y		       Yanks from current position  to	end  of	 line.
			       Equivalent to y$.

       u		       Undo the	last text modifying command.

       U		       Undo  all the text modifying commands performed
			       on the line.

       [count]v		       Returns	the  command  fc  -e  ${VISUAL:-${EDI-
			       TOR:-vi}}  count	 in the	input buffer. If count
			       is omitted, then	the current line is used.

       ^L		       Line feed and print current  line.  Has	effect
			       only in control mode.

       J		       (New line) Execute the current line, regardless
			       of mode.

       M		       (Return)	Execute	the current  line,  regardless
			       of mode.

       #		       If  the	first character	of the command is a #,
			       then this command deletes this  #  and  each  #
			       that  follows  a	 newline. Otherwise, sends the
			       line after inserting a #	in front of each  line
			       in  the command.	Useful for causing the current
			       line to be inserted in the history as a comment
			       and  removing  comments	from  previous comment
			       commands	in the history file.

       =		       List the	file names that	match the current word
			       if an asterisk were appended it.

       @letter		       Your alias list is searched for an alias	by the
			       name _letter and	if an alias of	this  name  is
			       defined,	 its  value  is	 inserted on the input
			       queue for processing.

   Special Commands
       The following  simple-commands  are  executed  in  the  shell  process.
       Input/Output  redirection is permitted. Unless otherwise	indicated, the
       output is written on file descriptor 1 and the exit status, when	 there
       is  no  syntax  error, is 0. Commands that are preceded by one or two *
       (asterisks) are treated specially in the	following ways:

       1.  Variable assignment lists preceding the command  remain  in	effect
	   when	the command completes.

       2.  I/O redirections are	processed after	variable assignments.

       3.  Errors cause	a script that contains them to abort.

       4.  Words, following a command preceded by ** that are in the format of
	   a variable assignment, are expanded with the	same rules as a	 vari-
	   able	 assignment.  This  means that tilde substitution is performed
	   after the = sign and	word splitting and file	 name  generation  are
	   not performed.

       * : [ arg ... ]

	   The command only expands parameters.

       * . file	[ arg ... ]

	   Read	 the complete file then	execute	the commands. The commands are
	   executed in the current shell environment. The search  path	speci-
	   fied	 by PATH is used to find the directory containing file.	If any
	   arguments arg are given, they  become  the  positional  parameters.
	   Otherwise  the positional parameters	are unchanged. The exit	status
	   is the exit status of the last command executed.

       ** alias	[ -tx ]	[ name[	=value ] ] ...

	   alias with no arguments prints the list  of	aliases	 in  the  form
	   name=value  on  standard  output. An	alias is defined for each name
	   whose value is given. A trailing space in  value  causes  the  next
	   word	 to  be	checked	for alias substitution.	The -t flag is used to
	   set and list	tracked	aliases. The value of a	tracked	alias  is  the
	   full	 pathname  corresponding  to the given name. The value becomes
	   undefined when the value of PATH is reset but the aliases  remained
	   tracked.  Without  the  -t flag, for	each name in the argument list
	   for which no	value is given,	the name and value  of	the  alias  is
	   printed.  The  -x flag is used to set or print exported aliases. An
	   exported alias is defined for scripts invoked by  name.   The  exit
	   status  is  non-zero	if a name is given, but	no value, and no alias
	   has been defined for	the name.

       bg [ %job... ]

	   This	command	is only	on systems that	support	job control. Puts each
	   specified  job  into	 the background. The current job is put	in the
	   background if job is	not specified. See "Jobs" section above	for  a
	   description of the format of	job.

       * break [ n ]

	   Exit	 from  the enclosed for, while,	until, or select loop, if any.
	   If n	is specified then break	n levels. If n	is  greater  than  the
	   number  of  enclosing  loops, the outermost enclosing loop shall be
	   exited.

       * continue [ n ]

	   Resume the next iteration of	the enclosed  for,  while,  until,  or
	   select  loop.  If  n	 is specified then resume at the n-th enclosed
	   loop. If n is greater than the number of enclosing loops, the  out-
	   ermost enclosing loop shall be used.

       cd [ -L ] [ -P ]	[ arg ]
       cd old new

	   This	 command  can  be in either of two forms. In the first form it
	   changes the current directory to arg. If arg	is - the directory  is
	   changed  to	the previous directory.	The shell variable HOME	is the
	   default arg.	The environment	variable PWD is	 set  to  the  current
	   directory.  If  the PWD is changed, the OLDPWD environment variable
	   shall also be changed to the	value of the  old  working  directory,
	   that	 is,  the  current  working directory immediately prior	to the
	   call	to change directory (cd). The shell  variable  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). 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 / then the search path is not used.
	   Otherwise,  each  directory	in  the	 path  is searched for arg. If
	   unsuccessful, cd attempts to	change	directories  to	 the  pathname
	   formed by the concatenation of the value of PWD, a slash character,
	   and arg.

	   -L	    Handles the	operation  dot-dot  (..)  logically.  Symbolic
		    link components are	not resolved before dot-dot components
		    are	processed.

	   -P	    Handles the	operand	dot-dot	physically. Symbolic link com-
		    ponents  are  resolved  before dot-dot components are pro-
		    cessed.

	   If both -L and -P options are specified,  the  last	option	to  be
	   invoked  is	used and the other is ignored. If neither -L nor -P is
	   specified, the operand is handled dot-dot logically.

	   The second form of cd substitutes the string	new for	the string old
	   in the current directory name, PWD, and tries to change to this new
	   directory. The cd command cannot be executed	by rksh.

       command [-p] [command_name] [argument ...]
       command [-v | -V] command_name

	   The command utility causes the shell	to treat the  arguments	 as  a
	   simple  command, suppressing	the shell function lookup. The -p flag
	   performs the	command	search using a default value for PATH that  is
	   guaranteed  to  find	 all  of  the  standard	utilities. The -v flag
	   writes a string to standard output that indicates the  pathname  or
	   command  that  is used by the shell,	in the current shell execution
	   environment,	to invoke command_name.	The -V flag writes a string to
	   standard  output  that  indicates  how  the	name given in the com-
	   mand_name operand is	interpreted by the shell, in the current shell
	   execution environment.

       echo [ arg ... ]

	   See echo(1) for usage and description.

       * eval [	arg ...	]

	   The arguments are read as input to the shell	and the	resulting com-
	   mand(s) executed.

       * exec [	arg ...	]

	   If arg is given, the	command	specified by the arguments is executed
	   in place of this shell without creating a new process. Input/output
	   arguments can appear	and affect the current process.	 If  no	 argu-
	   ments  are  given  the  effect  of  this  command is	to modify file
	   descriptors as prescribed by	the input/output redirection list.  In
	   this	 case,	any  file  descriptor  numbers greater than 2 that are
	   opened with this mechanism are closed when  invoking	 another  pro-
	   gram.

       * exit [	n ]

	   Causes the calling shell or shell script to exit with the exit sta-
	   tus specified by n. The value is the	least significant  8  bits  of
	   the	specified status. If n is omitted then the exit	status is that
	   of the last command executed. When exit  occurs  when  executing  a
	   trap,  the  last command refers to the command that executed	before
	   the trap was	invoked. An EOF	also causes the	shell to  exit	except
	   for a shell which has the ignoreeof option turned on. See set.

       ** export [ name[=value]	] ...
       ** export -p

	   The	given names are	marked for automatic export to the environment
	   of subsequently-executed commands.

	   When	-p is specified, export	writes	to  the	 standard  output  the
	   names and values of all exported variables in the following format:

	   "export %s=%s\n", name, value

	   if name is set, and:

	   "export %s\n", name

	   if name is unset.

	   The shell formats the output, including the proper use of  quoting,
	   so  that  it	 is suitable for reinput to the	shell as commands that
	   achieve the same exporting results, except for the following:

	       1.  Read-only variables with values cannot be reset.

	       2.  Variables that were unset at	the time they were output  are
		   not	reset to the unset state if a value is assigned	to the
		   variable between the	time the state was saved and the  time
		   at which the	saved output is	reinput	to the shell.

       fc [ -e ename ] [ -nlr ]	[ first	[ last ] ]
       fc -e - [ old=new ] [ command ]
       fc -s [ old=new ] [ command ]

	   In  the  first  form,  a  range  of	commands from first to last is
	   selected from the last HISTSIZE commands that  were	typed  at  the
	   terminal. The arguments first and last can be specified as a	number
	   or as a string. A string is used to locate the most recent  command
	   starting  with  the	given  string. A negative number is used as an
	   offset to the current command number. If the	-l flag	 is  selected,
	   the	commands  are listed on	standard output. Otherwise, the	editor
	   program ename is invoked on a file containing these	keyboard  com-
	   mands.  If  ename  is  not supplied,	then the value of the variable
	   FCEDIT (default /bin/ed) is used as the  editor.  When  editing  is
	   complete,  the edited command(s) is executed. If last is not	speci-
	   fied	then it	is set to first. If first is not specified the default
	   is  the  previous command for editing and -16 for listing. The flag
	   -r reverses the order of the	commands and the  flag	-n  suppresses
	   command numbers when	listing. In the	second form the	command	is re-
	   executed after the substitution old=new is performed. If  there  is
	   not	a command argument, the	most recent command typed at this ter-
	   minal is executed.

       fg [ %job... ]

	   This	command	is only	on systems that	support	job control. Each  job
	   specified  is brought to the	foreground. Otherwise, the current job
	   is brought into the foreground. See	"Jobs"	section	 above	for  a
	   description of the format of	job.

       getopts optstring name [	arg ...	]

	   Checks  arg	for  legal  options. If	arg is omitted,	the positional
	   parameters are used.	An option argument begins with a + or a	-.  An
	   option  not	beginning  with	 +  or	-  or  the argument - ends the
	   options. optstring contains the letters that	getopts	recognizes.
	    If a letter	is followed by a :, that option	is expected to have an
	   argument. The options can be	separated from the argument by blanks.

	   getopts places the next option letter it finds inside variable name
	   each	 time  it is invoked with a + prepended	when arg begins	with a
	   +. The index	of the next arg	is stored in OPTIND. The option	 argu-
	   ment, if any, gets stored in	OPTARG.

	   A  leading  : in optstring causes getopts to	store the letter of an
	   invalid option in OPTARG, and to set	 name  to  ?  for  an  unknown
	   option  and	to  :  when  a	required option	is missing. Otherwise,
	   getopts prints an error message. The	exit status is	non-zero  when
	   there  are no more options. See getoptcvt(1)	for usage and descrip-
	   tion.

	   getopts supports both traditional  single-character	short  options
	   and	long  options defined by Sun's Command Line Interface Paradigm
	   (CLIP).

	   Each	long option is an alias	for a short option and is specified in
	   parentheses	following  its	equivalent short option.  For example,
	   you can specify the long option file	as  an	alias  for  the	 short
	   option f using the following	script line:

	   getopts "f(file)" opt

	   Precede  long  options  on  the  command line with -- or ++.	In the
	   example above, --file on the	command	line would be  the  equivalent
	   of  -f,  and	 ++file	on the command line would be the equivalent of
	   +f.

	   Each	short  option  can  have  multiple  long  option  equivalents,
	   although  this is in	violation of the CLIP specification and	should
	   be used with	caution. You must enclose each long option  equivalent
	   parentheses,	as follows:

	   getopts "f:(file)(input-file)o:(output-file)"

	   In  the above example, both --file and --input-file are the equiva-
	   lent	of -f, and --output-file is the	equivalent of -o.

	   The variable	name is	always set to a	 short	option.	 When  a  long
	   option  is specified	on the command line, name is set to the	short-
	   option equivalent.

       hash [ name ... ]
       hash [ -r ]

	   For each name, the location in the search path of the command spec-
	   ified  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 pre-
	   sented. 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.	If a command is	found in a "relative" directory	in the
	   search  path, after changing	to that	directory, the stored location
	   of that command is recalculated. Commands for which	this  is  done
	   are	indicated by an	asterisk (*) adjacent to the hits information.
	   Cost	is incremented when the	recalculation is done.

       jobs [ -lnp ] [ %job ...	]

	   Lists information about each	given job; or all active jobs  if  job
	   is omitted. The -l flag lists process ids in	addition to the	normal
	   information.	The -n flag displays only jobs that  have  stopped  or
	   exited  since  last	notified.  The -p flag causes only the process
	   group to be listed. See "Jobs" section  above  and  jobs(1)	for  a
	   description of the format of	job.

       kill [ -sig ] %job ...
       kill [ -sig ] pid ...
       kill -l

	   Sends either	the TERM (terminate) signal or the specified signal to
	   the specified jobs or processes. Signals are	either given by	number
	   or  by  names  (as  given in	signal.h(3HEAD)	stripped of the	prefix
	   ``SIG'' with	the exception that SIGCHD is named CHLD). If the  sig-
	   nal being sent is TERM (terminate) or HUP (hangup), then the	job or
	   process is sent a CONT (continue) signal  if	 it  is	 stopped.  The
	   argument  job can be	the process id of a process that is not	a mem-
	   ber of one of the active jobs. See Jobs for a  description  of  the
	   format  of job. In the second form, kill -l,	the signal numbers and
	   names are listed.

       let arg...

	   Each	arg is a separate arithmetic expression	to be  evaluated.  See
	   the	Arithmetic  Evaluation	section	 above,	 for  a	description of
	   arithmetic expression evaluation.

	   The exit status is 0	if the value of	the last  expression  is  non-
	   zero, and 1 otherwise.

       login argument ...

	   Equivalent  to `exec	login argument....' See	login(1) for usage and
	   description.

       * newgrp	[ arg ... ]

	   Equivalent to exec /bin/newgrp arg ....

       print [ -Rnprsu[n ] ] [ arg ... ]

	   The shell output mechanism. With no flags or	with flag - or -,  the
	   arguments  are  printed on standard output as described by echo(1).
	   The exit status is 0, unless	the output file	is not open for	 writ-
	   ing.

	   -n		   Suppresses  NEWLINE from being added	to the output.

	   -R |	-r	   Raw mode. Ignores the escape	conventions  of	 echo.
			   The	-R  option prints all subsequent arguments and
			   options other than -n.

	   -p		   Writes the arguments	to the	pipe  of  the  process
			   spawned with	|& instead of standard output.

	   -s		   Writes the arguments	to the history file instead of
			   standard output.

	   -u [	n ]	   Specifies a one digit file descriptor unit number n
			   on which the	output is placed. The default is 1.

       pwd [ -L	| -P ]

	   Writes  to  the standard output an absolute pathname	of the current
	   working directory, which does not contain the filenames dot (.)  or
	   dot-dot (..).

	   -L	    If the PWD environment variable contains an	absolute path-
		    name of the	current	directory that does  not  contain  the
		    filenames  dot  or	dot-dot,  pwd  writes this pathname to
		    standard output. Otherwise,	the -L option behaves like the
		    -P option.

	   -P	    The	 absolute pathname written shall not contain filenames
		    that, in the context of the	pathname, refer	 to  files  of
		    type symbolic link.

	   If  both  -L	and -P are specified, the last one applies. If neither
	   -L nor -P is	specified, pwd behaves as if -L	had been specified.

       read [ -prsu[ n ] ] [ name?prompt ] [ name ... ]

	   The shell input mechanism. One line is read and is broken  up  into
	   fields  using the characters	in IFS as separators. The escape char-
	   acter, (\), is used to remove any  special  meaning	for  the  next
	   character and for line continuation.	In raw mode, -r, the \ charac-
	   ter is not treated specially. The first field is  assigned  to  the
	   first  name,	 the second field to the second	name, etc., with left-
	   over	fields assigned	to the last name. The  -p  option  causes  the
	   input  line to be taken from	the input pipe of a process spawned by
	   the shell using |&. If the -s flag is present, the input  is	 saved
	   as  a command in the	history	file. The flag -u can be used to spec-
	   ify a one digit file	descriptor unit	 n  to	read  from.  The  file
	   descriptor can be opened with the exec special command. The default
	   value of n is 0. If name is omitted	then  REPLY  is	 used  as  the
	   default  name.  The	exit  status is	0 unless the input file	is not
	   open	for reading or an EOF is  encountered.	An  EOF	 with  the  -p
	   option  causes  cleanup  for	 this  process	so that	another	can be
	   spawned. If the first argument contains a ?,	the remainder of  this
	   word	is used	as a prompt on standard	error when the shell is	inter-
	   active. The exit status is 0	unless an EOF is encountered.

       ** readonly [ name[=value] ] ...
       ** readonly -p

	   The given names are marked  readonly	 and  these  names  cannot  be
	   changed by subsequent assignment.

	   When	 -p  is	 specified, readonly writes to the standard output the
	   names and values of all read-only variables,	in the following  for-
	   mat:

	   "readonly %s=%s\n", name, value

	   if name is set, and:

	   "readonly $s\n", name

	   if name is unset.

	   The	shell formats the output, including the	proper use of quoting,
	   so that it is suitable for reinput to the shell  as	commands  that
	   achieve  the	same value and readonly	attribute-setting results in a
	   shell execution environment in which:

	       1.  Variables with values set at	the time they were  output  do
		   not have the	readonly attribute set.

	       2.  Variables  that  were unset at the time they	were output do
		   not have a value at the time	at which the saved  output  is
		   reinput to the shell.

       * return	[ n ]

	   Causes  a  shell  function  or '.' script to	return to the invoking
	   script with the return status specified by  n.  The	value  is  the
	   least  significant  8 bits of the specified status. If n is omitted
	   then	the return status is that of the  last	command	 executed.  If
	   return  is invoked while not	in a function or a '.' script, then it
	   is the same as an exit.

       set [ +-abCefhkmnopstuvx	] [ +-o	option ]... [ +-A name ] [ arg ... ]

	   The flags for this command have meaning as follows:

	   -A	    Array assignment. Unsets the  variable  name  and  assigns
		    values  sequentially from the list arg. If +A is used, the
		    variable name is not unset first.

	   -a	    All	subsequent variables that are  defined	are  automati-
		    cally exported.

	   -b	    Causes  the	 shell	to  notify  the	user asynchronously of
		    background job completions.	The following message is writ-
		    ten	to standard error:

		    "[%d]%c %s%s\n", <job-number>, <current>, <status>,	<job-name>

		    where the fields are as follows:

		    _current_	    The	 character  +  identifies the job that
				    would be used as a default for the	fg  or
				    bg	utilities. This	job can	also be	speci-
				    fied using the job_id %+ or	%%. The	 char-
				    acter  -  identifies  the  job  that would
				    become the default if the current  default
				    job	 were  to  exit;  this job can also be
				    specified using the	job_id %-.  For	 other
				    jobs,  this	field is a space character. At
				    most one job can be	identified with	+  and
				    at	most one job can be identified with -.
				    If there is	any suspended  job,  then  the
				    current  job  is a suspended job. If there
				    are	at least two suspended jobs, then  the
				    previous job is also a suspended job.

		    _job-number_    A  number that can be used to identify the
				    process group to the  wait,	 fg,  bg,  and
				    kill utilities. Using these	utilities, the
				    job	can be identified by prefixing the job
				    number with	%.

		    _status_	    Unspecified.

		    _job-name_	    Unspecified.

		    When the shell notifies the	user a job has been completed,
		    it can remove the job's process ID from the	list of	 those
		    known  in  the  current shell execution environment. Asyn-
		    chronous notification is not enabled by default.

	   -C	    Prevents existing files  from  being  overwritten  by  the
		    shell's  > redirection operator. The >| redirection	opera-
		    tor	overrides this	noclobber  option  for	an  individual
		    file.

	   -e	    If	a command has a	non-zero exit status, executes the ERR
		    trap, if set, and exit. This mode is disabled while	 read-
		    ing	profiles.

	   -f	    Disables file name generation.

	   -h	    Each  command  becomes  a tracked alias when first encoun-
		    tered.

	   -k	    All	variable assignment arguments are placed in the	 envi-
		    ronment  for  a  command,  not just	those that precede the
		    command name.

	   -m	    Background jobs runs in a separate	process	 group	and  a
		    line prints	upon completion. The exit status of background
		    jobs is reported in	a completion message. On systems  with
		    job	 control,  this	 flag  is  turned on automatically for
		    interactive	shells.

	   -n	    Reads commands and check them for syntax  errors,  but  do
		    not	execute	them. Ignored for interactive shells.

	   +o	    Writes  the	current	option stettings to standard output in
		    a format that is suitable for reinput to the shell as com-
		    mands that achieve the same	option settings.

	   -o	    The	 following argument can	be one of the following	option
		    names:

		    allexport	    Same as -a.

		    errexit	    Same as -e.

		    bgnice	    All	background jobs	are  run  at  a	 lower
				    priority. This is the default mode.

		    emacs	    Puts  you in an emacs style	in-line	editor
				    for	command	entry.

		    gmacs	    Puts you in	a gmacs	style  in-line	editor
				    for	command	entry.

		    ignoreeof	    The	shell does not exit onEOF. The command
				    exit must be used.

		    keyword	    Same as -k.

		    markdirs	    All	directory names	 resulting  from  file
				    name   generation	have   a   trailing  /
				    appended.

		    monitor	    Same as -m.

		    noclobber	    Prevents  redirection  >  from  truncating
				    existing  files.  Require >| to truncate a
				    file when turned on. Equivalent to -C.

		    noexec	    Same as -n.

		    noglob	    Same as -f.

		    nolog	    Do not save	function definitions  in  his-
				    tory file.

		    notify	    Equivalent to -b.

		    nounset	    Same as -u.

		    privileged	    Same as -p.

		    verbose	    Same as -v.

		    trackall	    Same as -h.

		    vi		    Puts  you in insert	mode of	a vi style in-
				    line editor	until you hit escape character
				    033.  This	puts  you  in  control mode. A
				    return sends the line.

		    viraw	    Each character is processed	as it is typed
				    in vi mode.

		    xtrace	    Same as -x.

		    If no option name is supplied, the current option settings
		    are	printed.

	   -p	    Disables processing	of the $HOME/.profile  file  and  uses
		    the	 file  /etc/suid_profile instead of the	ENV file. This
		    mode is on whenever	the effective uid is not equal to  the
		    real  uid,	or  when the effective gid is not equal	to the
		    real gid. Turning this off causes the  effective  uid  and
		    gid	to be set to the real uid and gid.

	   -s	    Sorts the positional parameters lexicographically.

	   -t	    Exits after	reading	and executing one command.

	   -u	    Treats unset parameters as an error	when substituting.

	   -v	    Prints shell input lines as	they are read.

	   -x	    Prints  commands and their arguments as they are executed.

	   -	    Turns off -x and -v	flags and  stops  examining  arguments
		    for	flags.

	   --	    Does  not change any of the	flags. Useful in setting $1 to
		    a value beginning with -. If no arguments follow this flag
		    then the positional	parameters are unset.

		    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 can be found in $-. Unless -A is
		    specified, the remaining arguments are positional  parame-
		    ters and are assigned, in order, to	$1 $2 .... If no argu-
		    ments are given, the names and values of all variables are
		    printed on the standard output.

       * shift [ n ]

	   The	positional  parameters	from $n+1 $n+1 ... are renamed $1 ...,
	   default n is	1. The parameter n can be  any	arithmetic  expression
	   that	evaluates to a non-negative number less	than or	equal to $#.

       stop%jobid  ...
       stop pid	...

	   stop	stops the execution of a background job(s) by using its	jobid,
	   or of any process by	using its pid. See ps(1).

       suspend

	   Stops the execution of the current shell (but  not  if  it  is  the
	   login shell).

       test expression

	   Evaluates conditional expressions. See Conditional Expressions sec-
	   tion	above and test(1) for usage and	description.

       * times

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

       * trap [	arg sig	... ]

	   arg	is  a  command to be read and executed when the	shell receives
	   signal(s) sig. arg is scanned once when the trap is	set  and  once
	   when	 the trap is taken. sig	can be specified as a signal number or
	   signal name.	trap commands are executed in order of signal  number.
	   Any	attempt	 to  set a trap	on a signal number that	was ignored on
	   entry to the	current	shell is ineffective.

	   If arg is -,	the shell resets each sig to the default value.	If arg
	   is  null  (''),  the	shell ignores each specified sig if it arises.
	   Otherwise, arg is read and executed by the shell when  one  of  the
	   corresponding  sigs arises. The action of the trap overrides	a pre-
	   vious action	(either	default	action or  one	explicitly  set).  The
	   value  of  $?  after	 the trap action completes is the value	it had
	   before the trap was invoked.

	   sig can be EXIT, 0 (equivalent to EXIT) or a	signal specified using
	   a  symbolic	name,  without	the SIG	prefix,	for example, HUP, INT,
	   QUIT, TERM. If sig is 0 or EXIT and the trap	statement is  executed
	   inside  the	body  of  a function, then the command arg is executed
	   after the function completes. If sig	is 0 or	EXIT for  a  trap  set
	   outside  any	function, the command arg is executed on exit from the
	   shell. If sig is ERR, arg is	executed whenever a command has	a non-
	   zero	exit status.  If sig is	DEBUG, arg is executed after each com-
	   mand.

	   The environment in which the	shell executes a trap on EXIT is iden-
	   tical  to  the  environment immediately after the last command exe-
	   cuted before	the trap on EXIT was taken.

	   Each	time the trap is invoked, arg is processed in a	manner equiva-
	   lent	to eval	"$arg".

	   Signals  that were ignored on entry to a non-interactive shell can-
	   not be trapped or reset, although no	error need  be	reported  when
	   attempting  to  do so. An interactive shell can reset or catch sig-
	   nals	ignored	on entry. Traps	remain in  place  for  a  given	 shell
	   until explicitly changed with another trap command.

	   When	a subshell is entered, traps are set to	the default args. This
	   does	not imply that the trap	command	cannot be used within the sub-
	   shell to set	new traps.

	   The trap command with no arguments writes to	standard output	a list
	   of commands associated with each sig. The format is:

	   trap	-- %s %s ... _arg_, _sig_ ...

	   The shell formats the output, including the proper use of  quoting,
	   so  that  it	 is suitable for reinput to the	shell as commands that
	   achieve the same trapping results. For example:

	   save_traps=$(trap)
	   ...
	   eval	"$save_traps"

	   If the trap name or number is invalid, a non-zero  exit  status  is
	   returned.  Otherwise,  0 is returned. For both interactive and non-
	   interactive shells, invalid signal names or numbers are not consid-
	   ered	a syntax error and dol not cause the shell to abort.

	   Traps  are  not  processed  while a job is waiting for a foreground
	   process. Thus, a trap on CHLD won't be  executed  until  the	 fore-
	   ground job terminates.

       type name ...

	   For	each  name, indicates how it would be interpreted if used as a
	   command name.

       ** typeset [ +-HLRZfilrtux[n] ] [ name[=value ] ] ...

	   Sets	attributes and values for shell	variables and functions.  When
	   typeset  is	invoked	inside a function, a new instance of the vari-
	   ables name is created. The variables	value and  type	 are  restored
	   when	 the  function completes. The following	list of	attributes can
	   be specified:

	   -H	    This flag provides UNIX to host-name file mapping on  non-
		    UNIX machines.

	   -L	    Left justifies and removes leading blanks from value. If n
		    is non-zero	it defines the width of	the field.  Otherwise,
		    it	is  determined	by  the	 width	of  the	value of first
		    assignment.	When the variable is assigned to, it is	filled
		    on	the  right  with blanks	or truncated, if necessary, to
		    fit	into the field.	Leading	zeros are removed  if  the  -Z
		    flag is also set. The -R flag is turned off.

	   -R	    Right  justifies  and  fills  with leading blanks. If n is
		    non-zero it	defines	the width of the field,	 otherwise  it
		    is	determined  by the width of the	value of first assign-
		    ment. The field is left filled with	 blanks	 or  truncated
		    from the end if the	variable is reassigned.	The -L flag is
		    turned off.

	   -Z	    Right justifies and	fills with leading zeros if the	 first
		    non-blank  character  is  a	 digit and the -L flag has not
		    been set. If n is non-zero it defines  the	width  of  the
		    field.  Otherwise,	it  is	determined by the width	of the
		    value of first assignment.

	   -f	    The	names refer to function	 names	rather	than  variable
		    names. No assignments can be made and the only other valid
		    flags are -t, -u, and -x. The flag -t turns	 on  execution
		    tracing  for  this function. The flag -u causes this func-
		    tion  to  be  marked  undefined.  The  FPATH  variable  is
		    searched to	find the function definition when the function
		    is referenced. The flag -x allows the function  definition
		    to	remain	in  effect  across shell procedures invoked by
		    name.

	   -i	    Parameter is an integer. This makes	arithmetic faster.  If
		    n  is non-zero it defines the output arithmetic base; oth-
		    erwise, the	first assignment determines the	output base.

	   -l	    All	upper-case characters are converted to lower-case. The
		    upper-case flag, -u	is turned off.

	   -r	    The	given names are	marked readonly	and these names	cannot
		    be changed by subsequent assignment.

	   -t	    Tags the variables.	Tags are user definable	 and  have  no
		    special meaning to the shell.

	   -u	    All	 lower-case  characters	 are  converted	 to upper-case
		    characters.	The lower-case flag, -l	is turned off.

	   -x	    The	given names are	marked for  automatic  export  to  the
		    environment	of subsequently-executed commands.

	   The	-i attribute cannot be specified along with -R,	-L, -Z,	or -f.

	   Using + rather than - causes	these flags to be turned  off.	If  no
	   name	 arguments  are	given but flags	are specified, a list of names
	   (and	optionally the values) of the variables	which have these flags
	   set	is printed. (Using + rather than - keeps the values from being
	   printed.) If	no names and flags are given, the names	and attributes
	   of all variables are	printed.

       ulimit [	-HSacdfnstv ] [	limit ]

	   Sets	 or  displays a	resource limit.	The available resources	limits
	   are listed in the following section.	Many systems  do  not  contain
	   one	or more	of these limits. The limit for a specified resource is
	   set when limit is specified.	The value of limit can be a number  in
	   the	unit specified with each resource, or the value	unlimited. The
	   H and S flags specify whether the hard limit	or the soft limit  for
	   the given resource is set. A	hard limit cannot be increased once it
	   is set. A soft limit	can be increased up to the value of  the  hard
	   limit.  If  neither	the  H	or  S  options is specified, the limit
	   applies to both. The	current	resource limit is printed  when	 limit
	   is  omitted.	 In  this  case, the soft limit	is printed unless H is
	   specified. When more	than one resource is specified,	the limit name
	   and unit is printed before the value.

	   -a	    Lists all of the current resource limits.

	   -c	    The	number of 512-byte blocks on the size of core dumps.

	   -d	    The	number of K-bytes on the size of the data area.

	   -f	    The	 number	 of  512-byte blocks on	files written by child
		    processes (files of	any size can be	read).

	   -n	    The	number of file descriptors plus	1.

	   -s	    The	number of K-bytes on the size of the stack area.

	   -t	    The	number of seconds to be	used by	each process.

	   -v	    The	number of K-bytes for virtual memory.

	   If no option	is given, -f is	assumed.

       umask [-S] [ mask ]

	   The user file-creation mask is set to mask (see umask(2)). mask can
	   either  be  an  octal  number  or  a	symbolic value as described in
	   chmod(1). If	a symbolic value is given, the new umask value is  the
	   complement  of the result of	applying mask to the complement	of the
	   previous umask value. If mask is omitted, the current value of  the
	   mask	is printed. The	-S flag	produces symbolic output.

       unalias name ...
       unalias -a

	   The	aliases	 given by the list of names are	removed	from the alias
	   list. The -a	option removes all alias definitions from the  current
	   execution environment.

       unset [ -f ] name ...

	   The	variables  given by the	list of	names are unassigned, that is,
	   their values	and attributes are erased. readonly  variables	cannot
	   be  unset. If the -f, flag is set, then the names refer to function
	   names. Unsetting ERRNO, LINENO, MAILCHECK, OPTARG, OPTIND,  RANDOM,
	   SECONDS,  TMOUT,  and  _ removes their special meaning even if they
	   are subsequently assigned to.

       * wait [	job ]

	   Waits for the specified job and report its termination  status.  If
	   job	is  not	 given	then  all currently active child processes are
	   waited for. The exit	status	from  this  command  is	 that  of  the
	   process  waited  for.  See  Jobs for	a description of the format of
	   job.

       whence [	-pv ] name ...

	   For each name, indicates how	it would be interpreted	if used	 as  a
	   command name.

	   The -v flag produces	a more verbose report.

	   The -p flag does a path search for name even	if name	is an alias, a
	   function, or	a reserved word.

   Invocation
       If the shell is invoked by exec(2), and the first character of argument
       zero  ($0) is -,	then the shell is assumed to be	a login	shell and com-
       mands are read from /etc/profile	and then from either .profile  in  the
       current	directory or $HOME/.profile, if	either file exists. Next, com-
       mands are read from the file named by performing	parameter substitution
       on the value of the environment variable	ENV if the file	exists.	If the
       -s flag is not present and arg is, then a path search is	 performed  on
       the  first  arg	to  determine  the  name of the	script to execute. The
       script arg must have read permission and	any setuid and setgid settings
       are  ignored.  If the script is not found on the	path, arg is processed
       as if it	named a	builtin	command	or function. Commands are then read as
       described  as follows. The following flags are interpreted by the shell
       when it is invoked:

       -c	 Reads commands	from  the  command_string  operand.  Sets  the
		value  of  special  parameter  0  from	the  value of the com-
		mand_name operand and the positional parameters	($1,  $2,  and
		so  on)	 in  sequence from the remaining arg operands. No com-
		mands are read from the	standard input.

       -s	If the -s flag is present or if	no arguments remain,  commands
		are read from the standard input. Shell	output,	except for the
		output of the Special Commands listed  above,  is  written  to
		file descriptor	2.

       -i	If the -i flag is present or if	the shell input	and output are
		attached to a terminal (as told	by ioctl(2)), then this	 shell
		is  interactive. In this case, TERM is ignored (so that	kill 0
		does not kill an interactive shell) and	 INTR  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.

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

   rksh	Only
       rksh  is	 used  to  set up login	names and execution environments whose
       capabilities are	more controlled	than those of the standard shell.  The
       actions	of rksh	are identical to those of ksh, except that the follow-
       ing are disallowed:

	 o  changing directory (see cd(1))

	 o  setting the	value of SHELL,	ENV, or	PATH

	 o  specifying path or command names containing	/

	 o  redirecting	output (>, >|, <>, and >>)

	 o  changing group (see	newgrp(1)).

       The restrictions	above are enforced after .profile and  the  ENV	 files
       are interpreted.

       When  a	command	 to be executed	is found to be a shell procedure, rksh
       invokes ksh to execute it. Thus,	it is possible to provide to the  end-
       user  shell  procedures that have access	to the full power of the stan-
       dard shell, while imposing a limited  menu  of  commands;  this	scheme
       assumes	that  the end-user does	not have write and execute permissions
       in the same directory.

       The net effect of these rules is	that the writer	of  the	 .profile  has
       complete	 control  over	user  actions,	by performing guaranteed setup
       actions and leaving the user in an appropriate directory	(probably  not
       the login directory).

       The  system  administrator  often sets up a directory of	commands (that
       is, /usr/rbin) that can be safely invoked by rksh.

       Errors detected by the shell, such as syntax errors, cause the shell to
       return  a  non-zero  exit status. Otherwise, the	shell returns the exit
       status of the last command executed (see	also the exit command  above).
       If  the	shell  is  being  used non-interactively then execution	of the
       shell file is abandoned.	Run time errors	 detected  by  the  shell  are
       reported	 by printing the command or function name and the error	condi-
       tion. If	the line number	that the error occurred	 on  is	 greater  than
       one, then the line number is also printed in square brackets ([]) after
       the command or function name.

       For a non-interactive shell, an error condition encountered by  a  spe-
       cial  built-in  or  other  type	of utility causes the shell to write a
       diagnostic message to standard error and	exit as	shown in the following
       table:

       +----------------------------------------------------------------------+
       |	     Error		   Special Built-in   Other Utilities |
       |Shell language syntax error		exits		   exits      |
       |Utility	 syntax	error (option or	exits	       does not	exit  |
       |operand	error)							      |
       |Redirection error			exits	       does not	exit  |
       |Variable assignment error		exits	       does not	exit  |
       |Expansion error				exits		   exits      |
       |Command	not found			 n/a		might exit    |
       |Dot script not found			exits		    n/a	      |
       +----------------------------------------------------------------------+

       An expansion error is one that occurs when  the	shell  expansions  are
       carried	out  (for example, ${x!y}, because ! is	not a valid operator).
       An implementation can treat these as syntax errors if  it  is  able  to
       detect them during tokenization,	rather than during expansion.

       If  any	of the errors shown as "might exit" or "exits" occur in	a sub-
       shell, the subshell exits or might exit with a non-zero status, but the
       script containing the subshell does not exit because of the error.

       In  all	of the cases shown in the table, an interactive	shell writes a
       diagnostic message to standard error without exiting.

       See largefile(5)	for the	description of the behavior of	ksh  and  rksh
       when encountering files greater than or equal to	2 Gbyte	(2**31 bytes).

       Each command has	an exit	status that  can  influence  the  behavior  of
       other  shell  commands. The exit	status of commands that	are not	utili-
       ties is documented in this section. The exit  status  of	 the  standard
       utilities is documented in their	respective sections.

       If  a command is	not found, the exit status is 127. If the command name
       is found, but it	is not an executable utility, the exit status is  126.
       Applications  that  invoke utilities without using the shell should use
       these exit status values	to report similar errors.

       If a command fails during word expansion	or redirection,	its exit  sta-
       tus is greater than zero.

       When  reporting the exit	status with the	special	parameter ?, the shell
       reports the full	eight bits of exit status available. The  exit	status
       of  a  command that terminated because it received a signal reported as
       greater than 128.

       /etc/profile

       /etc/suid_profile

       $HOME/.profile

       /tmp/sh*

       /dev/null

       See attributes(5) for descriptions of the following attributes:

   /usr/bin/ksh, /usr/bin/rksh
       +-----------------------------+-----------------------------+
       |      ATTRIBUTE	TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Availability		     |SUNWcsu			   |
       +-----------------------------+-----------------------------+
       |CSI			     |Enabled			   |
       +-----------------------------+-----------------------------+

   /usr/xpg4/bin/sh
       +-----------------------------+-----------------------------+
       |      ATTRIBUTE	TYPE	     |	    ATTRIBUTE VALUE	   |
       +-----------------------------+-----------------------------+
       |Availability		     |SUNWxcu4			   |
       +-----------------------------+-----------------------------+
       |CSI			     |Enabled			   |
       +-----------------------------+-----------------------------+
       |Interface Stability	     |Standard			   |
       +-----------------------------+-----------------------------+

       cat(1),	cd(1),	chmod(1),  cut(1),  echo(1),   env(1),	 getoptcvt(1),
       jobs(1),	 login(1),  newgrp(1),	paste(1),  pfksh(1), pfexec(1),	ps(1),
       shell_builtins(1), stty(1), test(1), vi(1), dup(2),  exec(2),  fork(2),
       ioctl(2), lseek(2), pipe(2), ulimit(2), umask(2), rand(3C), signal(3C),
       signal.h(3HEAD),	wait(3C), a.out(4), profile(4),	 attributes(5),	 envi-
       ron(5), largefile(5), standards(5)

       Morris  I. Bolsky and David G. Korn, The	KornShell Command and Program-
       ming Language, Prentice Hall, 1989.

       The use of setuid shell scripts is strongly discouraged.

       If a command which is a tracked alias is	executed, and then  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
       continues  to exec the original command.	Use the	-t option of the alias
       command to correct this situation.

       Some very old shell scripts contain a ^ as a synonym for	the pipe char-
       acter |.

       Using  the  fc  built-in	 command  within a compound command causes the
       whole command to	disappear from the history file.

       The built-in command .file reads	the whole file before any commands are
       executed.  Therefore,  alias  and unalias commands in the file does not
       apply to	any functions defined in the file.

       When the	shell executes a shell script that attempts to execute a  non-
       existent	command	interpreter, the shell returns an erroneous diagnostic
       message that the	shell script file does not exist.

				  29 Jun 2005				ksh(1)

NAME | SYNOPSIS

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=ksh&sektion=1&manpath=SunOS+5.10>

home | help