Source Code 1994 March/Source_Code_CD-ROM_Walnut_Creek_March_1994.iso/compsrcs/misc/volume35/zsh/part22

Text File | 1993-02-19 | 29.0 KB | 825 lines

Newsgroups: comp.sources.misc
From: [e-mail] (The Zsh Mailing List)
Subject: v35i072:  zsh - The Z Shell, version 2.3.1, Part22/22
Message-ID: <[e-mail]>
X-Md4-Signature: 24207d364cf40a5cab4565cfbb3ac370
Date: Sat, 20 Feb 1993 21:29:57 GMT
Approved: [e-mail]

Submitted-by: [e-mail] (The Zsh Mailing List)
Posting-number: Volume 35, Issue 72
Archive-name: zsh/part22
Environment: UNIX
Supersedes: zsh2.2: Volume 29, Issue 97-113

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then feed it
# into a shell via "sh file" or similar.  To overwrite existing files,
# type "sh file -c".
# The tool that generated this appeared in the comp.sources.unix newsgroup;
# send mail to [e-mail] if you want that tool.
# Contents:  dots/zlogin dots/zshenv func/acx func/cx func/harden
#   func/mere func/proto func/randline func/yp func/yu help/bg
#   help/break help/builtin help/chpwd help/continue help/coproc
#   help/disable help/disown help/echotc help/enable help/eval
#   help/exit help/export help/fg help/getln help/hash help/jobs
#   help/let help/log help/periodic help/precmd help/readonly
#   help/rehash help/repeat help/return help/sched help/shift
#   help/suspend help/test help/time help/times help/umask
#   help/unfunction help/unlimit help/until help/vared help/wait
#   help/while src/version.h
# Wrapped by mattson@odin on Sat Feb  6 14:41:56 1993
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
echo If this archive is complete, you will see the following message:
echo '          "shar: End of archive 22 (of 22)."'
if test -f 'dots/zlogin' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'dots/zlogin'\"
else
  echo shar: Extracting \"'dots/zlogin'\" \(247 characters\)
  sed "s/^X//" >'dots/zlogin' <<'END_OF_FILE'
Xclear
Xcd
Xstty dec new cr0 -tabs
Xttyctl -f  # freeze the terminal modes... can't change without a ttyctl -u
Xumask 022
Xexport MAIL=/usr/spool/mail/$USER
XMAILCHECK=60
Xmesg y
Xuptime
Xfortune
Xlog
Xfrom 2>/dev/null
Xcat notes
Xunlimit
Xlimit core 0
Xmsgs -fp
END_OF_FILE
  if test 247 -ne `wc -c <'dots/zlogin'`; then
    echo shar: \"'dots/zlogin'\" unpacked with wrong size!
  fi
  # end of 'dots/zlogin'
fi
if test -f 'dots/zshenv' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'dots/zshenv'\"
else
  echo shar: Extracting \"'dots/zshenv'\" \(123 characters\)
  sed "s/^X//" >'dots/zshenv' <<'END_OF_FILE'
Xpath=(~/scr ~/bin/$HOSTTYPE
X    /usr/princeton/bin /usr/ucb /usr/bin /bin
X    /usr/hosts /usr/princeton/bin/X11 /usr/etc /etc .)
END_OF_FILE
  if test 123 -ne `wc -c <'dots/zshenv'`; then
    echo shar: \"'dots/zshenv'\" unpacked with wrong size!
  fi
  # end of 'dots/zshenv'
fi
if test -f 'func/acx' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'func/acx'\"
else
  echo shar: Extracting \"'func/acx'\" \(104 characters\)
  sed "s/^X//" >'func/acx' <<'END_OF_FILE'
X#! /bin/sh
X#
X# zsh shell function to make its arguments 755
X# also works as an sh script
X#
Xchmod 755 $*
END_OF_FILE
  if test 104 -ne `wc -c <'func/acx'`; then
    echo shar: \"'func/acx'\" unpacked with wrong size!
  fi
  chmod +x 'func/acx'
  # end of 'func/acx'
fi
if test -f 'func/cx' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'func/cx'\"
else
  echo shar: Extracting \"'func/cx'\" \(109 characters\)
  sed "s/^X//" >'func/cx' <<'END_OF_FILE'
X#! /bin/sh
X#
X# zsh shell function to make its arguments executable
X# also works as a sh script
X#
Xchmod +x $*
END_OF_FILE
  if test 109 -ne `wc -c <'func/cx'`; then
    echo shar: \"'func/cx'\" unpacked with wrong size!
  fi
  chmod +x 'func/cx'
  # end of 'func/cx'
fi
if test -f 'func/harden' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'func/harden'\"
else
  echo shar: Extracting \"'func/harden'\" \(97 characters\)
  sed "s/^X//" >'func/harden' <<'END_OF_FILE'
X#! /bin/sh
X# harden a link (convert it to a singly linked file)
Xcp $1 $1.foo
Xrm $1
Xmv $1.foo $1
X
END_OF_FILE
  if test 97 -ne `wc -c <'func/harden'`; then
    echo shar: \"'func/harden'\" unpacked with wrong size!
  fi
  chmod +x 'func/harden'
  # end of 'func/harden'
fi
if test -f 'func/mere' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'func/mere'\"
else
  echo shar: Extracting \"'func/mere'\" \(84 characters\)
  sed "s/^X//" >'func/mere' <<'END_OF_FILE'
X#! /bin/sh
X# read a man page in the current directory
Xnroff -man -Tman $1 | less -s
END_OF_FILE
  if test 84 -ne `wc -c <'func/mere'`; then
    echo shar: \"'func/mere'\" unpacked with wrong size!
  fi
  chmod +x 'func/mere'
  # end of 'func/mere'
fi
if test -f 'func/proto' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'func/proto'\"
else
  echo shar: Extracting \"'func/proto'\" \(194 characters\)
  sed "s/^X//" >'func/proto' <<'END_OF_FILE'
X#! /bin/sh
X# generate prototypes, if your style is the same as mine
Xfor i
Xdo
X    rm $i:r.pro 2>/dev/null
X    grep -v '[{};:#]' $i | grep '^[A-Za-z]' |
X        grep -v static | sed 's/$/;/' >! $i:r.pro
Xdone
END_OF_FILE
  if test 194 -ne `wc -c <'func/proto'`; then
    echo shar: \"'func/proto'\" unpacked with wrong size!
  fi
  chmod +x 'func/proto'
  # end of 'func/proto'
fi
if test -f 'func/randline' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'func/randline'\"
else
  echo shar: Extracting \"'func/randline'\" \(80 characters\)
  sed "s/^X//" >'func/randline' <<'END_OF_FILE'
X# get a random line from a file
Xinteger z=$(wc -l <$1)
Xsed -n $[RANDOM%z+1]p $1
END_OF_FILE
  if test 80 -ne `wc -c <'func/randline'`; then
    echo shar: \"'func/randline'\" unpacked with wrong size!
  fi
  chmod +x 'func/randline'
  # end of 'func/randline'
fi
if test -f 'func/yp' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'func/yp'\"
else
  echo shar: Extracting \"'func/yp'\" \(29 characters\)
  sed "s/^X//" >'func/yp' <<'END_OF_FILE'
X#! /bin/sh
Xypmatch $1 passwd
END_OF_FILE
  if test 29 -ne `wc -c <'func/yp'`; then
    echo shar: \"'func/yp'\" unpacked with wrong size!
  fi
  chmod +x 'func/yp'
  # end of 'func/yp'
fi
if test -f 'func/yu' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'func/yu'\"
else
  echo shar: Extracting \"'func/yu'\" \(35 characters\)
  sed "s/^X//" >'func/yu' <<'END_OF_FILE'
X#! /bin/sh
Xypmatch $1 passwd.byuid
END_OF_FILE
  if test 35 -ne `wc -c <'func/yu'`; then
    echo shar: \"'func/yu'\" unpacked with wrong size!
  fi
  chmod +x 'func/yu'
  # end of 'func/yu'
fi
if test -f 'help/bg' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/bg'\"
else
  echo shar: Extracting \"'help/bg'\" \(145 characters\)
  sed "s/^X//" >'help/bg' <<'END_OF_FILE'
X     bg [ job ... ]
X     job ... &
X          Put each  specified  job  in  the  background,  or  the
X          current job if none is specified.
END_OF_FILE
  if test 145 -ne `wc -c <'help/bg'`; then
    echo shar: \"'help/bg'\" unpacked with wrong size!
  fi
  # end of 'help/bg'
fi
if test -f 'help/break' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/break'\"
else
  echo shar: Extracting \"'help/break'\" \(180 characters\)
  sed "s/^X//" >'help/break' <<'END_OF_FILE'
X     break [ n ]
X          Exit from an enclosing for, while,  until,  select,  or
X          repeat  loop.   If  n is specified, then break n levels
X          instead of just one.
END_OF_FILE
  if test 180 -ne `wc -c <'help/break'`; then
    echo shar: \"'help/break'\" unpacked with wrong size!
  fi
  # end of 'help/break'
fi
if test -f 'help/builtin' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/builtin'\"
else
  echo shar: Extracting \"'help/builtin'\" \(89 characters\)
  sed "s/^X//" >'help/builtin' <<'END_OF_FILE'
X     builtin name [ args ] ...
X          Executes the builtin name, with the given args.
END_OF_FILE
  if test 89 -ne `wc -c <'help/builtin'`; then
    echo shar: \"'help/builtin'\" unpacked with wrong size!
  fi
  # end of 'help/builtin'
fi
if test -f 'help/chpwd' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/chpwd'\"
else
  echo shar: Extracting \"'help/chpwd'\" \(96 characters\)
  sed "s/^X//" >'help/chpwd' <<'END_OF_FILE'
X     chpwd
X          Executed whenever  the  current  working  directory  is
X          changed.
END_OF_FILE
  if test 96 -ne `wc -c <'help/chpwd'`; then
    echo shar: \"'help/chpwd'\" unpacked with wrong size!
  fi
  # end of 'help/chpwd'
fi
if test -f 'help/continue' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/continue'\"
else
  echo shar: Extracting \"'help/continue'\" \(240 characters\)
  sed "s/^X//" >'help/continue' <<'END_OF_FILE'
X     continue [ num ]
X          Resume the next iteration of the enclosing for,  while,
X          until,  select,  or  repeat  loop.   If n is specified,
X          break out of n - 1 loops and resume at the nth  enclos-
X          ing loop.
END_OF_FILE
  if test 240 -ne `wc -c <'help/continue'`; then
    echo shar: \"'help/continue'\" unpacked with wrong size!
  fi
  # end of 'help/continue'
fi
if test -f 'help/coproc' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/coproc'\"
else
  echo shar: Extracting \"'help/coproc'\" \(264 characters\)
  sed "s/^X//" >'help/coproc' <<'END_OF_FILE'
X     If a pipeline is preceded by coproc, it  is  executed  as  a
X     coprocess;  a two-way pipe is established between it and the
X     parent shell.  The shell can  read  from  or  write  to  the
X     coprocess by means of the >&p and <&p redirection operators.
END_OF_FILE
  if test 264 -ne `wc -c <'help/coproc'`; then
    echo shar: \"'help/coproc'\" unpacked with wrong size!
  fi
  # end of 'help/coproc'
fi
if test -f 'help/disable' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/disable'\"
else
  echo shar: Extracting \"'help/disable'\" \(269 characters\)
  sed "s/^X//" >'help/disable' <<'END_OF_FILE'
X     disable arg ...
X          Disable the builtin arg temporarily.  This  allows  you
X          to  use  an  external  command  with the same name as a
X          shell builtin.  Actually the same as unhash.   Builtins
X          can be enabled with the enable command.
END_OF_FILE
  if test 269 -ne `wc -c <'help/disable'`; then
    echo shar: \"'help/disable'\" unpacked with wrong size!
  fi
  # end of 'help/disable'
fi
if test -f 'help/disown' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/disown'\"
else
  echo shar: Extracting \"'help/disown'\" \(248 characters\)
  sed "s/^X//" >'help/disown' <<'END_OF_FILE'
X     disown job ...
X          Remove the specified jobs from the job table; the shell
X          will  no  longer report their status, and will not com-
X          plain if you try to exit an interactive shell with them
X          running or stopped.
END_OF_FILE
  if test 248 -ne `wc -c <'help/disown'`; then
    echo shar: \"'help/disown'\" unpacked with wrong size!
  fi
  # end of 'help/disown'
fi
if test -f 'help/echotc' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/echotc'\"
else
  echo shar: Extracting \"'help/echotc'\" \(138 characters\)
  sed "s/^X//" >'help/echotc' <<'END_OF_FILE'
X     echotc cap [ arg ... ]
X          Output the termcap string corresponding to the capabil-
X          ity cap, with optional arguments.
END_OF_FILE
  if test 138 -ne `wc -c <'help/echotc'`; then
    echo shar: \"'help/echotc'\" unpacked with wrong size!
  fi
  # end of 'help/echotc'
fi
if test -f 'help/enable' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/enable'\"
else
  echo shar: Extracting \"'help/enable'\" \(124 characters\)
  sed "s/^X//" >'help/enable' <<'END_OF_FILE'
X     enable arg ...
X          Enable the specified builtin commands, presumably  dis-
X          abled earlier with disable.
END_OF_FILE
  if test 124 -ne `wc -c <'help/enable'`; then
    echo shar: \"'help/enable'\" unpacked with wrong size!
  fi
  # end of 'help/enable'
fi
if test -f 'help/eval' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/eval'\"
else
  echo shar: Extracting \"'help/eval'\" \(153 characters\)
  sed "s/^X//" >'help/eval' <<'END_OF_FILE'
X     eval [ arg ... ]
X          Read the arguments as input to the  shell  and  execute
X          the resulting command(s) in the current shell process.
END_OF_FILE
  if test 153 -ne `wc -c <'help/eval'`; then
    echo shar: \"'help/eval'\" unpacked with wrong size!
  fi
  # end of 'help/eval'
fi
if test -f 'help/exit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/exit'\"
else
  echo shar: Extracting \"'help/exit'\" \(275 characters\)
  sed "s/^X//" >'help/exit' <<'END_OF_FILE'
X     exit [ n ]
X          Exit the shell with the exit code specified  by  n;  if
X          none is specified, use the exit code from the last com-
X          mand executed.  An EOF condition will  also  cause  the
X          shell to exit, unless the IGNOREEOF option is set.
END_OF_FILE
  if test 275 -ne `wc -c <'help/exit'`; then
    echo shar: \"'help/exit'\" unpacked with wrong size!
  fi
  # end of 'help/exit'
fi
if test -f 'help/export' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/export'\"
else
  echo shar: Extracting \"'help/export'\" \(160 characters\)
  sed "s/^X//" >'help/export' <<'END_OF_FILE'
X     export [ name[=value] ... ]
X          The specified names are marked for automatic export  to
X          the environment of subsequently executed commands.
END_OF_FILE
  if test 160 -ne `wc -c <'help/export'`; then
    echo shar: \"'help/export'\" unpacked with wrong size!
  fi
  # end of 'help/export'
fi
if test -f 'help/fg' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/fg'\"
else
  echo shar: Extracting \"'help/fg'\" \(144 characters\)
  sed "s/^X//" >'help/fg' <<'END_OF_FILE'
X     fg [ job ... ]
X     job ...
X          Bring the specified jobs to the foreground.  If no  job
X          is specified, use the current job.
END_OF_FILE
  if test 144 -ne `wc -c <'help/fg'`; then
    echo shar: \"'help/fg'\" unpacked with wrong size!
  fi
  # end of 'help/fg'
fi
if test -f 'help/getln' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/getln'\"
else
  echo shar: Extracting \"'help/getln'\" \(147 characters\)
  sed "s/^X//" >'help/getln' <<'END_OF_FILE'
X     getln name ...
X          Read the top value from the buffer stack and put it  in
X          the shell parameter name.  Equivalent to read -zr.
END_OF_FILE
  if test 147 -ne `wc -c <'help/getln'`; then
    echo shar: \"'help/getln'\" unpacked with wrong size!
  fi
  # end of 'help/getln'
fi
if test -f 'help/hash' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/hash'\"
else
  echo shar: Extracting \"'help/hash'\" \(362 characters\)
  sed "s/^X//" >'help/hash' <<'END_OF_FILE'
X     hash name path
X          Puts name in the command  hash  table,  associating  it
X          with  the  pathname  path.   Whenever name is used as a
X          command argument, the shell will  try  to  execute  the
X          file given by path.
X     unhash name ...
X          The entry in the command hash table, if any,  for  each
X          name is removed.
END_OF_FILE
  if test 362 -ne `wc -c <'help/hash'`; then
    echo shar: \"'help/hash'\" unpacked with wrong size!
  fi
  # end of 'help/hash'
fi
if test -f 'help/jobs' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/jobs'\"
else
  echo shar: Extracting \"'help/jobs'\" \(202 characters\)
  sed "s/^X//" >'help/jobs' <<'END_OF_FILE'
X     jobs [ -lp ] [ job ... ]
X          Lists information about each given job, or all jobs  if
X          job is omitted.  The -l flag lists process ids, and the
X          -p flag lists process groups.
END_OF_FILE
  if test 202 -ne `wc -c <'help/jobs'`; then
    echo shar: \"'help/jobs'\" unpacked with wrong size!
  fi
  # end of 'help/jobs'
fi
if test -f 'help/let' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/let'\"
else
  echo shar: Extracting \"'help/let'\" \(277 characters\)
  sed "s/^X//" >'help/let' <<'END_OF_FILE'
X     let arg ...
X          Evaluate each arg as  an  arithmetic  expression.   See
X          ARITHMETIC EVALUATION above for a description of arith-
X          metic expressions.  The exit status is 0 if  the  value
X          of the last expression is nonzero, and 1 otherwise.
END_OF_FILE
  if test 277 -ne `wc -c <'help/let'`; then
    echo shar: \"'help/let'\" unpacked with wrong size!
  fi
  # end of 'help/let'
fi
if test -f 'help/log' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/log'\"
else
  echo shar: Extracting \"'help/log'\" \(120 characters\)
  sed "s/^X//" >'help/log' <<'END_OF_FILE'
X     log  List all users currently logged in who are affected  by
X          the current setting of the watch parameter.
END_OF_FILE
  if test 120 -ne `wc -c <'help/log'`; then
    echo shar: \"'help/log'\" unpacked with wrong size!
  fi
  # end of 'help/log'
fi
if test -f 'help/periodic' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/periodic'\"
else
  echo shar: Extracting \"'help/periodic'\" \(140 characters\)
  sed "s/^X//" >'help/periodic' <<'END_OF_FILE'
X     periodic
X          If the parameter PERIOD is set, this function  is  exe-
X          cuted every PERIOD seconds, just before a prompt.
END_OF_FILE
  if test 140 -ne `wc -c <'help/periodic'`; then
    echo shar: \"'help/periodic'\" unpacked with wrong size!
  fi
  # end of 'help/periodic'
fi
if test -f 'help/precmd' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/precmd'\"
else
  echo shar: Extracting \"'help/precmd'\" \(51 characters\)
  sed "s/^X//" >'help/precmd' <<'END_OF_FILE'
X     precmd
X          Executed before each prompt.
END_OF_FILE
  if test 51 -ne `wc -c <'help/precmd'`; then
    echo shar: \"'help/precmd'\" unpacked with wrong size!
  fi
  # end of 'help/precmd'
fi
if test -f 'help/readonly' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/readonly'\"
else
  echo shar: Extracting \"'help/readonly'\" \(148 characters\)
  sed "s/^X//" >'help/readonly' <<'END_OF_FILE'
X     readonly [ name[=value] ] ...
X          The given names are marked readonly; these names cannot
X          be changed by subsequent assignment.
END_OF_FILE
  if test 148 -ne `wc -c <'help/readonly'`; then
    echo shar: \"'help/readonly'\" unpacked with wrong size!
  fi
  # end of 'help/readonly'
fi
if test -f 'help/rehash' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/rehash'\"
else
  echo shar: Extracting \"'help/rehash'\" \(234 characters\)
  sed "s/^X//" >'help/rehash' <<'END_OF_FILE'
X     rehash [ -f ]
X          Throw out the command hash table and  start  over.   If
X          the  -f  option is set, rescan the command path immedi-
X          ately, instead of rebuilding the hash  table  incremen-
X          tally.
END_OF_FILE
  if test 234 -ne `wc -c <'help/rehash'`; then
    echo shar: \"'help/rehash'\" unpacked with wrong size!
  fi
  # end of 'help/rehash'
fi
if test -f 'help/repeat' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/repeat'\"
else
  echo shar: Extracting \"'help/repeat'\" \(247 characters\)
  sed "s/^X//" >'help/repeat' <<'END_OF_FILE'
X      repeat word
X      do list
X      done word is expanded  and  treated  as  an  arithmetic
X       expression,  which  must  evaluate  to a number n.
X       list is then executed n times.
X
X      repeat word sublist
X       This is a short form of repeat.
END_OF_FILE
  if test 247 -ne `wc -c <'help/repeat'`; then
    echo shar: \"'help/repeat'\" unpacked with wrong size!
  fi
  # end of 'help/repeat'
fi
if test -f 'help/return' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/return'\"
else
  echo shar: Extracting \"'help/return'\" \(249 characters\)
  sed "s/^X//" >'help/return' <<'END_OF_FILE'
X     return [ n ]
X          Causes a shell function or . script to  return  to  the
X          invoking  script with the return status specified by n.
X          If n is omitted then the return status is that  of  the
X          last command executed.
END_OF_FILE
  if test 249 -ne `wc -c <'help/return'`; then
    echo shar: \"'help/return'\" unpacked with wrong size!
  fi
  # end of 'help/return'
fi
if test -f 'help/sched' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/sched'\"
else
  echo shar: Extracting \"'help/sched'\" \(357 characters\)
  sed "s/^X//" >'help/sched' <<'END_OF_FILE'
X     sched [+]hh:mm command ...
X     sched [ -item ]
X          Make an entry in the scheduled list of commands to exe-
X          cute.   The time may be specified in either absolute or
X          relative time.  With no arguments, prints the  list  of
X          scheduled  commands.   With the argument -item, removes
X          the given item from the list.
END_OF_FILE
  if test 357 -ne `wc -c <'help/sched'`; then
    echo shar: \"'help/sched'\" unpacked with wrong size!
  fi
  # end of 'help/sched'
fi
if test -f 'help/shift' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/shift'\"
else
  echo shar: Extracting \"'help/shift'\" \(149 characters\)
  sed "s/^X//" >'help/shift' <<'END_OF_FILE'
X     shift [ n ]
X          The positional parameters from $n+1 ... are renamed $1,
X          where n is an arithmetic expression that defaults to 1.
END_OF_FILE
  if test 149 -ne `wc -c <'help/shift'`; then
    echo shar: \"'help/shift'\" unpacked with wrong size!
  fi
  # end of 'help/shift'
fi
if test -f 'help/suspend' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/suspend'\"
else
  echo shar: Extracting \"'help/suspend'\" \(204 characters\)
  sed "s/^X//" >'help/suspend' <<'END_OF_FILE'
X     suspend [ -f ]
X          Suspend the execution of the shell (send it a  SIGTSTP)
X          until  it  receives a SIGCONT.  If the -f option is not
X          given, complain if this is a login shell.
END_OF_FILE
  if test 204 -ne `wc -c <'help/suspend'`; then
    echo shar: \"'help/suspend'\" unpacked with wrong size!
  fi
  # end of 'help/suspend'
fi
if test -f 'help/test' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/test'\"
else
  echo shar: Extracting \"'help/test'\" \(153 characters\)
  sed "s/^X//" >'help/test' <<'END_OF_FILE'
X     test arg ...
X     [ arg ... ]
X          Like the system version of test.  Added for compatibil-
X          ity; use conditional expressions instead.
END_OF_FILE
  if test 153 -ne `wc -c <'help/test'`; then
    echo shar: \"'help/test'\" unpacked with wrong size!
  fi
  # end of 'help/test'
fi
if test -f 'help/time' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/time'\"
else
  echo shar: Extracting \"'help/time'\" \(271 characters\)
  sed "s/^X//" >'help/time' <<'END_OF_FILE'
X      time [ pipeline ]
X       The pipeline is executed,  and  timing  statistics
X       are  reported  on  the  standard error in the form
X       specified by the TIMEFMT parameter.   If  pipeline
X       is  omitted, print statistics about the shell pro-
X       cess and its children.
END_OF_FILE
  if test 271 -ne `wc -c <'help/time'`; then
    echo shar: \"'help/time'\" unpacked with wrong size!
  fi
  # end of 'help/time'
fi
if test -f 'help/times' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/times'\"
else
  echo shar: Extracting \"'help/times'\" \(131 characters\)
  sed "s/^X//" >'help/times' <<'END_OF_FILE'
X     times
X          Print the accumulated user and  system  times  for  the
X          shell and for processes run from the shell.
END_OF_FILE
  if test 131 -ne `wc -c <'help/times'`; then
    echo shar: \"'help/times'\" unpacked with wrong size!
  fi
  # end of 'help/times'
fi
if test -f 'help/umask' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/umask'\"
else
  echo shar: Extracting \"'help/umask'\" \(212 characters\)
  sed "s/^X//" >'help/umask' <<'END_OF_FILE'
X     umask [ mask ]
X          The umask is set to mask.  mask can be either an  octal
X          number  or  a  symbolic value as described in chmod(1).
X          If mask is omitted, the current value is printed.
END_OF_FILE
  if test 212 -ne `wc -c <'help/umask'`; then
    echo shar: \"'help/umask'\" unpacked with wrong size!
  fi
  # end of 'help/umask'
fi
if test -f 'help/unfunction' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/unfunction'\"
else
  echo shar: Extracting \"'help/unfunction'\" \(110 characters\)
  sed "s/^X//" >'help/unfunction' <<'END_OF_FILE'
X     unfunction name ...
X          The function definition,  if  any,  for  each  name  is
X          removed.
END_OF_FILE
  if test 110 -ne `wc -c <'help/unfunction'`; then
    echo shar: \"'help/unfunction'\" unpacked with wrong size!
  fi
  # end of 'help/unfunction'
fi
if test -f 'help/unlimit' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/unlimit'\"
else
  echo shar: Extracting \"'help/unlimit'\" \(253 characters\)
  sed "s/^X//" >'help/unlimit' <<'END_OF_FILE'
X     unlimit [ -h ] resource ...
X          The resource limit for each resource is set to the hard
X          limit.   If  the -h flag is given and the shell is run-
X          ning as root, the hard resource limit for each resource
X          is removed.
END_OF_FILE
  if test 253 -ne `wc -c <'help/unlimit'`; then
    echo shar: \"'help/unlimit'\" unpacked with wrong size!
  fi
  # end of 'help/unlimit'
fi
if test -f 'help/until' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/until'\"
else
  echo shar: Extracting \"'help/until'\" \(120 characters\)
  sed "s/^X//" >'help/until' <<'END_OF_FILE'
X      until list
X      do list
X      done Execute the do list as long as until list  returns
X       a nonzero exit status.
END_OF_FILE
  if test 120 -ne `wc -c <'help/until'`; then
    echo shar: \"'help/until'\" unpacked with wrong size!
  fi
  # end of 'help/until'
fi
if test -f 'help/vared' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/vared'\"
else
  echo shar: Extracting \"'help/vared'\" \(236 characters\)
  sed "s/^X//" >'help/vared' <<'END_OF_FILE'
X     vared name
X          The value of the parameter name is loaded into the edit
X          buffer,  and the line editor is invoked.  When the edi-
X          tor exits, name is set to the string value returned  by
X          the editor.
END_OF_FILE
  if test 236 -ne `wc -c <'help/vared'`; then
    echo shar: \"'help/vared'\" unpacked with wrong size!
  fi
  # end of 'help/vared'
fi
if test -f 'help/wait' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/wait'\"
else
  echo shar: Extracting \"'help/wait'\" \(352 characters\)
  sed "s/^X//" >'help/wait' <<'END_OF_FILE'
X     wait [ job ... ]
X          Wait for the specified jobs or processes.   If  job  is
X          not given then all currently active child processes are
X          waited for.  Each job can be either a job specification
X          or  the process-id of a job in the job table.  The exit
X          status from this command is that of the job waited for.
END_OF_FILE
  if test 352 -ne `wc -c <'help/wait'`; then
    echo shar: \"'help/wait'\" unpacked with wrong size!
  fi
  # end of 'help/wait'
fi
if test -f 'help/while' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help/while'\"
else
  echo shar: Extracting \"'help/while'\" \(199 characters\)
  sed "s/^X//" >'help/while' <<'END_OF_FILE'
X      while list
X      do list
X      done Execute the do list as  long  as  the  while  list
X       returns a zero exit status.
X
X      while ( list ) {
X      list
X      }    An alternate form of while.
END_OF_FILE
  if test 199 -ne `wc -c <'help/while'`; then
    echo shar: \"'help/while'\" unpacked with wrong size!
  fi
  # end of 'help/while'
fi
if test -f 'src/version.h' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'src/version.h'\"
else
  echo shar: Extracting \"'src/version.h'\" \(32 characters\)
  sed "s/^X//" >'src/version.h' <<'END_OF_FILE'
X#define VERSIONSTR "zsh v2.3.1"
END_OF_FILE
  if test 32 -ne `wc -c <'src/version.h'`; then
    echo shar: \"'src/version.h'\" unpacked with wrong size!
  fi
  # end of 'src/version.h'
fi
echo shar: End of archive 22 \(of 22\).
cp /dev/null ark22isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 22 archives.
    rm -f ark[1-9]isdone ark[1-9][0-9]isdone
    echo Concatenating pieces...
    cat doc/intro.troff.0[1-9] >doc/intro.troff && rm doc/intro.troff.0[1-9]
    cat doc/intro.txt.0[1-9] >doc/intro.txt && rm doc/intro.txt.0[1-9]
    cat doc/zsh.texi.0[1-9] >doc/zsh.texi && rm doc/zsh.texi.0[1-9]
    cat man/man1/zsh.1.0[1-9] >man/man1/zsh.1 && rm man/man1/zsh.1.0[1-9]
    cat src/builtin.c.0[1-9] >src/builtin.c && rm src/builtin.c.0[1-9]
else
    echo You still must unpack the following archives:
    echo "        " ${MISSING}
fi
exit 0

exit 0 # Just in case...