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

FreeBSD Manual Pages


home | help
SH(1)			    General Commands Manual			 SH(1)

       sh  -  shell, the standard UNIX system command interpreter and command-
       level language

       sh [ -acefhiknstuvx ] [ arguments ]

       sh, the Bourne shell, is	the standard UNIX-system command  interpreter.
       It executes commands read from a	terminal or a file.

       A  blank	 is  a TAB or a	SPACE character.  A name is a sequence of let-
       ters, digits, or	underscores beginning with a letter or underscore.   A
       parameter  is  a	name, a	digit, or any of the characters	*, @, #, ?, -,
       $, and !	.

       If the shell is invoked through execve(2V), exec(), see execl(3V),  and
       the  first  character  of  argument zero	is `-',	commands are initially
       read from /etc/profile and from $HOME/.profile, if  such	 files	exist.
       Thereafter,  commands  are  read	 as described below, which is also the
       case when the shell is invoked as sh.

       The options below are interpreted by the	shell on invocation only;  un-
       less the	-c or -s option	is specified, the first	argument is assumed to
       be the name of a	file containing	commands, and the remaining  arguments
       are passed as positional	parameters for use with	the commands that file

       -i	      If the -i	option is present or if	the  shell  input  and
		      output  are attached to a	terminal, this shell is	inter-
		      active.  In this case  TERMINATE	is  ignored  (so  that
		      `kill  0'	does not kill an interactive shell) and	INTER-
		      RUPT is caught and ignored (so that wait	is  interrupt-
		      ible).  In all cases, QUIT is ignored by the shell.

       -s	      If  the  -s  option is present or	if no arguments	remain
		      commands are read	from the standard input.  Any  remain-
		      ing  arguments specify the positional parameters.	 Shell
		      output (except for Special Commands) is written to  file
		      descriptor 2.

       -c string      If  the  -c  option  is  present	commands are read from

       The remaining options and arguments are described under	the  set  com-
       mand, under Special Commands, below.

       Refer  to  for  more information	about using the	shell as a programming

       A simple	command	is a sequence of nonblank words	separated  by  blanks.
       The  first  word	specifies the name of the command to be	executed.  Ex-
       cept as specified below,	the remaining words are	passed as arguments to
       the invoked command.  The command name is passed	as argument 0 (see ex-
       ecve(2V)).  The value of	a simple command is its	exit status if it ter-
       minates	normally,  or  (octal)	200+status if it terminates abnormally
       (see sigvec(2) for a list of status values).

       A pipeline is a sequence	of one or more commands	separated by `|'  (or,
       for  historical	compatibility,	by  `^').  The standard	output of each
       command but the last is connected by a pipe (see	pipe(2V)) to the stan-
       dard  input  of	the  next  command.  Each command is run as a separate
       process;	the shell normally waits for the last command to terminate be-
       fore  prompting	for or accepting the next input	line.  The exit	status
       of a pipeline is	the exit status	of its last command.

       A list is a sequence of one or more simple commands or pipelines, sepa-
       rated  by  `;', `&', `&&', or `||', and optionally terminated by	`;' or
       `&'.  Of	these four symbols, `;'	and `&'	have equal  precedence,	 which
       is  lower  than	that of	`&&' and `||'.	The symbols `&&' and `||' also
       have equal precedence.  A semicolon (;) sequentially executes the  pre-
       ceding pipeline;	an ampersand (&) asynchronously	executes the preceding
       pipeline	(the shell does	not wait for that pipeline  to	finish).   The
       symbols	&&  and	 ||  are used to indicate conditional execution	of the
       list that follows.  With	&& , list is executed only  if	the  preceding
       pipeline	(or command) returns a zero exit status.  With ||, list	is ex-
       ecuted only if the preceding pipeline (or command)  returns  a  nonzero
       exit status.  An	arbitrary number of NEWLINE characters may appear in a
       list, instead of	semicolons, to delimit commands.

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

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

       case word in [pattern[ |	pattern] ...  )	list ;;	] ... esac
	      A	case command executes the list associated with the first  pat-
	      tern that	matches	word.  The form	of the patterns	is the same as
	      that used	for filename generation	(see Filename Generation)  ex-
	      cept that	a slash, a leading dot,	or a dot immediately following
	      a	slash need not be matched explicitly.

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

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

       (list) Execute list in a	subshell.

	      list is simply executed.

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

       The following 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 {	}

       A  word	beginning with # and all the following characters up to	a NEW-
       LINE are	ignored.

   Command Substitution
       The shell reads commands	from the string	between	two grave accents (``)
       and  the	standard output	from these commands may	be used	as all or part
       of a word.  Trailing NEWLINE characters from the	 standard  output  are

       No  interpretation is done on the string	before the string is read, ex-
       cept to remove backslashes (\) used to escape other characters.	 Back-
       slashes	may  be	used to	escape a grave accent (`) or another backslash
       (\) and are removed before the command string is	read.  Escaping	 grave
       accents	allows	nested command substitution.  If the command substitu-
       tion lies within	a pair of double quotes	(" ...`	...` ... "),  a	 back-
       slash used to escape a double quote (\")	will be	removed; otherwise, it
       will be left intact.

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

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

	      name=value [ name=value ]	...

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

	      The  value, if any, of the parameter is substituted.  The	braces
	      are required only	when parameter is followed by a	letter,	digit,
	      or underscore that is not	to be interpreted as part of its name.
	      If parameter is `*'  or  `@',  all  the  positional  parameters,
	      starting	with  $1,  are substituted (separated by SPACE charac-
	      ters).  Parameter	$0 is set from argument	zero when the shell is
       If  the	colon (:) is omitted from the following	expressions, the shell
       only checks whether parameter is	set or not.
	      If parameter is set and is nonnull, substitute its value;	other-
	      wise substitute word.
	      If  parameter is not set or is null set it to word; the value of
	      the parameter is substituted.  Positional	parameters may not  be
	      assigned to in this way.
	      If parameter is set and is nonnull, substitute its value;	other-
	      wise, print word and exit	from the shell.	 If word  is  omitted,
	      the message `parameter null or not set' is printed.
	      If  parameter  is	set and	is nonnull, substitute word; otherwise
	      substitute nothing.

       In the above, word is not evaluated unless it is	to be used as the sub-
       stituted	 string,  so  that,  in	the following example, pwd is executed
       only if d is not	set or is null:

	      echo ${d:-`pwd`}

       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
	      ?	     The decimal value returned	by the last synchronously exe-
		     cuted command.
	      $	     The process number	of this	shell.
	      !	     The process number	of the	last  background  command  in-

       The following parameters	are used by the	shell:

	      HOME	     The  default argument (home directory) for	the cd

	      PATH	     The search	path for commands (see	Execution  be-

	      CDPATH	     The search	path for the cd	command.

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

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

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

	      PS1	     Primary prompt string, by default `$ '.

	      PS2	     Secondary prompt string, by default `> '.

	      IFS	     Internal  field  separators, normally SPACE, TAB,
			     and NEWLINE.

	      SHELL	     When the shell is invoked,	it scans the  environ-
			     ment (see Environment below) for this name.

       The  shell  gives  default values to PATH, PS1, PS2, MAILCHECK and IFS.
       HOME and	MAIL are set by	login(1).

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

       A command's input and output may	be redirected using a special notation
       interpreted by the shell.  The following	may appear anywhere in a  sim-
       ple command or may precede or follow a command and are not passed on to
       the invoked command.  Note: parameter and command  substitution	occurs
       before word or digit is used.

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

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

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

       <<[-]word     After parameter and command substitution is done on word,
		     the shell input is	read up	to the first line that	liter-
		     ally  matches the resulting word, or to an	EOF.  If, how-
		     ever, `-' is appended to:

			    o	leading	TAB characters are stripped from  word
				before	the shell input	is read	(but after pa-
				rameter	and command substitution  is  done  on

			    o	leading	 TAB  characters are stripped from the
				shell input as it is read and before each line
				is compared with word, and

			    o	shell  input is	read up	to the first line that
				literally matches the resulting	word, or to an

		     If	any character of word is quoted, (see Quoting, later),
		     no	additional processing is done to the shell input.   If
		     no	characters of word are quoted:

			    o	parameter and command substitution occurs,

			    o	(escaped) \NEWLINE is ignored, and

			    o	`\'  must be used to quote the characters `\',
				`$', and ``'.

       The resulting document becomes the standard input.

	      Use the file associated with file	descriptor digit  as  standard
	      input.  Similarly	for the	standard output	using >&digit.

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

       If any of the above is preceded by a digit, the file  descriptor	 which
       will  be	 associated  with the file is that specified by	the digit (in-
       stead of	the default 0 or 1).  For example:

	      ... 2>&1

       associates file descriptor 2 with the file  currently  associated  with
       file descriptor 1.

       The  order  in  which  redirections  are	specified is significant.  The
       shell evaluates redirections left-to-right.  For	example:

	      ... 1>xxx	2>&1

       first associates	file descriptor	1 with file xxx.  It  associates  file
       descriptor  2  with the file associated with file descriptor 1 (namely,
       file xxx).  If the order	of redirections	were reversed, file descriptor
       2 would be associated with the terminal (assuming file descriptor 1 had
       been) and file descriptor 1 would be associated with file xxx.

       Using the terminology introduced	on the first page, under Commands,  if
       a  command  is composed of several simple commands, redirection will be
       evaluated for the entire	command	before it is evaluated for each	simple
       command.	 That is, the shell evaluates redirection for the entire list,
       then each pipeline within the list, then	each command within each pipe-
       line, then each list within each	command.

       If  a  command is followed by & the default standard input for the com-
       mand 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.

   Filename Generation
       Before a	command	is executed, each command  word	 is  scanned  for  the
       characters  `*',	 `?', and `['.	If one of these	characters appears the
       word is regarded	as a pattern.  The word	is  replaced  with  alphabeti-
       cally sorted filenames that match the pattern.  If no filename is found
       that matches the	pattern, the word is left  unchanged.	The  character
       `.'  at the start of a filename or immediately following	a `/', as well
       as the character	`/' itself, must be matched explicitly.

	      *	     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 !	 any character not en-
		     closed is matched.

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

	      ;	 &  (  )  |  ^	<  > NEWLINE   SPACE   TAB

       A  character  may  be quoted (made to stand for itself) by preceding it
       with a backslash	(\) or inserting it between a pair of quote marks  (''
       or  "").	  During processing, the shell may quote certain characters to
       prevent them from taking	on a special  meaning.	 Backslashes  used  to
       quote  a	 single	character are removed from the word before the command
       is executed.  The pair \NEWLINE is removed from a word  before  command
       and parameter substitution.

       All  characters enclosed	between	a pair of single quote marks (''), ex-
       cept a single quote, are	quoted by the shell.  Backslash	has no special
       meaning	inside	a pair of single quotes.  A single quote may be	quoted
       inside a	pair of	double quote marks (for	example, "'").

       Inside a	pair of	double quote marks (""), parameter and command substi-
       tution occurs and the shell quotes the results to avoid blank interpre-
       tation and file name generation.	 If $* is  within  a  pair  of	double
       quotes, the positional parameters are substituted and quoted, separated
       by quoted spaces	("$1 $2	..."); however,	if $@ is within	a pair of dou-
       ble quotes, the positional parameters are substituted and quoted, sepa-
       rated by	unquoted spaces	("$1" "$2" ... ).  \ quotes the	characters  \,
       `, ", and $.  The pair \NEWLINE is removed before parameter and command
       substitution.  If a backslash precedes characters other than \,	`,  ",
       $, and NEWLINE, then the	backslash itself is quoted by the shell.

       When used interactively,	the shell prompts with the value of PS1	before
       reading a command.  If at any time a RETURN is typed and	further	 input
       is  needed  to  complete	 a command, the	secondary prompt (the value of
       PS2) is issued.

       The environment (see environ(5V)) is a list of name-value pairs that is
       passed  to  an  executed	 program  in the same way as a normal argument
       list.  The shell	interacts with the environment in  several  ways.   On
       invocation, the shell scans the environment and creates a parameter for
       each name found,	giving it the corresponding value.  If the user	 modi-
       fies  the  value	 of any	of these parameters or creates new parameters,
       none of these affects the environment unless the	export command is used
       to  bind	 the shell's parameter to the environment (see also `set -a').
       A parameter may be removed from the environment with the	unset command.
       The  environment	 seen  by any executed command is thus composed	of any
       unmodified name-value pairs originally inherited	by  the	 shell,	 minus
       any pairs removed by unset, plus	any modifications or additions,	all of
       which must be noted in export commands.

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



	      (export TERM; TERM=450;cmd)

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

       If  the -k option is set, all keyword arguments are placed in the envi-
       ronment,	even if	they occur after  the  command	name.	The  following
       first prints a=b	c and c:

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

       The  INTERRUPT  and  QUIT signals for an	invoked	command	are ignored if
       the command is followed by &; otherwise signals have the	values	inher-
       ited  by	 the  shell from its parent (but see also the trap command be-
       low).  INTERRUPT	is handled asynchronously.

       Each time a command is executed,	the above  substitutions  are  carried
       out.   If  the  command name matches one	of the Special Commands	listed
       below, it is executed in	the shell process.  If the command  name  does
       not  match  a  Special Command, but matches the name of a defined func-
       tion, the function is executed in the shell process (note how this dif-
       fers  from  the execution of shell procedures).	The positional parame-
       ters $1,	$2, ....  are set to the arguments of the  function.   If  the
       command	name  matches  neither a Special Command nor the name of a de-
       fined function, a new process is	created	and an attempt is made to exe-
       cute the	command	using execve(2V).

       The shell parameter PATH	defines	the search path	for the	directory con-
       taining the command.  Alternative directory names are  separated	 by  a
       colon  (:).   The  default  path	is :/usr/ucb:/bin:/usr/bin (specifying
       /usr/ucb, /bin, and /usr/bin, in	addition to  the  current  directory).
       Directories  are	searched in order.  The	current	directory is specified
       by a null path name, which can appear immediately after the equal  sign
       (PATH=:...),  between  the colon	delimiters (...::...) anywhere else in
       the path	list, or at the	end of the path	list (...:).  If  the  command
       name  contains a	/ the search path is not used.	Otherwise, each	direc-
       tory in the path	is searched for	an executable file.  If	the  file  has
       execute	permission  but	 is not	an binary executable (see a.out(5) for
       details)	or an executable script	(with a	first line beginning with  #!)
       it is assumed to	be a file containing shell commands, and a subshell is
       spawned to read it.  A parenthesized command is also executed in	a sub-

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

   Special Commands
       Input/output redirection	is now permitted for these commands.  File de-
       scriptor	1 is the default output	location.

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

       . filename     Read and execute commands	from filename and return.  The
		      search path specified by PATH is used to find the	direc-
		      tory containing filename.

       break [ n ]    Exit from	the enclosing for or while loop, if any.  If n
		      is specified break n levels.

       continue	[ n ] Resume  the next iteration of the	enclosing for or while
		      loop.  If	n is specified resume at  the  n'th  enclosing

       cd[ arg ]      Change the current directory to argument.	 The shell pa-
		      rameter HOME is the default argument.  The shell parame-
		      ter  CDPATH  defines  the	 search	path for the directory
		      containing argument.  Alternative	 directory  names  are
		      separated	 by  a	colon  (:).   The default path is NULL
		      (specifying the current directory).  Note:  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 ar-
		      gument begins with a / the  search  path	is  not	 used.
		      Otherwise,  each	directory  in the path is searched for

       echo [ argument ... ]
		      Echo arguments. See echo(1V) for usage and description.

       eval [ argument ... ]
		      The arguments are	read as	input to the shell and the re-
		      sulting command(s) executed.

       exec [ argument ... ]
		      The  command  specified  by the arguments	is executed in
		      place of this shell without creating a new process.  In-
		      put/output  arguments  may appear	and, if	no other argu-
		      ments are	given, modify the shell's input/output.

       exit [ n	]     Exit a shell with	the exit status	specified by n.	 If  n
		      is  omitted  the exit status is that of the last command
		      executed (an EOF will also cause the shell to exit.)

       export [	name ... ]
		      The given	names are marked for automatic export  to  the
		      environment  of  subsequently-executed  commands.	 If no
		      arguments	are  given,  variable  names  that  have  been
		      marked  for  export during the current shell's execution
		      are listed.  (Variable  names  exported  from  a	parent
		      shell  are  listed only if they have been	exported again
		      during the current shell's execution.)   Function	 names
		      are not exported.

       getopts	      Use  in shell scripts to parse positional	parameters and
		      check for	legal options.	See getopts(1) for  usage  and

       hash [ -r ] [ name ... ]
		      For  each	 name,	the location in	the search path	of the
		      command specified	by name	is determined  and  remembered
		      by  the shell.  The -r option causes the shell to	forget
		      all remembered locations.	 If no	arguments  are	given,
		      information  about  remembered  commands	is  presented.
		      hits is the number of times a command has	 been  invoked
		      by the shell process.  cost is a measure of the work re-
		      quired 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 loca-
		      tion  of	that  command  is  recalculated.  Commands for
		      which this will be done are indicated by an asterisk (*)
		      adjacent	to  the	hits information.  cost	will be	incre-
		      mented when the recalculation is done.

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

       newgrp [	argument ... ]
		      Equivalent  to `exec newgrp argument....'	 See newgrp(1)
		      for usage	and description.

       pwd	      Print the	current	working	directory.  See	pwd(1) for us-
		      age and description.

       read [ name ... ]
		      One  line	is read	from the standard input	and, using the
		      internal field separator,	IFS (normally a	SPACE  or  TAB
		      character),  to  delimit word boundaries,	the first word
		      is assigned to the first name, the second	 word  to  the
		      second  name,  etc., with	leftover words assigned	to the
		      last name.   Lines  can  be  continued  using  \NEWLINE.
		      Characters other than NEWLINE can	be quoted by preceding
		      them with	a backslash.  These  backslashes  are  removed
		      before  words  are assigned to names, and	no interpreta-
		      tion is done on the character  that  follows  the	 back-
		      slash.   The  return  code is 0 unless an	EOF is encoun-

       readonly	[ name ... ]
		      The given	names are marked readonly and  the  values  of
		      the these	names may not be changed by subsequent assign-
		      ment.  If	no arguments are given,	a list of all readonly
		      names is printed.

       return [	n ]   Exit  a  function	 with the return value specified by n.
		      If n is omitted, the return status is that of  the  last
		      command executed.

       set [ -aefhkntuvx- [ argument ... ] ]

		      -a     Mark  variables which are modified	or created for

		      -e     Exit immediately if a command exits with  a  non-
			     zero exit status.

		      -f     Disable filename generation.

		      -h     Locate  and  remember  function commands as func-
			     tions are defined (function commands are normally
			     located when the function is executed).

		      -k     All  keyword arguments are	placed in the environ-
			     ment for a	command, not just those	 that  precede
			     the command name.

		      -n     Read commands but do not execute them.

		      -t     Exit after	reading	and executing one command.

		      -u     Treat unset variables as an error when substitut-

		      -v     Print shell input lines as	they are read.

		      -x     Print commands and	their arguments	 as  they  are

		      --     Do	 not change any	of the options;	useful in set-
			     ting $1 to	`-'.

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

       shift [ n ]    The  positional parameters are shifted to	the left, from
		      position n+1 to position 1, and so on.  Previous	values
		      for  $1 through $n are discarded.	 If n is not given, it
		      is assumed to be 1.

       test	      Evaluate conditional expressions.	See test(1V) for usage
		      and description.

       times	      Print  the  accumulated  user  and system	times for pro-
		      cesses run from the shell.

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

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

       umask [ ooo ]
		      The user file-creation mode mask	is  set	 to  ooo  (see
		      csh(1)).	The three octal	digits refer to	read/write/ex-
		      ecute permissions	for owner, group, and others,  respec-
		      tively.  The value of each specified digit is subtracted
		      from the corresponding "digit" specified by  the	system
		      for  the creation	of a file.  For	example, umask 022 re-
		      moves group and others write permission (files  normally
		      created  with  mode  777	become mode 755; files created
		      with mode	666 become mode	644).  The  current  value  of
		      the mask is printed if ooo is omitted.

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

       wait [ n	]     Wait  for	 the  background process whose process ID is n
		      and report its termination status.  If n is omitted, all
		      the  shell's  currently  active background processes are
		      waited for and the return	code will be zero.

       Errors detected by the shell, such as syntax errors, return  a  nonzero
       exit  status.  If the shell is being used noninteractively execution of
       the shell file is abandoned.  Otherwise,	the  shell  returns  the  exit
       status of the last command executed (see	also the exit command above).

       The  environment	 variables  LC_CTYPE, LANG, and	LC_default control the
       character classification	throughout all command	line  parsing.	 These
       variables  are  checked	in  the	 following  order: LC_CTYPE, LANG, and
       LC_default.  When a valid value is found, remaining  environment	 vari-
       ables  for  character  classification  are ignored.  For	example, a new
       setting for LANG	does not override the current valid character  classi-
       fication	 rules	of  LC_CTYPE.	When  none of the values is valid, the
       shell character classification defaults to the POSIX.1 "C" locale.


       cd(1),  csh(1),	echo(1V),  env(1),  getopts(1),	 login(1),  newgrp(1),
       pwd(1),	test(1V),  wait(1),  dup(2V),  execve(2V), fork(2V), pipe(2V),
       sigvec(2), wait(2V), execl(3V), a.out(5), environ(5V), locale(5)

       Words used for filenames	in input/output	 redirection  are  not	inter-
       preted  for filename generation (see File Name Generation, above).  For
       example,	`cat file1 > a*' will create a file named `a*'.

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

       If you get the error message `cannot fork, too many processes', try us-
       ing the wait(1) command to clean	up your	background processes.  If this
       does  not  help,	 the system process table is probably full or you have
       too many	active foreground processes.  There is a limit to  the	number
       of process IDs associated with your login, and to the number the	system
       can keep	track of.

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

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

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

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

				2 October 1989				 SH(1)


Want to link to this manual page? Use this URL:

home | help