




Command:   sh, ., break, case, cd, continue, eval, exec,  exit,  export,
                for,  if, read, readonly, set, shift, trap, umask, wait,
                while - shell
Syntax:    sh [-eiknqstvxu] [-c str] [file]
Flags:     -c  Execute the commands in str
           -e  Quit on error
           -i  Interactive mode; ignore QUIT, TERMINATE, INTERRUPT
           -k  Look for name=value everywhere on command line
           -n  Do not execute commands
           -q  Change qflag from sig_ign to sig_del
           -s  Read commands from standard input
           -t  Exit after reading and executing one command
           -v  Echo input lines as they are read
           -x  Trace
           -u  Unset variables
Example:   sh script                # Run a shell script

     Sh is the shell, which forms the user's  main  interface  with  the
system.  On startup, the shell reads /etc/profile and $HOME/.profile, if
they exist, and executes any commands they contain.  The Minix shell has
most  of the features of the V7 (Bourne) shell, including redirection of
input and output, pipes, magic  characters,  background  processes,  and
shell  scripts.   A  brief  summary  follows,  but whole books have been
written on shell programming alone.

Some of the more common notations are:

   date                    # Regular command
   sort <file              # Redirect stdin (standard input)
   sort <file1  >file2     # Redirect stdin and stdout
   cc file.c  2>error      # Redirect stderr
   a.out >f  2>&1          # Combine standard output and standard error
   sort <file1  >>file2    # Append output to file2
   sort <file1  >file2 &   # Background job
   (ls -l; a.out) &        # Run two background commands sequentially
   sort <file | wc         # Two-process pipeline
   sort <f | uniq | wc     # Three-process pipeline
   ls -l *.c               # List all files ending in .c
   ls -l [a-c]*            # List all files beginning with a, b, or c
   ls -l ?                 # List all one-character file names
   ls \?                   # List the file whose name is question mark
   ls '???'                # List the file whose name is three  question
                             marks
   v=/usr/ast              # Set shell variable v
   ls -l $v                # Use shell variable v
   PS1='Hi! '              # Change the primary prompt to Hi!
   PS2='More: '            # Change the secondary prompt to More:
   ls -l $HOME             # List the home directory
   echo $PATH              # Echo the search path
   echo $?                 # Echo exit status  of  previous  command  in
                             decimal
   echo $$                 # Echo shell's pid in decimal
   echo $!                 # Echo PID of last background process
   echo $#                 # Echo number of parameters (shell script)
   echo $2                 # Echo second parameter (shell script)
   echo "$2"               # Echo  second  parameter  without  expanding


                                                                        



                                                                        


                             spaces
   echo $*                 # Echo all parameters (shell script)
   echo $@                 # Echo all parameters (shell script)
   echo "$@"               # Echo  all  parameters   without   expanding
                             spaces

The shell uses the following variables for specific purposes:

   SHELL                   the path of the current shell
   HOME                    the default value for the cd(1) command
   PATH                    the  directories  to  be  searched  to   find
                           commands
   IFS                     the internal  field  separators  for  command
                           strings
   PS1                     the primary shell prompt
   PS2                     the secondary shell prompt

There are various forms of substitution on the shell command line:

   `...`                   Command   string   between   back-quotes   is
                           replaced by its output
   "..."                   Permits variable substitution between quotes
   '...'                   Inhibits variable substitution between quotes
   $VAR                    Replaced by contents of variable VAR
   ${VAR}                  Delimits  variable  VAR  from  any  following
                           string

The expressions below depend on whether or not VAR has  ever  been  set.
If VAR has been set, they give:

   ${VAR-str}              Replace expression by VAR, else by str
   ${VAR=str}              Replace expression by VAR, else  by  str  and
                           set VAR to str
   ${VAR?str}              Replace expression by VAR, else print str and
                           exit shell
   ${VAR+str}              Replace  expression  by  str,  else  by  null
                           string

If a colon is placed after VAR, the expressions depend on whether or not
VAR is currently set and non-null.

The shell has a number of built-in commands:

   :                       return true status
   . fn                    execute shell script fn on current path
   break [n]               break from a for, until or while loop; exit n
                           levels
   continue [n]            continue a for, until or while  loop;  resume
                           nth loop
   cd [dir]                change current  working  directory;  move  to
                           $HOME
   eval cmd                rescan cmd, performing substitutions
   eval                    rescan the current command line
   exec cmd                execute cmd without creating a new process
   exec <|>                with no command name, modify shell I/O
   exit [n]                exit a shell program, with exit value n


                                                                        



                                                                        


   export [var]            export var to shell's children; list exported
                           variables
   pwd                     print  the  name  of  the   current   working
                           directory
   read var                read a line from stdin and assign to var
   readonly [var]          make var readonly; list readonly variables
   set -f                  set shell flag (+f unsets flag)
   set str                 set positional parameter to str
   set                     show the current shell variables
   shift                   reassign positional parameters (except  ${0})
                           one left
   times                   print accumulated user and system  times  for
                           processes
   trap arg sigs           trap signals sigs and run arg on receipt
   trap                    list trapped signals
   umask [n]               set the user file  creation  mask;  show  the
                           current umask
   wait [n]                wait  for  process  pid  n;  wait   for   all
                           processes

The shell also contains a programming language, which has the  following
operators and flow control statements:

   #                       Comment        The  rest  of  the   line   is
                                          ignored
   =                       Assignment     Set a shell variable
   &&                      Logical AND    Execute second command only if
                                          first succeeds
   ||                      Logical OR     Execute second command only if
                                          first fails
   (...)                   Group          Execute   enclosed    commands
                                          before continuing

   for                     For loop (for ... in ... do ... done)
   case                    Case statement ((case ... ) ... ;; ... esac)
   esac                    Case statement end
   while                   While loop (while ... do ... done)
   do                      Do/For/While loop start (do ... until ...)
   done                    For/While loop end
   if                      Conditional statement (if ... else  ...  elif
                           ... fi)
   in                      For loop selection
   then                    Conditional statement start
   else                    Conditional statement alternative
   elif                    Conditional statement end
   until                   Do loop end
   fi                      Conditional statement end











                                                                        

