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 se-
       quence 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 pa-
	   rameter 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 af-
	   ter 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  in-
       cluding the metacharacters listed above.	The first word of each command
       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 com-
       mand and	can be removed with the	unalias	command. Exported aliases  re-
       main  in	 effect	for scripts invoked by name, but must be reinitialized
       for separate invocations	of the shell. See Invocation. To prevent infi-
       nite  loops  in	recursive aliasing, if the shell is not	currently pro-
       cessing 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 op-
       tion to the aliasing facility allows the	value of the alias to be auto-
       matically set to	the full pathname of the corresponding command.	 These
       aliases are called tracked aliases. The value of	a tracked alias	is de-
       fined 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. Sev-
       eral  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  un-
       quoted 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 assign-
       ment), following	any unquoted colon or both. A tilde-prefix in  an  as-
       signment	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  re-
       placed  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  am-
       biguities 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 ex-
       pansion 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 ac-
       cording 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 op-
       erating 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 em-
       bedded arithmetic expansions, command substitutions and variable	expan-
       sions, 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  op-
       tional  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 ex-
	    pansion.

	 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, pa-
       rameter 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  de-
       scribed	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 pa-
			       rameter.	In all cases, the final	value  of  pa-
			       rameter is substituted. Only variables, not po-
			       sitional	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  in-
			       teractive shell need not	exit.

       ${parameter:+[word]}    Use Alternative Value. If parameter is unset or
			       null, null is substituted. Otherwise,  the  ex-
			       pansion 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 as-
       signed 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 ex-
			       panded to produce a pattern. The	parameter  ex-
			       pansion	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 ex-
			       panded to produce a pattern. The	parameter  ex-
			       pansion	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 ex-
			       panded to produce a pattern. The	parameter  ex-
			       pansion	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 ex-
			       panded to produce a pattern. The	parameter  ex-
			       pansion	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 en-
		       vironment.  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 in-
		       voked.

       ERRNO	       The value of errno as set by the	most  recently	failed
		       system  call. This value	is system dependent and	is in-
		       tended 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 ef-
		       fective group IDs are different.

		       This variable can be used  to  set  aliases  and	 other
		       items  local to the invocation of a shell. The file re-
		       ferred 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,  un-
		       like  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	attri-
		       bute 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  ac-
		       cessible	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  be-
		       fore  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 in-
		       forms 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  un-
		       specified

       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  un-
       changed.	When a pattern is used for file	name generation, the character
       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 .re-
       store, 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 (""), pa-
       rameter	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 at-
       tribute.	  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 lo-
			       cale setting for	category LC_COLLATE.

       string1 > string2       True, if	string1	comes after string2  based  on
			       strings	interpreted  as	appropriate to the lo-
			       cale 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 no-
			       clobber 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 re-
			       sulting document, called	a  here-document,  be-
			       comes  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 de-
			       scriptor	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 de-
       fault 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)  as-
       sociation 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  ex-
       port.  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, ex-
       cept 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. Er-
       rors 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 al-
       lowed, 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-as-
       signment	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  de-
       clared  successfully; otherwise,	it is greater than zero. The exit sta-
       tus of a	function invocation is the exit	status of the last command ex-
       ecuted 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 as-
       signs  them small integer numbers. When a job is	started	asynchronously
       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 in-
       terrupt 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 re-
       ferred 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 re-
       turn,  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 po-
		       sition up to the	cursor.	If preceded by a numerical pa-
		       rameter whose value is greater than the current	cursor
		       position,  then	delete	from cursor up to given	cursor
		       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  de-
		       fined,  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 de-
		       fined, 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 en-
       abled 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 ad-
			       vance 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 ap-
			       pended. If the match is unique, a / is appended
			       if  the	file is	a directory and	a space	is ap-
			       pended 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. In-
       put/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 se-
	   lect	loop. If n is specified	then resume at the n-th	enclosed loop.
	   If  n  is greater than the number of	enclosing loops, the outermost
	   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 di-
	   rectory. 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  di-
	   rectory  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  un-
	   successful,	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 in-
	   voked 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  de-
	   scriptors  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 se-
	   lected from the last	HISTSIZE commands that were typed at the  ter-
	   minal. 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  de-
	   scription of	the format of job.

       getopts optstring name [	arg ...	]

	   Checks arg for legal	options. If arg	is omitted, the	positional pa-
	   rameters are	used. An option	argument begins	with a + or  a	-.  An
	   option  not	beginning  with	 + or -	or the argument	- ends the op-
	   tions. 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 op-
	   tion	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 description.

	   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  op-
	   tion	f using	the following script line:

	   getopts "f(file)" opt

	   Precede  long options on the	command	line with -- or	++. In the ex-
	   ample 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, al-
	   though 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 op-
	   tion	is specified on	the command line, name is set to the short-op-
	   tion	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 op-
	   tion	causes the shell to forget all remembered locations. If	no ar-
	   guments 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 de-
	   scription 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 ar-
	   gument job can be the process id of a process that is not a	member
	   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 in-
	   put	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  de-
	   scriptor  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  de-
	   fault  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 interactive. 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 re-
	   turn	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 be-
				    come 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 in-
		    teractive 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	 / ap-
				    pended.

		    monitor	    Same as -m.

		    noclobber	    Prevents redirection > from	truncating ex-
				    isting  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 re-
				    turn 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 lo-
	   gin 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 be-
	   fore	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 af-
	   ter the function completes. If sig is 0 or EXIT for a trap set out-
	   side	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 un-
	   til 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  as-
		    signment.  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 en-
		    vironment 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 ap-
	   plies to both. The current resource limit is	printed	when limit  is
	   omitted. In this case, the soft limit is printed unless H is	speci-
	   fied. 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 ig-
		nored  (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 ca-
       pabilities 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  as-
       sumes  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 ac-
       tions 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  re-
       ported  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 di-
       agnostic	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 de-
       tect 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  be-
       fore the	directory where	the original command was found,	the shell con-
       tinues 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