zsh-3.1.5-pws-3 zsh-3.1.5-pws-3

4 files changed, 1288 insertions, 44 deletions

diff --git a/Misc/globtests b/Misc/globtests
index b7d5fd0bd..9a12a11e1 100755
--- a/Misc/globtests
+++ b/Misc/globtests
@@ -112,5 +112,6 @@ t fooxx         ((#i)FOOX)x
 f fooxx         ((#i)FOOX)X
 f BAR           (bar|(#i)foo)
 t FOO           (bar|(#i)foo)
+t Modules       (#i)*m*
 EOT
 print "$failed tests failed."
diff --git a/Misc/globtests.ksh b/Misc/globtests.ksh
index da5145845..839637af4 100755
--- a/Misc/globtests.ksh
+++ b/Misc/globtests.ksh
@@ -96,5 +96,6 @@ t fooxx         @((#i)FOOX)x
 f fooxx         @((#i)FOOX)X
 f BAR           @(bar|(#i)foo)
 t FOO           @(bar|(#i)foo)
+t Modules       (#i)*m*
 EOT
 print "$failed tests failed."
diff --git a/Misc/lete2ctl b/Misc/lete2ctl
index 273ea4674..ca00b8aee 100755
--- a/Misc/lete2ctl
+++ b/Misc/lete2ctl
@@ -9,7 +9,6 @@
 # Runs as a filter.  Should ignore anything which isn't a "complete".
 # It expects each "complete" statement to be the first thing on a line.
 # All the examples in the tcsh manual give sensible results.
-# Author:  Peter Stephenson <pws@ibmth.df.unipi.it>
 #
 # Option:
 # -x (exact): only applies in the case of command disambiguation (is
@@ -39,11 +38,6 @@
 # (5) Make sure all command names with wildcards are processed together --
 #     they need to be lumped into one "compctl -C" or "compctl -D"
 #     statement for zsh.
-# (6) Group completion (complete's g flag) is not built into zsh, so
-#     you need perl to be available to generate the groups.  If this
-#     script is useful, I assume that's not a problem.
-# (7) I don't know what `completing completions' means, so the X
-#     flag to complete is not handled.
 
 # Handle options
 if (@ARGV) {
@@ -119,13 +113,6 @@ sub gettype {
 # Nothing (n) can be handled by returning nothing.  (C.f. King Lear, I.i.)
     if ($c =~ /[abcjuv]/) {
 	$ret = "-$c";
-    } elsif ($c eq 'C') {
-	if (defined($glob)) {
-	    $ret = "-W $glob -/g '*(.*)'";
-	    undef($glob);
-	} else {
-	    $ret = '-c';
-	}
     } elsif ($c eq 'S') {
 	$ret = '-k signals';
     } elsif ($c eq 'd') {
@@ -134,42 +121,18 @@ sub gettype {
 	} else {
 	    $ret = '-/';
 	}
-    } elsif ($c eq 'D') {
-	if (defined($glob)) {
-	    $ret = "-W $glob -/";
-	    undef($glob);
-	} else {
-	    $ret = '-/';
-	}
     } elsif ($c eq 'e') {
 	$ret = '-E';
     } elsif ($c eq 'f' && !$glob) {
 	$ret = '-f';
-    } elsif ($c eq 'F') {
-	if (defined($glob)) {
-	    $ret = "-W $glob -f";
-	    undef($glob);
-	} else {
-	    $ret = '-f';
-	}
-    } elsif ($c eq 'g') {
-	$ret = "-s '\$(perl -e '\\''while ((\$name) = getgrent)\n" .
-	    "{ print \$name, \"\\n\"; }'\\'')'";
     } elsif ($c eq 'l') {
 	$ret = q!-k "(`limit | awk '{print $1}'`)"!;
     } elsif ($c eq 'p') {
-        $ret = "-W $glob -f", undef($glob) if defined($glob);
+	$ret = "-W $glob -f", undef($glob) if defined($glob);
     } elsif ($c eq 's') {
-        $ret = '-p';
+	$ret = '-p';
     } elsif ($c eq 't') {
 	$qual = '.';
-    } elsif ($c eq 'T') {
-        if (defined($glob)) {
-            $ret = "-W $glob -g '*(.)'";
-            undef($glob);
-        } else {
-            $ret = "-g '*(.)'";
-        }
     } elsif ($c eq 'x') {
 	$glob =~ s/'/'\\''/g;
 	$ret = "-X '$glob'";
@@ -227,7 +190,7 @@ $" = " - ";
 
 while (<>) {
     if (/^\s*complete\s/) {
-	undef(@stuff);
+	undef(@stuff); 
 	$default = '';
 	$_ = $';
 	while (/\\$/) {
@@ -248,7 +211,7 @@ while (<>) {
 	    # Loop over remaining arguments to "complete".
 	    $sep = substr($word,1,1);
 	    $sep =~ s/(\W)/\\$1/g;
-	    @split = split(/$sep/,$word,4);
+	    @split = split(/$sep/,$word);
 	    for ($i = 0; $i < 3; $i++) {
 		while ($split[$i] =~ /\\$/) {
 		    substr($split[$i],-1,1) = "";
@@ -262,9 +225,7 @@ while (<>) {
 		 # The "complete" catch-all:  treat this as compctl\'s
 		 # default (requiring no pattern matching).
 		$default .= &gettype($type) . ' ';
-		defined($suffix) &&
-		    (defined($defsuf) ? ($defsuf .= $suffix)
-		     : ($defsuf = $suffix));
+		defined($suffix) && ($defsuf .= $suffix);
 	    } else {
 		$pat = &getpat($pat,$arg);
 		$type = &gettype($type);
diff --git a/Misc/zftp-functions b/Misc/zftp-functions
new file mode 100644
index 000000000..a07e46d72
--- /dev/null
+++ b/Misc/zftp-functions
@@ -0,0 +1,1281 @@
+# zftp is a loadable module implementing an FTP client as a builtin
+# command so that you can use the shell command language and line
+# editing to make life easier.  If your system has dynamically
+# load libraries and zsh was compiled to use them, it is probably
+# somewhere where it can be loaded at run time.  Otherwise, it depends
+# whether the shell was compiled with zftp already built into it.
+#
+# Here is a suite of functions, plus assorted other code, to make
+# zftp work smoothly.
+#
+# Completion is implemented in a fairly natural way, except that
+# very little support has been provided for non-UNIX remote hosts.
+# On such machines, the safest thing to do is only try to complete
+# files in the current directory; this should be OK.
+#
+# Remote globbing for commands which retrieve files is also
+# implemented.  This can be done in two different ways.  The default
+# is for zsh to do the globbing locally.  The advantage is that full
+# zsh pattern matching (respecting the setting of extendedglob) is
+# possible, and no assumption (apart from the restrictions on
+# directory handling noted above) is made about the behaviour of the
+# server.  The disadvantage is that the entire filename list for the
+# current directory must be retrieved, and then zsh must laboriously
+# do pattern matching against every file, so it is potentially slow
+# for large directories.  Only the non-directory part of file names is
+# globbed.
+#
+# The alternative will be used if $zfrglob has non-zero length.
+# Zsh then sends the pattern to the server for globbing.  Best of
+# luck.
+#
+# To support remote globbing, some functions have been aliased
+# with 'noglob' in front.  Currently, this has a dire effect on
+# completion unless the completeinaliases option is set, so
+# it is set below.  This can conceivably cause you problems
+# if you expect completion for aliases automatically to give you
+# completion for the base command.  I suspect that most people
+# don't even know that happens.
+#
+# The following functions are provided.
+#
+# General status changing and displaying functions:
+# zfparams
+#   Simple front end to `zftp params', except it will automatically
+#   query host, user and password.  These are then stored to be
+#   used with a `zfopen' with no arguments.
+# zfopen [ host [ user ... ] ]
+#   Open a connection and login.  Unless the option -1 (once)
+#   is given, will store the parameters for the open (including
+#   a password which is prompted for and not echoed) so that
+#   if you call zfopen subsequently without arguments it will
+#   reopen the same connection.
+# zfanon anonftphost
+#   Open a connection for anonymous FTP.  Tries to guess an
+#   email address to use as the password, unless $EMAIL_ADDR is
+#   already set.  The first time, will tell you what it has guessed.
+#   It's rude to set EMAIL_ADDR=mozilla.
+# zfcd [ dir | old new ]
+#   Change directory on the server.  This tries to mimic the behaviour
+#   of the shell's cd.  In particular,
+#    zfcd           change to '~' on server, if it interprets it
+#    zfcd -         change to previous directory of current connection
+#    zfcd OLD NEW   change directory from fooOLDbar to fooNEWbar
+#   One piece of magic is builtin:  an initial part of the directory
+#   matching $HOME is translated back to `~'.  Most UNIX servers
+#   recognise the usual shell convention.  So things like `zfcd $PWD'
+#   is useful provide you are under your home directory and the
+#   structure on the remote machine mirrors that on the local.
+# zfhere
+#   Synonym for `zfcd $PWD', see above.
+# zfdir [args]
+#   Show a long diretory list of the remote connection.  Any
+#   arguments are passed on to the server, apart from options.
+#   Currently this always uses a pager to show the directory
+#   list.  Caching is implemented:  zfdir on its own always shows
+#   the current diretory, which is cached; zfdir with some other
+#   directory arguments shows that, which is cached separately
+#   and can be reviewed with `zfdir -r'.  Other options:
+#    -f  force reget, overriding the cache, in case something's changed
+#    -d  delete the cache, but don't show anything.
+#   To pass options to the server, use e.g. `zfdir -- -C'.
+#   This also has the zfcd ~ hack.
+# zfls [args]
+#   Short list of the long directory, depending on what [args]
+#   do to the server.  No options, no caching, no pager.
+# zftype [ a[scii] | i[mage] | b[inary] ]
+#   Set or display the transfer type; currently only ASCII
+#   and image (same as binary) types are supported.
+# zfclose
+#   Close the connection.
+# zfstat
+#   Print the zftp status from local variables; doesn't do any network
+#   operations unless -v is supplied, in which case the server is
+#   asked for its views on the status, too.
+#
+# Functions for retrieving data:
+#   All accept the following options:
+#    -G   Don't do remote globbing (see above); the default is to do it.
+#    -t   Try to set local files to the same time as the remote ones.
+#         Unfortunately we only know the remote time in GMT, so it's
+#         a little tricky and you need perl 5 (installed as `perl')
+#         for this to work.  Suggestions welcome.
+# zfget file1 file2 ...
+#   Retrieve each file from the server.  The remote file is the
+#   full name given, the local file is the non-directory part of that
+#   (assuming UNIX file paths).
+# zfuget file1 file2 ..
+#   Get with update.  Check remote and local sizes and times and
+#   retrieve files which are newer on the server.  Will query
+#   hard cases, which are where the remote file is newer but a
+#   different size, or is older but the same size.  With option -s
+#   (silent) assumes it's best to retrieve the files in both those
+#   cases.  With -v (may be combined with -s), print the information
+#   about the files being considered.
+# zfcget file1 ...
+#   Assuming file1 was incompletely retrieved, try to get the rest of
+#   it.  This relies on a normal UNIX server behaviour which is not
+#   as specified in the FTP standard and hence is not universal.
+# zfgcp file1 file2
+# zfgcp file1 file2 ... dir
+#   Get with the behaviour of cp, i.e. copy remote file1 to local
+#   file2, or get remote fileN into local diretory dir.
+#
+# Function for sending data:
+# zfput file1 file2 ...
+#   Put the local files onto the server under the same name.  The
+#   local files are exactly as given; the remote files are the
+#   non-diretory parts of that. 
+# zfuput file1 file2 ..
+#   Put the local files onto the server, with update.  Works
+#   similarly to zfuget.
+#
+# Utility functions:
+# zftp_chpwd
+#   Show the new directory when it changes; try to put it into
+#   an xterm on shelltool header.  Works best alongside chpwd.
+# zftp_progress
+#   Show the percentage of a file retrieved as it is coming; if the
+#   size is not available show the size transferred so far.  The
+#   percentage may be wrong if sending data from a local pipe.
+#   If you transfer files in the background, you should undefine
+#   this before the transfer.  It is smart enough not to print
+#   anything when stderr is not a terminal.
+# zfcd_match
+#   Function for remote directory completion.
+# zfget_match
+#   Function for remote filename completion.
+# zfrglob varname
+#   This is used for the remote globbing.  The pattern resides
+#   in $varname (note extra level of indirection), and on return
+#   $varname will contain the list of matching files.
+# zfrtime locfile remfile [ time ]
+#   This sad thing does the setting of local file times to those
+#   of the remote, see horror story above.
+
+zmodload -ia zftp
+
+alias zfcd='noglob zfcd'
+alias zfget='noglob zfget'
+alias zfls='noglob zfls'
+alias zfdir='noglob zfdir'
+alias zfuget='noglob zfuget'
+# only way of getting that noglob out of the way at the moment
+setopt completealiases
+
+#
+# zftp completions
+#
+compctl -f -x 'p[1]' \
+  -k '(open params user login type ascii binary mode put putat
+  get getat append appendat ls dir local remote mkdir rmdir delete
+  close quit)'  - \
+  'w[1,cd][1,ls][1,dir][1,rmdir]' -K zfcd_match -S/ -q - \
+  'W[1,get*]' -K zfget_match - 'w[1,delete][1,remote]' -K zfget_match - \
+  'w[1,open][1,params]' -k hosts -- zftp
+compctl -K zfcd_match -S/ -q zfcd zfdir zfls
+compctl -K zfget_match zfget zfgcp zfuget zfcget
+compctl -k hosts zfopen zfparams
+
+function zfanon {
+  local opt optlist once
+  
+  while [[ $1 = -* ]]; do
+    if [[ $1 = - || $1 = -- ]]; then
+      shift;
+      break;
+    fi
+    optlist=${1#-}
+    for (( i = 1; i <= $#optlist; i++)); do
+      opt=$optlist[$i]
+      case $optlist[$i] in
+        1) once=1
+  	 ;;
+        *) print option $opt not recognised >&2
+  	 ;;
+      esac
+    done
+    shift
+  done
+  
+  if [[ -z $EMAIL_ADDR ]]; then
+    # Exercise in futility.  There's a poem by Wallace Stevens
+    # called something like `N ways of looking at a blackbird',
+    # where N is somewhere around 0x14 to 0x18.  Now zftp is
+    # ashamed to prsent `N ways of looking at a hostname'.
+    local domain host
+    # First, maybe we've already got it.  Zen-like.
+    if [[ $HOST = *.* ]]; then
+      # assume this is the full host name
+      host=$HOST
+    elif [[ -f /etc/resolv.conf ]]; then
+      # Next, maybe we've got resolv.conf.
+      domain=$(awk '/domain/ { print $2 }' /etc/resolv.conf)
+      [[ -n $domain ]] && host=$HOST.$domain
+    fi
+    # Next, maybe we've got nlsookup.  May not work on LINUX.
+    [[ -z $host ]] && host=$(nslookup $HOST | awk '/Name:/ { print $2 }')
+    if [[ -z $host ]]; then
+      # we're running out of ideas, but this should work.
+      # after all, i wrote it...
+      # don't want user to know about this, too embarrassed.
+      local oldvb=$ZFTP_VERBOSE oldtm=$ZFTP_TMOUT
+      ZFTP_VERBOSE=
+      ZFTP_TMOUT=5
+      if zftp open $host >& /dev/null; then
+        host=$ZFTP_HOST
+        zftp close $host
+      fi
+      ZFTP_VERBOSE=$oldvb
+      ZFTP_TMOUT=$oldtm
+    fi
+    if [[ -z $host ]]; then
+      print "Can't get your hostname.  Define \$EMAIL_ADDR by hand."
+      return 1;
+    fi
+    EMAIL_ADDR="$USER@$host"
+    print "Using $EMAIL_ADDR as anonymous FTP password."
+  fi
+  
+  if [[ $once = 1 ]]; then
+    zftp open $1 anonymous $EMAIL_ADDR
+  else
+    zftp params $1 anonymous $EMAIL_ADDR
+    zftp open
+  fi
+}
+
+function zfcd {
+  # zfcd:  change directory on the remote server.
+  #
+  #  Currently has the following features:
+  # --- an initial string matching $HOME in the directory is turned back into ~
+  #     to be re-interpreted by the remote server.
+  # --- zfcd with no arguments changes directory to '~'
+  # --- `zfcd old new' and `zfcd -' work analagously to cd
+  # --- if the connection is not currently open, it will try to
+  #     re-open it with the stored parameters as set by zfopen.
+  #     If the connection timed out, however, it won't know until
+  #     too late.  In that case, just try the same zfcd command again
+  #     (but now `zfcd -' and `zfcd old new' won't work).
+  
+  # hack: if directory begins with $HOME, turn it back into ~
+  # there are two reasons for this:
+  #   first, a ~ on the command line gets expanded even with noglob.
+  #     (I suppose this is correct, but I wouldn't like to swear to it.)
+  #   second, we can no do 'zfcd $PWD' and the like, and that will
+  #     work just as long as the directory structures under the home match.
+  
+  # Autoopen:  if not already open, hope there are parameters set up to
+  # do so.  If not, we get the right error message, so no harm done.
+  [[ -z $ZFTP_HOST ]] && { zfopen  || return 1; }
+  
+  if [[ $1 = $HOME || $1 = $HOME/* ]]; then
+    1="~${1#$HOME}"
+  fi
+  
+  if (( $# == 0 )); then
+    # Emulate `cd' behaviour
+    set -- '~'
+  elif [[ $# -eq 1 && $1 = - ]]; then
+    # Emulate `cd -' behaviour.
+    set -- $zflastdir
+  elif [[ $# -eq 2 ]]; then
+    # Emulate `cd old new' behaviour.
+    # We have to find a character not in $1 or $2; ! is a good bet.
+    eval set -- "\${ZFTP_PWD:s!$1!$2!}"
+  fi
+  
+  # We have to remember the current directory before changing it
+  # if we want to keep it.
+  local lastdir=$ZFTP_PWD
+  
+  zftp cd "$@"  &&  zflastdir=$lastdir
+}
+
+function zfcd_match {
+  # see zfcd for details of this hack
+  if [[ $1 = $HOME || $1 = $HOME/* ]]; then
+    1="~${1#$HOME}"
+  fi
+  
+  # error messages only
+  local ZFTP_VERBOSE=45
+  # should we redirect 2>/dev/null or let the user see it?
+  
+  if [[ $ZFTP_SYSTEM = UNIX* ]]; then
+    # hoo, aren't we lucky: this makes things so much easier
+    setopt localoptions rcexpandparam
+    local dir
+    if [[ $1 = ?*/* ]]; then
+      dir=${1%/*}
+    elif [[ $1 = /* ]]; then
+      dir=/
+    fi
+    # If we're using -F, we get away with using a directory
+    # to list, but not a glob.  Don't ask me why.
+    # I hate having to rely on awk here.
+    reply=($(zftp ls -F $dir | 
+    awk '/\/$/ { print substr($1, 0, length($1)-1) }'))
+    if [[ $dir = / ]]; then
+      reply=(${dir}$reply)
+    elif [[ -n $dir ]]; then
+      reply=($dir/$reply)
+    fi
+  else
+    # I simply don't know what to do here.
+    # Just use the list of files for the current directory.
+    zfget_match $*
+  fi
+  
+}
+
+function zfcget {
+  # Continuation get of files from remote server.
+  # For each file, if it's shorter here, try to get the remainder from
+  # over there.  This requires the server to support the REST command
+  # in the way many do but RFC959 doesn't specify.
+  # Options:
+  #   -G   don't to remote globbing, else do
+  #   -t   update the local file times to the same time as the remote.
+  #        Currently this only works if you have the `perl' command,
+  #        and that perl is version 5 with the standard library.
+  #        See the function zfrtime for more gory details.
+  
+  setopt localoptions
+  unsetopt ksharrays shwordsplit
+  
+  local loc rem stat=0 optlist opt nglob remlist locst remst
+  local tmpfile=${TMPPREFIX}zfcget$$ rstat tsize time
+  
+  while [[ $1 = -* ]]; do
+    if [[ $1 = - || $1 = -- ]]; then
+      shift;
+      break;
+    fi
+    optlist=${1#-}
+    for (( i = 1; i <= $#optlist; i++)); do
+      opt=$optlist[$i]
+      case $optlist[$i] in
+        G) nglob=1
+  	 ;;
+        t) time=1
+  	 ;;
+        *) print option $opt not recognised >&2
+  	 ;;
+      esac
+    done
+    shift
+  done
+  
+  for remlist in $*; do
+    # zfcd directory hack to put the front back to ~
+    if [[ $remlist = $HOME || $remlist = $HOME/* ]]; then
+      remlist="~${remlist#$HOME}"
+    fi
+    if [[ $nglob != 1 ]]; then
+      zfrglob remlist
+    fi
+    if (( $#remlist )); then
+      for rem in $remlist; do
+        loc=${rem:t}
+        if [[ ! -f $loc ]]; then
+  	# File does not yet exist
+  	zftp get $rem >$loc || stat=$?
+        else
+  	# Compare the sizes.
+  	locst=($(zftp local $loc))
+  	zftp remote $rem >$tmpfile
+  	rstat=$?
+  	remst=($(<$tmpfile))
+  	rm -f $tmpfile
+  	if [[ $rstat = 2 ]]; then
+  	  print "Server does not support SIZE command.\n" \
+  	  "Assuming you know what you're doing..." 2>&1
+  	  zftp getat $rem $locst[1] >>$loc || stat=$?
+  	  continue
+  	elif [[ $rstat = 1 ]]; then
+  	  print "Remote file not found: $rem" 2>&1
+  	  continue
+  	fi
+  	if [[ $locst[1] -gt $remst[1] ]]; then
+  	  print "Local file is larger!" 2>&1
+  	  continue;
+  	elif [[ $locst[1] == $remst[1] ]]; then
+  	  print "Files are already the same size." 2>&1
+  	  continue
+  	else
+  	  if zftp getat $rem $locst[1] >>$loc; then
+  	    [[ $time = 1 ]] && zfrtime $loc $rem $remst[2]
+  	  else
+  	    stat=1
+  	  fi
+  	fi
+        fi
+      done
+    fi
+  done
+  
+  return $stat
+}
+
+function zfclose {
+  zftp close
+}
+
+function zfdir {
+  # Long directory of remote server.
+  # The remote directory is cached.  In fact, two caches are kept:
+  # one of the standard listing of the current directory, i.e. zfdir
+  # with no arguments, and another for everything else.
+  # To access the appropriate cache, just use zfdir with the same
+  # arguments as previously.  zfdir -r will also re-use the `everything
+  # else' cache; you can always reuse the current directory cache just
+  # with zfdir on its own.
+  #
+  # The current directory cache is emptied when the directory changes;
+  # the other is kept until a new zfdir with a non-empty argument list.
+  # Both are removed when the connection is closed.
+  #
+  # zfdir -f will force the existing cache to be ignored, e.g. if you know
+  #          or suspect the directory has changed.
+  # zfdir -d will remove both caches without listing anything.
+  # If you need to pass -r, -f or -d to the dir itself, use zfdir -- -d etc.
+  
+  setopt localoptions unset
+  unsetopt shwordsplit ksharrays
+  
+  local file opt optlist redir i newargs force
+  
+  while [[ $1 = -* ]]; do
+    if [[ $1 = - || $1 = -- ]]; then
+      shift;
+      break;
+    fi
+    optlist=${1#-}
+    for (( i = 1; i <= $#optlist; i++)); do
+      opt=$optlist[$i]
+      case $optlist[$i] in
+        r) redir=1
+  	 ;;
+        f) force=1
+  	 ;;
+        d) [[ -n $zfcurdir && -f $zfcurdir ]] && rm -f $zfcurdir
+  	 [[ -n $zfotherdir && -f $zfotherdir ]] && rm -f $zfotherdir
+  	 zftp_fcache=()
+  	 return 0
+  	 ;;
+        *) print option $opt not recognised >&2
+  	 ;;
+      esac
+    done
+    shift
+  done
+  
+  # directory hack, see zfcd
+  for (( i = 1; i <= $#argv; i++ )); do
+    if [[ $argv[$i] = $HOME || $argv[$i] = $HOME/* ]]; then
+      argv[$i]="~${argv[$i]#$HOME}"
+    fi
+  done
+  
+  if [[ $# -eq 0 ]]; then
+    # Cache it in the current directory file.  This means that repeated
+    # calls to zfdir with no arguments always use a cached file.
+    [[ -z $zfcurdir ]] && zfcurdir=${TMPPREFIX}zfcurdir$$
+    file=$zfcurdir
+  else
+    # Last directly looked at was not the current one, or at least
+    # had non-standard arguments.
+    [[ -z $zfotherdir ]] && zfotherdir=${TMPPREFIX}zfotherdir$$
+    file=$zfotherdir
+    newargs="$*"
+    if [[ -f $file && $redir != 1 && $force -ne 1 ]]; then
+      # Don't use the cached file if the arguments changed.
+      [[ $newargs = $zfotherargs ]] || rm -f $file
+    fi
+    zfotherargs=$newargs
+  fi
+  
+  if [[ $force -eq 1 ]]; then
+    rm -f $file
+    # if it looks like current directory has changed, better invalidate
+    # the filename cache, too.
+    (( $# == 0 )) && zftp_fcache=()
+  fi
+  
+  if [[ -n $file && -f $file ]]; then
+    eval ${PAGER:-more} \$file
+  else
+    zftp dir $* | tee $file | eval ${PAGER-:more}
+  fi
+}
+
+function zfgcp {
+  # ZFTP get as copy:  i.e. first arguments are remote, last is local.
+  # Supposed to work exactly like a normal copy otherwise, i.e.
+  #  zfcp rfile lfile
+  # or
+  #  zfcp rfile1 rfile2 rfile3 ... ldir
+  # Options:
+  #   -G   don't to remote globbing, else do
+  #   -t   update the local file times to the same time as the remote.
+  #        Currently this only works if you have the `perl' command,
+  #        and that perl is version 5 with the standard library.
+  #        See the function zfrtime for more gory details.
+  
+  setopt localoptions
+  unsetopt shwordsplit
+  
+  local opt optlist nglob remlist rem loc stat=0 time
+  
+  while [[ $1 == -* ]]; do
+    if [[ $1 == - || $1 == -- ]]; then
+      shift;
+      break;
+    fi
+    optlist=${1#-}
+    for (( i = 1; i <= $#optlist; i++)); do
+      opt=$optlist[$i]
+      case $opt in
+        G) nglob=1
+  	 ;;
+        t) time=1
+  	 ;;
+        *) print option $opt not recognised >&2
+  	 ;;
+      esac
+    done
+    shift
+  done
+  
+  # hmm, we should really check this after expanding the glob,
+  # but we shouldn't expand the last argument remotely anyway.
+  if [[ $# -gt 2 && ! -d $argv[-1] ]]; then
+    print "zfgcp:  last argument must be a directory." 2>&1
+    return 1
+  elif [[ $# == 1 ]]; then
+    print "zfgcp:  not enough arguments." 2>&1
+    return 1
+  fi
+  
+  if [[ -d $argv[-1] ]]; then
+    local dir=$argv[-1]
+    argv[-1]=
+    for remlist in $*; do
+      # zfcd directory hack to put the front back to ~
+      if [[ $remlist = $HOME || $remlist = $HOME/* ]]; then
+        remlist="~${remlist#$HOME}"
+      fi
+      if [[ $nglob != 1 ]]; then
+        zfrglob remlist
+      fi
+      if (( $#remlist )); then
+        for rem in $remlist; do
+  	loc=$dir/${rem:t}
+  	if zftp get $rem >$loc; then
+  	  [[ $time = 1 ]] && zfrtime $rem $loc
+  	else
+  	  stat=1
+  	fi
+        done
+      fi
+    done
+  else
+    zftp get $1 >$2 || stat=$?
+  fi
+  return $stat
+}
+
+function zfget {
+  # Get files from remote server.  Options:
+  #   -G   don't to remote globbing, else do
+  #   -t   update the local file times to the same time as the remote.
+  #        Currently this only works if you have the `perl' command,
+  #        and that perl is version 5 with the standard library.
+  #        See the function zfrtime for more gory details.
+  
+  local loc rem stat=0 optlist opt nglob remlist time
+  
+  while [[ $1 == -* ]]; do
+    if [[ $1 == - || $1 == -- ]]; then
+      shift;
+      break;
+    fi
+    optlist=${1#-}
+    for (( i = 1; i <= $#optlist; i++)); do
+      opt=$optlist[$i]
+      case $opt in
+        G) nglob=1
+  	 ;;
+        t) time=1
+  	 ;;
+        *) print option $opt not recognised >&2
+  	 ;;
+      esac
+    done
+    shift
+  done
+  
+  for remlist in $*; do
+    # zfcd directory hack to put the front back to ~
+    if [[ $remlist == $HOME || $remlist == $HOME/* ]]; then
+      remlist="~${remlist#$HOME}"
+    fi
+    if [[ $nglob != 1 ]]; then
+      zfrglob remlist
+    fi
+    if (( $#remlist )); then
+      for rem in $remlist; do
+        loc=${rem:t}
+        if zftp get $rem >$loc; then
+  	[[ $time = 1 ]] && zfrtime $rem $loc
+        else
+  	stat=1
+        fi
+      done
+    fi
+  done
+  
+  return $stat
+}
+
+function zfget_match {
+  # the zfcd hack:  this may not be necessary here
+  if [[ $1 == $HOME || $1 == $HOME/* ]]; then
+    1="~${1#$HOME}"
+  fi
+  
+  
+  if [[ $ZFTP_SYSTEM == UNIX* && $1 == */* ]]; then
+    # On the first argument to ls, we usually get away with a glob.
+    reply=($(zftp ls "$1*$2"))
+  else
+    if (( $#zftp_fcache == 0 )); then
+      # Always cache the current directory and use it
+      # even if the system is UNIX.
+      zftp_fcache=($(zftp ls))
+    fi
+    reply=($zftp_fcache);
+  fi
+}
+
+function zfhere {
+  # Change to the directory corresponding to $PWD on the server.
+  # See zfcd for how this works.
+  zfcd $PWD
+}
+
+function zfls {
+  # directory hack, see zfcd
+  if [[ $1 = $HOME || $1 = $HOME/* ]]; then
+    1="~${1#$HOME}"
+  fi
+  zftp ls $*
+}
+
+function zfopen {
+  # Use zftp params to set parameters for open, rather than sending
+  # them straight to open.  That way they are stored for a future open
+  # command.
+  #
+  # With option -1 (just this 1ce), don't do that.
+  
+  local optlist opt once
+  
+  while [[ $1 = -* ]]; do
+    if [[ $1 = - || $1 = -- ]]; then
+      shift;
+      break;
+    fi
+    optlist=${1#-}
+    for (( i = 1; i <= $#optlist; i++)); do
+      opt=$optlist[$i]
+      case $optlist[$i] in
+        1) once=1
+  	 ;;
+        *) print option $opt not recognised >&2
+  	 ;;
+      esac
+    done
+    shift
+  done
+  
+  # This is where we should try and do same name-lookupage in
+  # both .netrc and .ncftp/bookmarks .  We could even try saving
+  # the info in their for new hosts, like ncftp does.
+  
+  if [[ $once = 1 ]]; then
+    zftp open $*
+  else
+    # set parameters, but only if there was at least a host
+    (( $# > 0 )) && zfparams $*
+    # now call with no parameters
+    zftp open
+  fi
+}
+
+function zfparams {
+    # Set to prompt for any user or password if not given.
+    # Don't worry about accounts here.
+    if (( $# > 0 )); then
+      (( $# < 2 )) && 2='?'
+      (( $# < 3 )) && 3='?'
+    fi
+    zftp params $*
+}
+
+function zfput {
+  # Simple put:  dump every file under the same name, but stripping
+  # off any directory parts.
+  local loc rem stat=0
+  for loc in $*; do
+    rem=${loc:t}
+    zftp put $rem <$loc
+    [[ $? == 0 ]] || stat=$?
+  done
+  return $stat
+}
+
+function zfrglob {
+  # Do the remote globbing for zfput, etc.
+  # We have two choices:
+  #  (1) Get the entire file list and match it one by one
+  #      locally against the pattern.
+  #      Causes problems if we are globbing directories (rare, presumably).
+  #      But: we can cache the current directory, which
+  #      we need for completion anyway.  Works on any OS if you
+  #      stick with a single directory.  This is the default.
+  #  (2) Use remote globbing, i.e. pass it to ls at the site.
+  #      Faster, but only works with UNIX, and only basic globbing.
+  #      We do this if $zfrglob is non-null.
+  
+  # There is only one argument, the variable containing the
+  # pattern to be globbed.  We set this back to an array containing
+  # all the matches.
+  setopt localoptions unset
+  unsetopt ksharrays
+  
+  local pat dir nondir files i
+  
+  eval pat=\$$1
+  
+  # Check if we really need to do anything.  Look for standard
+  # globbing characters, and if extendedglob is set and we are
+  # using zsh for the actual pattern matching also look for
+  # extendedglob characters.
+  if [[ $remlist != *[][*?]* &&
+    ( -n $zfrglob || ! -o extendedglob || $remlist != *[(|)~#^]* ) ]]; then
+    return 0
+  fi
+  
+  if [[ $zfrglob != '' ]]; then
+    eval "$1=(\$(zftp ls \"$pat\" 2>/dev/null))"
+  else
+    if [[ $ZFTP_SYSTEM = UNIX* && $pat = */* ]]; then
+      # not the current directory and we know how to handle paths
+      if [[ $pat = ?*/* ]]; then
+        # careful not to remove too many slashes
+        dir=${pat%/*}
+      else
+        dir=/
+      fi
+      nondir=${pat##*/}
+      files=($(zftp ls "$dir" 2>/dev/null))
+    else
+      # we just have to do an ls and hope that's right
+      nondir=$pat
+      if (( $#zftp_fcache == 0 )); then
+        zftp_fcache=($(zftp ls))
+      fi
+      files=($zftp_fcache)
+    fi
+    # now we want to see which of the $files match $nondir
+    for (( i = 1; i <= $#files; i++)); do
+      # empty words are elided in array assignment
+      [[ $files[$i] = ${~nondir} ]] || files[$i]=''
+    done
+    eval "$1=(\$files)"
+  fi
+}
+
+function zfrtime {
+  # Set the modification time of file LOCAL to that of REMOTE.
+  # If the optional TIME is passed, it should be in the FTP format
+  # CCYYMMDDhhmmSS, i.e. no dot before the seconds, and in GMT.
+  # This is what both `zftp remote' and `zftp local' return.
+  #
+  # Unfortunately, since the time returned from FTP is GMT and
+  # your file needs to be set in local time, we need to do some
+  # hacking around with time.  At the moment this requires perl 5
+  # with the standard library.
+  
+  setopt localoptions unset
+  unsetopt ksharrays
+  
+  local time gmtime loctime
+  
+  if [[ -n $3 ]]; then
+    time=$3
+  else
+    time=($(zftp remote $2 2>/dev/null))
+    [[ -n $time ]] && time=$time[2]
+  fi
+  [[ -z $time ]] && return 1
+  
+  # Now's the real *!@**!?!.  We have the date in GMT and want to turn
+  # it into local time for touch to handle.  It's just too nasty
+  # to handle in zsh; do it in perl.
+  if perl -mTime::Local -e '($file, $t) = @ARGV;
+  $yr = substr($t, 0, 4) - 1900;
+  $mon = substr($t, 4, 2) - 1;
+  $mday = substr($t, 6, 2) + 0;
+  $hr = substr($t, 8, 2) + 0;
+  $min = substr($t, 10, 2) + 0;
+  $sec = substr($t, 12, 2) + 0;
+  $time = Time::Local::timegm($sec, $min, $hr, $mday, $mon, $yr);
+  utime $time, $time, $file and return 0;' $1 $time 2>/dev/null; then
+    print "Setting time for $1 failed.  Need perl 5." 2>1
+  fi
+  
+  # If it wasn't for the GMT/local time thing, it would be this simple.
+  #
+  # time="${time[1,12]}.${time[13,14]}"
+  #
+  # touch -t $time $1
+  
+}
+
+function zfstat {
+  # Give a zftp status report using local variables.
+  # With option -v, connect the remote host and ask it what it
+  # thinks the status is.  
+  
+  setopt localoptions unset
+  unsetopt ksharrays
+  
+  local i stat=0 opt optlist verbose
+  
+  while [[ $1 = -* ]]; do
+    if [[ $1 = - || $1 = -- ]]; then
+      shift;
+      break;
+    fi
+    optlist=${1#-}
+    for (( i = 1; i <= $#optlist; i++)); do
+      opt=$optlist[$i]
+      case $opt in
+        v) verbose=1
+  	 ;;
+        *) print option $opt not recognised >&2
+  	 ;;
+      esac
+    done
+    shift
+  done
+  
+  # hack:  in case the status from a subshell process hasn't been
+  # fixed yet
+  zftp type >&/dev/null
+  
+  if [[ -n $ZFTP_HOST ]]; then
+    print "Host:\t\t$ZFTP_HOST"
+    print "IP:\t\t$ZFTP_IP"
+    [[ -n $ZFTP_SYSTEM ]] && print "System type:\t$ZFTP_SYSTEM"
+    if [[ -n $ZFTP_USER ]]; then
+      print "User:\t\t$ZFTP_USER "
+      [[ -n $ZFTP_ACCOUNT ]] && print "Account:\t$AFTP_ACCOUNT"
+      print "Directory:\t$ZFTP_PWD"
+      print -n "Transfer type:\t"
+      if [[ $ZFTP_TYPE = "I" ]]; then
+        print Image
+      elif [[ $ZFTP_TYPE = "A" ]]; then
+        print Ascii
+      else
+        print Unknown
+      fi
+      print -n "Transfer mode:\t"
+      if [[ $ZFTP_MODE = "S" ]]; then
+        print Stream
+      elif [[ $ZFTP_MODE = "B" ]]; then
+        print Block
+      else
+        print Unknown
+      fi
+    else
+      print "No user logged in."
+    fi
+  else
+    print "Not connected."
+    stat=1
+  fi
+  
+  # things which may be set even if not connected:
+  [[ -n $ZFTP_REPLY ]] && print "Last reply:\t$ZFTP_REPLY"
+  print "Verbosity:\t$ZFTP_VERBOSE"
+  print -n "Preferences:\t"
+  for (( i = 1; i <= ${#ZFTP_PREFS}; i++ )); do
+    case $ZFTP_PREFS[$i] in
+      [pP]) print -n "Passive "
+  	  ;;
+      [sS]) print -n "Sendport "
+  	  ;;
+      [dD]) print -n "Dumb "
+  	  ;;
+      *) print -n "$ZFTP_PREFS[$i]???"
+    esac
+  done
+  print
+  
+  if [[ -n $ZFTP_HOST && $verbose = 1 ]]; then
+    print "Status of remote server:"
+    # make sure we print the reply
+    local ZFTP_VERBOSE=045
+    zftp quote STAT
+  fi
+  
+  return $stat
+}
+
+function zftp_chpwd {
+  # You may want to alter chpwd to call this when $ZFTP_USER is set.
+  # If so, call it with a non-zero first argument so it doesn't
+  # print the new FTP directory.
+  
+  # Cancel the filename cache for the current directory.
+  zftp_fcache=()
+  # ...and also empty the stored directory listing cache.
+  # As this function is called when we close the connection, this
+  # is the only place we need to do these two things.
+  [[ -n $zfcurdir && -f $zfcurdir ]] && rm -f $zfcurdir
+  
+  if [[ -z $ZFTP_USER ]]; then
+    # last call, after an FTP logout
+  
+    # delete the non-current cached directory
+    [[ -n $zfotherdir && -f $zfotherdir ]] && rm -f $zfotherdir
+    zfotherargs=
+  
+    # don't keep zflastdir between opens
+    zflastdir=
+  
+    # return the display to standard
+    # uncomment the following line if you have a chpwd which shows directories
+    # chpwd
+  else
+    [[ -z $zflastdir ]] && zflastdir=$ZFTP_PWD
+    local args
+    if [[ -t 1 && -t 2 ]]; then
+      local str="$ZFTP_HOST:$ZFTP_PWD"
+      [[ -z $1 ]] && print $str
+      [[ ${#str} -lt 70 ]] && str="%m: %~  $str"
+      case $TERM in
+        sun-cmd) print -n -P "\033]l$str\033\\"
+  	       ;;
+        xterm) print -n -P "\033]2;$str\a"
+  	     ;;
+      esac
+    fi
+  fi
+}
+
+function zftp_progress {
+  # Basic progress metre, showing the percent of the file transferred.
+  # You want growing bars?  You gotta write growing bars.
+  
+  # Don't show progress unless stderr is a terminal
+  [[ ! -t 2 ]] && return 0
+  
+  if [[ $ZFTP_TRANSFER = *F ]]; then
+    print 1>&2
+  elif [[ -n $ZFTP_TRANSFER ]]; then
+    if [[ -n $ZFTP_SIZE ]]; then
+      local frac="$(( ZFTP_COUNT * 100 / ZFTP_SIZE ))%"
+      print -n "\r$ZFTP_FILE ($ZFTP_SIZE bytes): $ZFTP_TRANSFER $frac" 1>&2
+    else
+      print -n "\r$ZFTP_FILE: $ZFTP_TRANSFER $ZFTP_COUNT" 1>&2
+    fi
+  fi
+}
+
+function zftype {
+  local type
+  
+  if (( $# == 0 )); then
+    type=$(zftp type)
+    if [[ $type = I ]]; then
+      print "Current type is image (binary)"
+      return 0
+    elif [[ $type = A ]]; then
+      print "Current type is ASCII"
+      return 0
+    else
+      return 1
+    fi
+  else
+    if [[ $1 == [aA]([sS][cC]([iI][iI]|)|) ]]; then
+      type=A
+    elif [[ $1 == [iI]([mM]([aA][gG][eE]|)|) ||
+      $1 == [bB]([iI][nN]([aA][rR][yY]|)|) ]]; then
+      type=I
+    else
+      print "Type not recognised:  $1" 2>&1
+      return 1
+    fi
+    zftp type $type
+  fi
+}
+
+function zfuget {
+  # Get a list of files from the server with update.
+  # In other words, only retrieve files which are newer than local
+  # ones.  This depends on the clocks being adjusted correctly
+  # (i.e. if one is fifteen minutes out, for the next fifteen minutes
+  # updates may not be correctly calculated).  However, difficult
+  # cases --- where the files are the same size, but the remote is newer,
+  # or have different sizes, but the local is newer -- are prompted for.
+  #
+  # Files are globbed on the remote host --- assuming, of course, they
+  # haven't already been globbed local, so use 'noglob' e.g. as
+  # `alias zfuget="noglob zfuget"'.
+  #
+  # Options:
+  #  -G    Glob:     turn off globbing
+  #  -v    verbose:  print more about the files listed.
+  #  -s    silent:   don't ask, just guess.  The guesses are:
+  #                - if the files have different sizes but remote is older ) grab
+  #                - if they have the same size but remote is newer        )
+  #                  which is safe if the remote files are always the right ones.
+  #   -t   time:     update the local file times to the same time as the remote.
+  #                  Currently this only works if you have the `perl' command,
+  #                  and that perl is version 5 with the standard library.
+  #                  See the function zfrtime for more gory details.
+  
+  setopt localoptions
+  unsetopt ksharrays shwordsplit
+  
+  local loc rem stat=0 locstats remstats doit tmpfile=${TMPPREFIX}zfuget$$
+  local rstat remlist verbose optlist opt bad i silent nglob time
+  
+  zfuget_print_time() {
+    local tim=$1
+    print -n "$tim[1,4]/$tim[5,6]/$tim[7,8] $tim[9,10]:$tim[11,12].$tim[13,14]"
+    print -n GMT
+  }
+  
+  zfuget_print () {
+    print -n "\nremote $rem ("
+    zfuget_print_time $remstats[2]
+    print -n ", $remstats[1] bytes)\nlocal $loc ("
+    zfuget_print_time $locstats[2]
+    print ", $locstats[1] bytes)"
+  }
+  
+  while [[ $1 = -* ]]; do
+    if [[ $1 = - || $1 = -- ]]; then
+      shift;
+      break;
+    fi
+    optlist=${1#-}
+    for (( i = 1; i <= $#optlist; i++)); do
+      opt=$optlist[$i]
+      case $optlist[$i] in
+        v) verbose=1
+  	 ;;
+        s) silent=1
+  	 ;;
+        G) nglob=1
+  	 ;;
+        t) time=1
+  	 ;;
+        *) print option $opt not recognised >&2
+  	 ;;
+      esac
+    done
+    shift
+  done
+  
+  [[ -n $bad ]] && return 1
+  
+  for remlist in $*; do
+    # zfcd directory hack to put the front back to ~
+    if [[ $remlist == $HOME || $remlist == $HOME/* ]]; then
+      remlist="~${remlist#$HOME}"
+    fi
+    if [[ $nglob != 1 ]]; then
+      zfrglob remlist
+    fi
+    if (( $#remlist )); then
+      for rem in $remlist; do
+        loc=${rem:t}
+        doit=y
+        remstats=()
+        if [[ -f $loc ]]; then
+  	zftp local $loc >$tmpfile
+  	locstats=($(<$tmpfile))
+  	zftp remote $rem >$tmpfile
+  	rstat=$?
+  	remstats=($(<$tmpfile))
+  	rm -f $tmpfile
+  	if [[ $rstat = 2 ]]; then
+  	  print "Server does not implement full command set required." 1>&2
+  	  return 1
+  	elif [[ $rstat = 1 ]]; then
+  	  print "File not found on server: $rem" 1>&2
+  	  stat=1
+  	  continue
+  	fi
+  	[[ $verbose = 1 ]] && zfuget_print
+  	if (( $locstats[1] != $remstats[1] )); then
+  	  # Files have different sizes
+  	  if [[ $locstats[2] > $remstats[2] && $silent != 1 ]]; then
+  	    [[ $verbose != 1 ]] && zfuget_print
+  	    print "Local file $loc more recent than remote," 1>&2
+  	    print -n "but sizes are different.  Transfer anyway [y/n]? " 1>&2
+  	    read -q doit
+  	  fi
+  	else
+  	  # Files have same size
+  	  if [[ $locstats[2] < $remstats[2] ]]; then
+  	    if [[ $silent != 1 ]]; then
+  	      [[ $verbose != 1 ]] && zfuget_print
+  	      print "Local file $loc has same size as remote," 1>&2
+  	      print -n "but local file is older. Transfer anyway [y/n]? " 1>&2
+  	      read -q doit
+  	    fi
+  	  else
+  	    # presumably same file, so don't get it.
+  	    [[ $verbose = 1 ]] && print Not transferring
+  	    doit=n
+  	  fi
+  	fi
+        else
+  	[[ $verbose = 1 ]] && print New file $loc
+        fi
+        if [[ $doit = y ]]; then
+  	if zftp get $rem >$loc; then
+  	  if [[ $time = 1 ]]; then
+  	    # if $remstats is set, it's second element is the remote time
+  	    zfrtime $loc $rem $remstats[2]
+  	  fi
+  	else
+  	  stat=$?
+  	fi
+  	
+        fi
+      done
+    fi
+  done
+  return $stat
+}
+
+function zfuput {
+  # Put a list of files from the server with update.
+  # See zfuget for details.
+  #
+  # Options:
+  #  -v    verbose:  print more about the files listed.
+  #  -s    silent:   don't ask, just guess.  The guesses are:
+  #                - if the files have different sizes but remote is older ) grab
+  #                - if they have the same size but remote is newer        )
+  #                  which is safe if the remote files are always the right ones.
+  
+  setopt localoptions
+  unsetopt ksharrays shwordsplit
+  
+  local loc rem stat=0 locstats remstats doit tmpfile=${TMPPREFIX}zfuput$$
+  local rstat verbose optlist opt bad i silent
+  
+  zfuput_print_time() {
+    local tim=$1
+    print -n "$tim[1,4]/$tim[5,6]/$tim[7,8] $tim[9,10]:$tim[11,12].$tim[13,14]"
+    print -n GMT
+  }
+  
+  zfuput_print () {
+    print -n "\nremote $rem ("
+    zfuput_print_time $remstats[2]
+    print -n ", $remstats[1] bytes)\nlocal $loc ("
+    zfuput_print_time $locstats[2]
+    print ", $locstats[1] bytes)"
+  }
+  
+  while [[ $1 = -* ]]; do
+    if [[ $1 = - || $1 = -- ]]; then
+      shift;
+      break;
+    fi
+    optlist=${1#-}
+    for (( i = 1; i <= $#optlist; i++)); do
+      opt=$optlist[$i]
+      case $optlist[$i] in
+        v) verbose=1
+  	 ;;
+        s) silent=1
+  	 ;;
+        *) print option $opt not recognised >&2
+  	 ;;
+      esac
+    done
+    shift
+  done
+  
+  [[ -n $bad ]] && return 1
+  
+  if [[ $ZFTP_VERBOSE = *5* ]]; then
+    # should we turn it off locally?
+    print "Messages with code 550 are harmless." >&2
+  fi
+  
+  for loc in $*; do
+    rem=${loc:t}
+    doit=y
+    remstats=()
+    if [[ ! -f $loc ]]; then
+      print "$loc: file not found" >&2
+      stat=1
+      continue
+    fi
+    zftp local $loc >$tmpfile
+    locstats=($(<$tmpfile))
+    zftp remote $rem >$tmpfile
+    rstat=$?
+    remstats=($(<$tmpfile))
+    rm -f $tmpfile
+    if [[ $rstat = 2 ]]; then
+      print "Server does not implement full command set required." 1>&2
+      return 1
+    elif [[ $rstat = 1 ]]; then
+      [[ $verbose = 1 ]] && print New file $loc
+    else
+      [[ $verbose = 1 ]] && zfuput_print
+      if (( $locstats[1] != $remstats[1] )); then
+        # Files have different sizes
+        if [[ $locstats[2] < $remstats[2] && $silent != 1 ]]; then
+  	[[ $verbose != 1 ]] && zfuput_print
+  	print "Remote file $rem more recent than local," 1>&2
+  	print -n "but sizes are different.  Transfer anyway [y/n]? " 1>&2
+  	read -q doit
+        fi
+      else
+        # Files have same size
+        if [[ $locstats[2] > $remstats[2] ]]; then
+  	if [[ $silent != 1 ]]; then
+  	  [[ $verbose != 1 ]] && zfuput_print
+  	  print "Remote file $rem has same size as local," 1>&2
+  	  print -n "but remote file is older. Transfer anyway [y/n]? " 1>&2
+  	  read -q doit
+  	fi
+        else
+  	# presumably same file, so don't get it.
+  	[[ $verbose = 1 ]] && print Not transferring
+  	doit=n
+        fi
+      fi
+    fi
+    if [[ $doit = y ]]; then
+      zftp put $rem <$loc || stat=$?
+    fi
+  done
+  return $stat
+}