zsh-3.1.5-pws-16

Completion/Core/_path_files

@@ -153,7 +153,7 @@ if [[ "$pre[1]" = \~ ]]; then
   # prefix path by setting `prepaths'.
   
   linepath="${pre%%/*}/"
-  eval realpath\=$linepath
+  realpath=$~linepath
   [[ "$realpath" = "$linepath" ]] && return 1
   pre="${pre#*/}"
   orig="${orig#*/}"
@@ -236,8 +236,14 @@ for prepath in "$prepaths[@]"; do
       # the outer loop.
 
       if [[ $#tmp2 -eq 0 ]]; then
- 	[[ "$tmp1[1]" = */* ]] &&
+ 	if [[ "$tmp1[1]" = */* ]]; then
-	    exppaths=( "$exppaths[@]" ${^tmp1%/*}/${tpre}${tsuf} )
+	  tmp2=( "${(@)tmp1#${prepath}${realpath}}" )
+	  if [[ "$tmp2[1]" = */* ]]; then
+	    exppaths=( "$exppaths[@]" ${^tmp2%/*}/${tpre}${tsuf} )
+          else
+	    exppaths=( "$exppaths[@]" ${tpre}${tsuf} )
+	  fi
+        fi
         continue 2
       fi
 
@@ -249,8 +255,6 @@ for prepath in "$prepaths[@]"; do
         tmp1=( "${(@M)tmp1:#(${(j:|:)~${(@)tmp2:q}})}" )
       fi
     elif (( ! $#tmp1 )); then
-      [[ "$tmp1[1]" = */* ]] &&
-          exppaths=( "$exppaths[@]" ${^tmp1%/*}/${tpre}${tsuf} )
       continue 2
     fi
 
@@ -375,8 +379,8 @@ exppaths=( "${(@)exppaths:#$orig}" )
 
 if [[ -n "$compconfig[path_expand]" &&
       $#exppaths -ne 0 && nm -eq compstate[nmatches] ]]; then
-  compadd -U -S '' "$group[@]" "$expl[@]" -i "$IPREFIX" -I "$ISUFFIX" - \
+  compadd -U -S '' "$group[@]" "$expl[@]" -i "$IPREFIX" -I "$ISUFFIX" \
-          "${(@)exppaths}"
+          -p "$linepath" - "${(@)exppaths}"
 fi
 
 [[ nm -eq compstate[nmatches] ]]

Completion/Core/compdump

@@ -18,7 +18,7 @@
 _d_file=${compconfig[dumpfile]-${0:h}/compinit.dump}
 
 typeset -U _d_files
-_d_files=( ${^~fpath}/_*~*~(N:t) )
+_d_files=( ${^~fpath}/_(|*[^~])(N:t) )
 
 print "#files: $#_d_files" > $_d_file
 

Completion/Core/compinit

@@ -217,15 +217,30 @@ compdef() {
 # With the option `-l' as the first argument, the other arguments are
 # taken to be key names and the values for theses keys are printed, one
 # per line.
+# When listing is done and the `-L' option is given, the keys and
+# values are printed as invocations for this function, usable to be put
+# inte a setup script.
 
 compconf() {
-  local i
+  local i opt list
+
+  while getopts "lL" opt; do
+    if [[ "$opt" = l ]]; then
+      [[ -z "$list" ]] && list=yes
+    else
+      list=long
+    fi
+  done
+  shift OPTIND-1
 
   if (( $# )); then
-    if [[ "$1" = -l ]]; then
+    if [[ -n $list ]]; then
-      shift
       for i; do
-        print $compconfig[$i]
+        if [[ $list = long ]]; then
+	  (( ${+compconfig[$i]} )) && print "compconf $i='$compconfig[$i]'"
+	else
+          print $compconfig[$i]
+	fi
       done
     else
       for i; do
@@ -238,20 +253,19 @@ compconf() {
     fi
   else
     for i in ${(k)compconfig}; do
-      print ${(r:25:)i} $compconfig[$i]
+      if [[ $list = long ]]; then
+	print "compconf $i='$compconfig[$i]'"
+      else
+        print ${(r:25:)i} $compconfig[$i]
+      fi
     done
   fi
 }
 
 # Now we automatically make the definition files autoloaded.
 
-if [[ ! -o extendedglob ]]; then
-  _i_noextglob=yes
-  setopt extendedglob
-fi
-
 typeset -U _i_files
-_i_files=( ${^~fpath}/_*~*~(N:t) )
+_i_files=( ${^~fpath}/_(|*[^~])(N:t) )
 _i_initname=$0
 _i_done=''
 
@@ -268,7 +282,7 @@ fi
 if [[ -z "$_i_done" ]]; then
   for _i_dir in $fpath; do
     [[ $_i_dir = . ]] && continue
-    for _i_file in $_i_dir/_*~*~(N); do
+    for _i_file in $_i_dir/_(|*[^~])(N); do
       read -rA _i_line < $_i_file
       _i_tag=$_i_line[1]
       shift _i_line
@@ -306,6 +320,4 @@ if [[ -z "$_i_done" ]]; then
   (( _i_autodump )) && builtin . ${_i_initname:h}/compdump
 fi
 
-[[ -z "$_i_noextglob" ]] || unsetopt extendedglob
+unset _i_files _i_initname _i_done _i_autodump
-
-unset _i_files _i_initname _i_done _i_autodump _i_noextglob

Completion/User/_find

@@ -2,7 +2,7 @@
 
 local prev="$words[CURRENT-1]"
 
-if compset -N '-(ok|exec)' '\;' then
+if compset -N '-(ok|exec)' '\;'; then
   _normal
 elif compset -P 1 -; then
   compgen -s 'daystart {max,min,}depth follow noleaf version xdev \
@@ -13,7 +13,7 @@ elif [[ CURRENT -eq 2 ]]; then
   local ret=1
 
   compgen -g '. ..' && ret=0
-  _files -g '(-/)' && ret=0
+  _files -g '*(-/)' && ret=0
 
   return ret
 elif [[ "$prev" = -((a|c|)newer|fprint(|0|f)) ]]; then

Completion/User/_make

@@ -1,3 +1,3 @@
 #compdef make gmake pmake
 
-compgen -s "\$(awk '/^[a-zA-Z0-9][^\/         ]+:/ {print \$1}' FS=: [mM]akefile)"
+compgen -s "\$(awk '/^[a-zA-Z0-9][^\/         ]+:/ {print \$1}' FS=: [mM]akefile /dev/null)"

Config/version.mk

@@ -27,5 +27,5 @@
 # This must also serve as a shell script, so do not add spaces around the
 # `=' signs.
 
-VERSION=3.1.5-pws-15
+VERSION=3.1.5-pws-16
-VERSION_DATE='April 13, 1999'
+VERSION_DATE='April 25, 1999'

Doc/Makefile.in

@@ -40,7 +40,7 @@ TEXI2HTML = texi2html -expandinfo -split_chapter
 # man pages to install
 MAN = zsh.1 zshbuiltins.1 zshcompctl.1 zshcompwid.1 zshcompsys.1 \
 zshexpn.1 zshmisc.1 zshmodules.1 \
-zshoptions.1 zshparam.1 zshzle.1 zshall.1
+zshoptions.1 zshparam.1 zshzftpsys.1 zshzle.1 zshall.1
 
 # yodl documentation
 YODLDOC = $(MAN) zsh.texi
@@ -53,7 +53,7 @@ Zsh/mod_clone.yo Zsh/mod_comp1.yo Zsh/mod_compctl.yo Zsh/mod_deltochar.yo \
 Zsh/mod_example.yo Zsh/mod_files.yo Zsh/mod_stat.yo \
 Zsh/mod_zle.yo Zsh/options.yo \
 Zsh/params.yo Zsh/prompt.yo Zsh/redirect.yo Zsh/restricted.yo \
-Zsh/seealso.yo Zsh/zle.yo
+Zsh/seealso.yo Zsh/zftpsys.yo Zsh/zle.yo
 
 # ========== DEPENDENCIES FOR BUILDING ==========
 
@@ -132,6 +132,8 @@ zshoptions.1: Zsh/options.yo
 
 zshparam.1: Zsh/params.yo
 
+zshzftpsys.1: Zsh/zftpsys.yo
+
 zshzle.1: Zsh/zle.yo
 
 version.yo: $(sdir_top)/Config/version.mk

Doc/Zsh/compsys.yo

@@ -1,4 +1,4 @@
-texinode(Completion System)()(Zsh Modules)(Top)
+texinode(Completion System)(Zftp Function System)(Zsh Modules)(Top)
 chapter(Completion System)
 cindex(completion, system)
 cindex(completion, programmable)
@@ -165,8 +165,8 @@ var(function) autoloadable (exactly equivalent to
 tt(autoload )var(function)).
 )
 xitem(tt(compconf) var(definitions...))
-xitem(tt(compconf))
+xitem(tt(compconf) [ tt(-L) ] )
-item(tt(compconf) [ tt(-l) ] var(keys...))(
+item(tt(compconf) [ tt(-l) ] [ tt(-L) ] var(keys...))(
 Several aspects of the completion system can be configured by the
 user. The configuration values are stored under the keys described
 below in the associative array `tt(compconfig)'.  After sourcing
@@ -183,7 +183,9 @@ you should not set all values at once by doing `tt(compconfig=(...))'.
 In the second form (without arguments), this function lists all keys
 and their values. If given the tt(-l) option as its first argument, as 
 in the last form, the other arguments are taken as names of keys and
-the values of these keys are printed one per line.
+the values of these keys are printed one per line. In either case, if the
+tt(-L) option is given, the keys and values are printed as calls to this
+function, usable to be put in a setup script.
 )
 enditem()
 

Doc/Zsh/compwid.yo

@@ -4,27 +4,27 @@ cindex(completion, widgets)
 cindex(completion, programmable)
 cindex(completion, controlling)
 sect(Description)
-Completion widgets are defined using the tt(-C) option to the tt(zle)
+Completion widgets are defined by the tt(-C) option to the tt(zle)
 builtin command provided by the tt(zle) module (see
 ifzman(zmanref(zshzle))\
 ifnzman(noderef(The zle Module))\
-). For example, the invocation:
+). For example,
 
-indent(nofill(
+indent(
-tt(zle -C complete expand-or-complete completer)))
+nofill(tt(zle -C complete expand-or-complete completer))
+)
 
-defines a widget named tt(complete). If this widget is bound to a key
+defines a widget named tt(complete). When this widget is bound to a key
 using the tt(bindkey) builtin command defined in the tt(zle) module
 (see 
 ifzman(zmanref(zshzle))\
 ifnzman(noderef(Zsh Line Editor))\
-) typing that key will make the completion code call the shell
+), typing that key will call the shell function tt(completer). This
-function tt(completer). This function is responsible for generating
+function is responsible for generating the possible matches using the
-the possible matches using the builtins described below. Once the
+builtins described below. Once the function returns, the completion code
-function returns, the completion code takes over control again and
+takes over control again and treats the matches as the builtin widget
-treats the matches the way the builtin widget tt(expand-or-complete)
+tt(expand-or-complete) would do.  For this second argument, the name of any
-would do it. For this second argument, the name of any of the builtin
+of the builtin widgets that handle completions can be given:
-widgets that handle completions can be given, i.e. it may be any of
 tt(complete-word), tt(expand-or-complete),
 tt(expand-or-complete-prefix), tt(menu-complete),
 tt(menu-expand-or-complete), tt(reverse-menu-complete),
@@ -40,94 +40,103 @@ endmenu()
 texinode(Special Parameters)(Builtin Commands)()(Completion Widgets)
 sect(Special Parameters)
 
-Inside completion widgets some parameters have special meaning. They
+Inside completion widgets, and any functions called from those, some
-will be used inside the widget function and other shell functions
+parameters have special meaning; outside these function they are not
-called from it. Outside of these function they are not special to the
+special to the shell in any way.  These parameters are used to pass
-shell in any way.
+information between the completion code and the completion widget. Some of
-
+the builtin commands and the condition codes use or change the current
-The parameters are used to give information about the internal state
+values of these parameters.  Any existing values will be hidden during
-from the completion code to the completion widget and can be set to
+execution of completion widgets; except for tt(compstate), the parameters
-give information to the completion code from the completion
+are reset on each function exit (including nested function calls from
-widget. Some of the builtin commands and the condition codes use or
+within the completion widget) to the values they had when the function was
-change the current values of these parameters. While the completion
+entered.
-widget is active, these parameters are reset on each function exit to
-the values they had when the function was entered.
 
 startitem()
 item(tt(words))(
-This array contains the words from the line.
+This array contains the words present on the command line currently being
+edited.
 )
 item(tt(CURRENT))(
 This is the number of the current word, i.e. the word the cursor is
-currently on in the tt(words) array. Note that this value is only
+currently on in the tt(words) array.  Note that this value is only
-correct, if the tt(ksharrays) options is not set.
+correct if the tt(ksharrays) options is not set.
 )
 item(tt(PREFIX))(
-This should be set to that part of the current word that should be
+Initially this will be set to the part of the current word from the
-taken as the string every possible match has to begin with. Initially
+beginning of the word up to the position of the cursor; it may be altered
-this will be set to the part of the current word from the beginning of
+to give a common prefix for all matches.
-the word up to the position of the cursor. When 
 )
 item(tt(IPREFIX))(
-When a part of the current word should not be considered part of the
+Initially this will be set to the empty string.  It functions like
-matches, this part should be taken from the tt(PREFIX) parameter and
+tt(PREFIX), and gives a string which precedes the one in tt(PREFIX) and is
-appended to this parameter. This will initially be set to the empty
+not considered part of the list of matches.  Typically, a string is
-string when called from the completion code.
+transferred from the beginning of tt(PREFIX) to the end of tt(IPREFIX), for
+example:
+
+tt(indent(
+nofill(IPREFIX=${PREFIX%%\=*}=)
+nofill(PREFIX=${PREFIX#*=})
+))
+
+causes the part of the prefix up to and including the first equal sign not
+to be treated as part of a matched string.
 )
 item(tt(SUFFIX))(
-This should be set to that part of the current word that should be
+Initially this will be set to the part of the current word from the
-taken as the string every possible match has to end with. The
+cursor position to the end; it may be altered to give a common suffix for
-completion code sets this to the part of the current word from the
+all matches.  It is most useful when the option tt(COMPLETE_IN_WORD) is
-cursor position to the end.
+set, as otherwise the whole word on the command line is treated as a
+prefix.
 )
 item(tt(ISUFFIX))(
-Like tt(IPREFIX), but for a suffix that should not be considered part
+As tt(IPREFIX), but for a suffix that should not be considered part
-of the matches.
+of the matches; note that the tt(ISUFFIX) string follows the tt(SUFFIX)
+string.
 )
 item(tt(compstate))(
-This is an associative array with various keys and values the
+This is an associative array with various keys and values that the
-completion uses to give informtaion to the completion widget and to
+completion code uses to exchange information with the completion widget.
-get information regarding the further processing from it. The keys
+The keys are:
-are:
 
 startitem()
 item(tt(context))(
 This will be set by the completion code to the overall context
-completion is attempted in. Possible values are:
+in which completion is attempted. Possible values are:
 
 startitem()
 item(tt(command))(
-when completing for a normal command (in a command position or for an
+when completing for a normal command (either in a command position or for
-argument)
+an argument of the command).
 )
 item(tt(redirect))(
-when completing after a redirection operator
+when completing after a redirection operator.
 )
 item(tt(condition))(
-when completing inside a `tt([[)...tt(]])' conditional expressing; in
+when completing inside a `tt([[)...tt(]])' conditional expression; in
 this case the tt(words) array contains the words inside the
-conditional expression
+conditional expression.
 )
 item(tt(math))(
 when completing in a mathematical environment such as a
-`tt(LPAR()LPAR())...tt(RPAR()RPAR())' construct
+`tt(LPAR()LPAR())...tt(RPAR()RPAR())' construct.
 )
 item(tt(value))(
-when completing the value of a parameter assignment
+when completing the value of a parameter assignment.
 )
 item(tt(array_value))(
 when completing inside the value of an array parameter assignment; in
-this case the tt(words) array contains the words inside the parentheses
+this case the tt(words) array contains the words inside the parentheses.
 )
 item(tt(subscript))(
-when completing inside a parameter subscript
+when completing inside a parameter subscript.
 )
 item(tt(parameter))(
-when the name of a parameter in a parameter expansion
+when completing the name of a parameter in a parameter expansion beginning
+with tt($) but not tt(${).
 )
 item(tt(brace_parameter))(
-when the name of a parameter in a parameter expansion that started
+when completing the name of a parameter in a parameter expansion beginning
-with tt(${)
+with tt(${).
 )
 enditem()
 )
@@ -136,154 +145,147 @@ The name of the parameter when completing in a subscript or in the
 value of a parameter assignment.
 )
 item(tt(redirect))(
-The redirection operator when completing in a redirection position.
+The redirection operator when completing in a redirection position,
+i.e. one of tt(<), tt(>), etc.
 )
 item(tt(quoting))(
-If completion is done inside single quotes, this is set to the string
+When completing inside single quotes, this is set to the string
-tt(single). When completing inside double quotes this is set to
+tt(single); inside double quotes, the string
-tt(double). When completing inside backticks it is set to tt(backtick).
+tt(double); inside backticks, the string tt(backtick).
 Otherwise it is unset.
 )
 item(tt(quote))(
 When completing inside quotes, this contains the quotation character
-(i.e. either a single quote, a double quote, or a backtick).
+(i.e. either a single quote, a double quote, or a backtick).  Otherwise it
+is unset.
 )
 item(tt(nmatches))(
-This is always set to the number of matches generated and accepted by
+The number of matches generated and accepted by the completion code so far.
-the completion code so far.
 )
 item(tt(matcher))(
-When completion is used with a global match specification (i.e. a
+When completion is performed with a global match specification as defined
-tt(compctl) with only a tt(-M) option), this contains the
+by
-number of the specification string which is currently used.
+
+indent(
+nofill(tt(compctl -M) var(spec1 ... specN ...))
+)
+
+this gives the number of the specification string currently in use.
+In this case, matching is performed with each specification in turn.
 )
 item(tt(matcher_string))(
-This is set to the global match specification string currently used.
+The global match specification string var(specN) currently used.
 )
 item(tt(total_matchers))(
 The total number of global match specifications.
 )
 item(tt(restore))(
-This is set to tt(auto) before a function is entered. If a function
+This is set to tt(auto) before a function is entered, which forces the
-unsets it or sets it to any other string, the special parameters
+special parameters mentioned above (tt(words), tt(CURRENT), tt(PREFIX),
-mentioned above (tt(words), tt(CURRENT), tt(PREFIX), tt(IPREFIX), and
+tt(IPREFIX), tt(SUFFIX), and tt(ISUFFIX)) to be restored to their
-tt(SUFFIX)) will not be restored to their previous values when the
+previous values when the function exits.   If a function unsets it or
-function exits as is normally done.
+sets it to any other string, they will not be restored.
 )
 item(tt(list))(
-On entry to the completion widget this will be unset, if the set of
+This controls whether or how the list of matches will be displayed.  If it
-matches generated will not be listed. It is set to tt(list),
+is unset or empty they will never be listed; if is set to tt(list), they
-tt(autolist), or tt(ambiguous) if the matches will always be listed,
+will always be listed; if tt(autolist) or tt(ambiguous), they will be
-if they will be listed due to tt(AUTO_LIST) being set, or if they will 
+listed when the tt(AUTO_LIST) or tt(LIST_AMBIGUOUS) options respectively
-be listed if there is no unambiguous string to insert and
+would normally cause them to be.  It will be set appropriately on entry to
-tt(LIST_AMBIGUOUS) is set, respectively. Inside the completion widget
+a completion widget and may be changed there.
-it may be set to any of these values to make the completion code as if 
-the appropriate options had been set.
 )
 item(tt(force_list))(
 If the value for the tt(list) key is tt(ambiguous), the list will
 normally be shown only if there are at least two matches in the
-list. Setting tt(force_list) to an non-empty string makes the list be
+list. Setting tt(force_list) to an non-empty string forces the list to be
 shown even if there is only one match.
 )
 item(tt(list_max))(
 Initially this is set to the value of the tt(LISTMAX) parameter.
-Completion widgets may set it to any other numeric value and the value 
+It may be set to any other numeric value; when the widget exits this value
-stored at when the widget finishes will be used in the same way the
+will be used in the same way as the value of tt(LISTMAX).
-value of tt(LISTMAX) is used.
 )
 item(tt(last_prompt))(
 If this is set to an non-empty string, the completion code will move
 the cursor back to the previous prompt after the list of completions
-has been displayed. Initially this is set depending on the setting of
+has been displayed.  Initially this is set or unset according to
 the tt(ALWAYS_LAST_PROMPT) option.
 )
 item(tt(insert))(
-This will be unset by the completon code if the contents of the
+This controls the manner in which a match is inserted into the command
-command line will not be changed. It is set to tt(unambiguous),
+line.  On entry to the widget fuction, if it is unset the command line is
-tt(menu), or tt(automenu) if a common unambiguous string will be
+not to be changed; if set to tt(unambiguous), any prefix common to all
-inserted or if the first match will be inserted and menu completion
+matches is to be inserted; if set to tt(menu) or tt(automenu) the usual
-will be started (due to tt(MENU_COMPLETE) or tt(AUTO_MENU) being set), 
+behaviour of the tt(MENU_COMPLETE) or tt(AUTO_MENU) options, respectively,
-respectively.
+is to be used.
 
-On exit it may be set to any of the values above with the obvious
+On exit it may be set to any of the values above, or to a number, in which
-result or to a number or a string of the form
+case the match whose number is given will be inserted into the command line.
-`var(group):var(match)'. If it is set to a number the match whose
+It may also be set to a string of the form `var(group):var(match)' which
-number is given will be inserted in the command line. A string like
+specifies a match from a group of matches to be inserted, counting from 1
-`tt(2:4)' specifies which match from which group should be
+upwards (e.g. `tt(2:4)' specifies the fourth match of the second group).
-inserted. In this example the fourth match of the second group is
+Negative numbers count backward from the last match or group (with `tt(-1)'
-inserted. All groups and matches are number from one upwards. In the
+selecting the last match or group) and out-of-range values are wrapped
-value of this key, negative numbers count backward from the last match 
+around, so that a value of zero selects the last match or group and a value
-or group (with `tt(-1)' selecting the last match or group) and values
+one more than the maximum selects the first.
-out of the range from one to the number of matches or groups are
-wrapped around (so that a value of zero selects the last match and a
-value equal to the number of matches or groups plus one selects the
-first one).
 )
 item(tt(to_end))(
-On entry to the completion widget this is set to tt(single) if the
+Specifies the occasions on which the cursor is moved to the end of a string
-cursor would be moved to the end of the word only if completion
+when a match is inserted.  On entry to a widget function, it may be
-generated only one match and that is inserted into the line. Depending 
+tt(single) if this will happen when a single unambiguous match was inserted
-on the original position of the cursor and the setting of the option
+or tt(match) if it will happen any time a match is inserted (for example,
-tt(ALWAYS_TO_END) this may also be set to the string tt(match) if the
+by menucompletion; this is likely to be the effect of the tt(ALWAYS_TO_END)
-cursor would be moved to the end if a whole match would be inserted
+option).
-(either if there is only one match or if menucompletion is used).
 
-The value of this key after the completion widget exits will be used
+On exit, it may be set to tt(single) as above.  It may also be set to
-to determin when the cursor will be moved to the end of the string
+tt(always), or to the empty string or unset; in those cases the cursor will
-inserted into the line. If it is unset or set to the empty string, the 
+be moved to the end of the string always or never respectively.  Any
-cursor will never be moved to the end. If it is set to tt(single), it
+other string is treated as tt(match).
-will be moved to the end only if completion generated only one
-match. A value of tt(always) says to move the cursor always to the end 
-(even with normal completion when an unambiguous string is inserted),
-and any other value says to move the cursor to the end when a full
-match is inserted (a single match or the first match when using
-menucompletion).
 )
 item(tt(old_list))(
 This is set to tt(yes) if there is still a valid list of completions
-from a previous completion at the time the widget is invoked. Such a
+from a previous completion at the time the widget is invoked.  This will
-list exists if it was generated by the previous key press. If the list 
+usually be the case if and only if the previous editing operation was a
-is also shown on the screen, the value of this key is tt(shown).
+completion widget or one of the builtin completion fuctions.  If there is a
+valid list and it is also currently shown on the screen, the value of this
+key is tt(shown).
 
 After the widget has exited the value of this key is only used if it
-was set to tt(keep). In this case, the completion code will continue
+was set to tt(keep).  In this case the completion code will continue
-to use this old list. If the widget generated new matches, they will
+to use this old list.  If the widget generated new matches, they will
 not be used.
 )
 item(tt(old_insert))(
 On entry to the widget this will be set to the number of the match of
-an old list of completions that is currently inserted in the command
+an old list of completions that is currently inserted into the command
 line. If no match has been inserted, this is unset.
 
-As with tt(old_list), the value of this key will only be used if it is 
+As with tt(old_list), the value of this key will only be used if it is the
-the string tt(keep). If it was set to this value by the widget and
+string tt(keep). If it was set to this value by the widget and there was an
-there was an old match inserted in the line, this match will be kept
+old match inserted into the command line, this match will be kept and if
-and if the value of the tt(insert) key says that another match should
+the value of the tt(insert) key specifies that another match should be
-be inserted, this will be inserted after the old one.
+inserted, this will be inserted after the old one.
 )
 item(tt(exact))(
-This is set to tt(accept) if an exact match would be accepted by the
+Controls the behaviour when the tt(REC_EXACT) option is set.  It will be
-completion code due to tt(REC_EXACT) being set or it is unset if an
+set to tt(accept) if an exact match would be accepted, and will be unset
-exact match would not be accepted.
-)
-item(tt(exact_string))(
-This is set to the string of an exact match if one was found and unset 
 otherwise.
 )
+item(tt(exact_string))(
+The string of an exact match if one was found, otherwise unset.
+)
 item(tt(pattern_match))(
-If the option tt(GLOB_COMPLETE) is set, this is initially set to
+Locally controls the behaviour given by the tt(GLOB_COMPLETE) option.
-`tt(*)' and unset otherwise. If the completion widget sets it to a
+Initially it is set to `tt(*)' if and only if the option is set.
-`tt(*)', the completion code will from then on behave as if
+The completion widget may set it to either of these two values, or to any
-tt(GLOB_COMPLETE) is set, i.e. if the strings in tt(PREFIX) and
+other non-empty string.  If it is non-empty, unquoted metacharacters on the
-tt(SUFFIX) contain unquoted metacharacters, they will be treated as
+command line will be treated as patterns; if it is `tt(*)', then
-patterns. If the string is set to any other non-empty string, the
+additionally a wildcard `tt(*)' is assumed at the cursor position; if
-strings will be treated as patterns but the code will not automatically
+it is empty or unset, metacharacters will be treated literally.
-insert a star at the cursor position.
 )
 item(tt(pattern_insert))(
-Normally this is set to tt(menu) which means that menu-completion will be
+Normally this is set to tt(menu), which specifies that menu-completion will
-used whenever the matches were generated using pattern matching. If this
+be used whenever the matches were generated using pattern matching. If it
 is set to any other non-empty string by the user and menu-completion is
 not selected by other option settings, the code will insert an
 unambiguous string for the generated matches as with normal completion.
@@ -293,10 +295,10 @@ This key is read-only and will always be set to the unambiguous string
 the completion code has generated for all matches added so far.
 )
 item(tt(unambiguous_cursor))(
-This gives the position the cursor would be placed at when the
+This gives the position the cursor would be placed at if the
-unambiguous string would be inserted, relative to the value of the
+unambiguous string in the tt(unambiguous) key were inserted, relative to
-tt(unambiguous) key. The cursor would be placed before the character
+the value of that key. The cursor would be placed before the character
-whise index is given by this key.
+whose index is given by this key.
 )
 enditem()
 )
@@ -308,12 +310,13 @@ startitem()
 findex(compgen)
 item(tt(compgen) var(flags ...))(
 
-Generate matches according to the given var(flags) which can be any of 
+Generate matches according to the given var(flags).  These can be any of 
-the option flags supported by the tt(compctl) builtin command (see
+the normal option flags (not those for extended completion) supported by
+the tt(compctl) builtin command (see
 ifzman(zmanref(zshcompctl))\
 ifnzman(noderef(Programmable Completion))\
-) except for the tt(-t) and tt(-l) flags. Also, when using the tt(-K)
+) except for the tt(-t) and tt(-l) flags.  However, when using the tt(-K)
-flag, the function given as argument to it can not access the command
+flag, the function given as argument to it cannot access the command
 line with the tt(read) builtin command.
 
 The matches will be generated in the same way as if the completion code
@@ -323,11 +326,11 @@ possible completions that match the prefix and suffix from the special
 parameters desribed above. These strings will be compared with the
 generated matches using the normal matching rules and any matching
 specifications given with the tt(-M) flag to tt(compgen) and the
-global matching specifications given to the tt(compctl) builtin
+global matching specifications given via the tt(compctl -M )var(spec1 ...)
-command.
+builtin command.
 
-The return value can be used to test if matches were added. It is zero 
+The return value is zero if at least one match was added and non-zero
-if at least one match was added and non-zero otherwise.
+otherwise.
 )
 xitem(tt(compadd) [ tt(-qQfnUam) ] [ tt(-F) var(array) ])
 xitem([ tt(-P) var(prefix) ] [ tt(-S) var(suffix) ])
@@ -339,12 +342,12 @@ xitem([ tt(-r) var(remove-chars) ] [ tt(-R) var(remove-func) ])
 xitem([ tt(-M) var(match-spec) ] [ tt(-O) var(array) ] [ tt(-A) var(array) ])
 item([ tt(--) ] [ var(words) ... ])(
 
-This builtin command can be used to add matches and directly control
+This builtin command can be used to add matches directly and control
 all the information the completion code stores with each possible
 match. The return value is zero if at least one match was added and
 non-zero if no matches were added.
 
-The completion code breaks the string to complete into six fields in
+The completion code breaks the string to complete into seven fields in
 the order: 
 
 indent(
@@ -352,46 +355,43 @@ var(<ipre><apre><hpre><word><hsuf><asuf><isuf>)
 )
 
 The first field
-is an ignored prefix taken from the line, the contents of the
+is an ignored prefix taken from the command line, the contents of the
 tt(IPREFIX) parameter plus the string given with the tt(-i)
-option. With the tt(-U) option given, only the string from the tt(-i)
+option. With the tt(-U) option, only the string from the tt(-i)
-option is used. The field var(<apre>) is a optional prefix string that 
+option is used. The field var(<apre>) is an optional prefix string
-should automatically be added by the completion code, this is what can 
+given with the tt(-P) option.  The var(<hpre>) field is a string
-be gievn with the tt(-P) option. The var(<hpre>) field is a string
 that is considered part of the match but that should not be shown when 
-listing completions, it is given with the tt(-p) option. E.g. for
+listing completions, given with the tt(-p) option; for example,
-functions that do filename generation, one might want to use this for
+functions that do filename generation might specify
-a common path prefix. var(<word>) is the part of the match that should 
+a common path prefix this way. var(<word>) is the part of the match that
-appear in the list of completions, one of the tt(words) given at the
+should appear in the list of completions, one of the tt(words) given at the
-end. The field var(<hsuf>) is like var(<hpre>) but gives a suffix that 
+end. The suffixes var(<hsuf>), var(<asuf>) and var(<isuf>) correspond to
-should be matched but will not be listed. Finally, var(<asuf>) is the
+the prefixes var(<hpre>), var(<apre>) and var(<ipre>) and are given by the
-suffix given with tt(-S) that should automatically be added by the
+options tt(-s), tt(-S) and tt(-I), respectively.
-completion code and var(<isuf>) is like var(<ipre>), but taken from
-the tt(ISUFFIX) parameter and the tt(-I) option.
 
 The supported flags are:
 
 startitem()
 item(tt(-P) var(prefix))(
-The same as for tt(compctl) and tt(compgen), it gives a string that
+As for tt(compctl) and tt(compgen), it gives a string to
-should be inserted before the given words when they are completed. The
+be inserted before the given var(words).  The
-string given is not considered to be part of the match.
+string given is not considered as part of the match.
 )
 item(tt(-S) var(suffix))(
-Like tt(-P) but gives a string that has to be inserted after the match.
+Like tt(-P) but gives a string to be inserted after the match.
 )
 item(tt(-p) var(hidden-prefix))(
-This gives a string that should be inserted in the line before the
+This gives a string that should be inserted into the command line before the
 match but that should not appear in the list of matches. Unless the
-tt(-U) option is given, the string on the line has to match this
+tt(-U) option is given, this string must be matched as part of the string
-string.
+on the command line.
 )
 item(tt(-s) var(hidden-suffix))(
 Like `tt(-p)', but gives a string to insert after the match.
 )
 item(tt(-i) var(ignored-prefix))(
 This gives a string to insert into the command line just before any
-string given with the `tt(-P)' option. Without `tt(-P)' the string is
+string given with the `tt(-P)' option.  Without `tt(-P)' the string is
 inserted before the string given with `tt(-p)' or directly before the
 match.
 )
@@ -399,128 +399,123 @@ item(tt(-I) var(ignored-suffix))(
 Like tt(-i), but gives an ignored suffix.
 )
 item(tt(-J) var(name))(
-As for tt(compctl) and tt(compgen) this gives the name of the group
+As for tt(compctl) and tt(compgen), this gives the name of the group
 of matches the words should be stored in.
 )
 item(tt(-V) var(name))(
 Like tt(-J) but naming a unsorted group.
 )
 item(tt(-X) var(explanation))(
-The var(explanation) string will be printed with the list of matches,
+As for tt(compctl) and tt(compgen), the var(explanation) string will be
-as for tt(compctl -X).
+printed with the list of matches.
 )
 item(tt(-q))(
-This flag has the same meaning as for tt(compctl) and tt(compgen),
+As for tt(compctl) and tt(compgen),
-too. It makes the suffix given with tt(-S) be automatically removed if 
+the suffix given with tt(-S) will be automatically removed if 
-the next character typed is a blank or does not insert anything or if
+the next character typed is a blank or does not insert anything, or if
 the suffix consists of only one character and the next character typed 
 is the same character.
 )
 item(tt(-r) var(remove-chars))(
-This makes the suffix given with tt(-S) be automatically removed if
+This is a more versatile form of the tt(-q) option.
+The suffix given with tt(-S) will be automatically removed if
 the next character typed inserts one of the characters given in the
-var(remove-chars). This string is parsed as a characters class with
+var(remove-chars).  This string is parsed as a characters class and
-the usual backslash-sequences understood, e.g. using `tt(-r "a-z\t")'
+understands the backslash sequences used by the tt(print) command.  For
-removes the suffix if the next character typed inserts one of the
+example, `tt(-r "a-z\t")' removes the suffix if the next character typed
-lower case letters or a TAB, and `tt(-r "^0-9")' removes the suffix if 
+inserts a lowercase character or a TAB, and `tt(-r "^0-9")' removes the
-the next character typed inserts anything but a digit. One extra
+suffix if the next character typed inserts anything but a digit. One extra
 backslash sequence is understood in this string: `tt(\-)' stands for
 all characters that insert nothing. Thus `tt(-S "=" -q)' is the same
 as `tt(-S "=" -r "= \t\n\-")'.
 )
 item(tt(-R) var(remove-func))(
-For the cases where one wants to remove suffix and the tt(-r) option
+This is another form of the tt(-r) option. When a suffix given with the
-does not give enough control, this option can be used. It stores the
+tt(-S) option has been inserted and the completion accepted, the function
-name of the shell function var(remove-func) in the matches. If one of
+var(remove-func) will be called after the next character typed.  It is
-the matches is finally accepted and the tt(-S)-suffix inserted, this
+passed the length of the suffix as an argument and can use the special
-function will be called after the next character typed. It gets the
+parameters available in ordinary (non-completion) zle widgets (see
-length of the suffix as its argument and can use the special
-parameters available in zle widgets (see
 ifzman(zmanref(zshzle))\
 ifnzman(noderef(Zsh Line Editor))\
 ) to analyse and modify the command line.
 )
 item(tt(-f))(
-If this flag is given, the matches build are marked as being the names 
+If this flag is given, all of the matches built from var(words) are
-of files. They need not be actual filenames, though. But if they are
+marked as being the names of files.  They are not required to be actual
-and the option tt(LIST_TYPES) is set, the characters describing the
+filenames, but if they are, and the option tt(LIST_TYPES) is set, the
-types of the files in the completion lists will be shown. This also
+characters describing the types of the files in the completion lists will
-makes a slash automatically be added when the name of a directory is
+be shown. This also forces a slash to be added when the name of a
-completed.
+directory is completed.
 )
 item(tt(-W) var(file-prefix))(
 This option has the same meaning as for the tt(compctl) and
 tt(compgen) builtin commands. Here, however, only one string may be
-given, not an array. This string is used as a pathname that will be
+given, not an array. This string is a pathname that will be
-prepended to the given words and the prefix given with the tt(-p)
+prepended to each of the matches formed by the given var(words) together 
-option to perform the file-tests when showing completion
+with any prefix specified by the tt(-p) option to form a complete filename
-listings. Hence it is only useful if combined with the tt(-f) flag,
+for testing.  Hence it is only useful if combined with the tt(-f) flag, as
-since the tests will only be performed if that flag is given.
+the tests will not otherwise be performed.
 )
 item(tt(-a))(
-When used by tt(compctl) or tt(compgen) the completion code normally
+In the tt(compctl) or tt(compgen) commands, the completion code normally
 builds two sets of matches: the normal one where words with one of the 
 suffixes in the array parameter tt(fignore) are not considered
 possible matches, and the alternate set where the words excluded
 from the first set are stored. Normally only the matches in the first
-set are used. But if this set is empty, the words from the alternate
+set are used, but if this set is empty, the words from the alternate
 set are used.
 
 The tt(compadd) builtin does not use tt(fignore) parameter and
-normally stores all words in the first set. With the tt(-a)-flag
+normally stores all words in the first set.  With the tt(-a)-flag
-given, however, they are all stored in the alternate set unless this
+given, however, the given var(words) are stored in the alternate set unless
-flag is overridden by the tt(-F) option.
+this flag is overridden by the tt(-F) option.
 )
 item(tt(-F) var(array))(
-This can be used to give an array containing suffixes like the
+Specifies an array containing suffixes in the same form as the
 tt(fignore) parameter. Words with one of these suffixes are stored in
 the alternate set of matches and words without one of these suffixes
 are stored in the normal set.
 
 The var(array) may be the name of an array parameter or a list of
-literal suffixes enclosed in parentheses as in `tt(-F "(.o .h)")'. If
+literal suffixes enclosed in parentheses and quoted, as in `tt(-F "(.o
-the name of an array is given, the elements of the array are taken as
+.h)")'. If the name of an array is given, the elements of the array are
-the suffixes.
+taken as the suffixes.
 )
 item(tt(-Q))(
-As for tt(compctl) and tt(compgen) this flag instructs the completion 
+As for tt(compctl) and tt(compgen), this flag instructs the completion 
 code not to quote any metacharacters in the words when inserting them
-in the command line.
+into the command line.
 )
 item(tt(-M) var(match-spec))(
-This option allows one to give local match specifications with the
+As for tt(compctl) and tt(compgen), this gives local match specifications.
-same meaning and format as for the tt(compctl) and tt(compgen)
+Note that they will only be used if the tt(-U) option is not given.
-builtin commands. Note that they will only be used if the tt(-m) is
-given, too.
 )
 item(tt(-n))(
-Words added with tt(compadd) with this flag will be used as possible
+Specifies that the words added are to be used as possible
-matches as usual but they not appear in the completion listing.
+matches, but are not to appear in the completion listing.
 )
 item(tt(-U))(
-If this flag is given, all words given will be accepted, no matching
+If this flag is given, all words given will be accepted and no matching
 will be done by the completion code. Normally this is used in
 functions that do the matching themselves.
 
 Note that with tt(compadd) this option does not automatically turn on
-menu completion if tt(AUTO_LIST) is set as the same options for the
+menu completion if tt(AUTO_LIST), unlike the corresponding option of
-tt(compctl) and tt(compgen) builtin command do.
+tt(compctl) and tt(compgen) commands.
 )
 item(tt(-O) var(array))(
 If this option is given, the var(words) are em(not) added to the set of
-possible completions. Instead, matching is done as usual and all
+possible completions.  Instead, matching is done as usual and all of the
-var(words) given as arguments that are matched will be stored in the
+var(words) given as arguments that match the string on the command line
-array parameter whose name is given as var(array).
+will be stored in the array parameter whose name is given as var(array).
 )
 item(tt(-A) var(array))(
-Like the tt(-O) option this keeps the var(words) from being stored as
+As the tt(-O) option, except that instead of those of the var(words) which
-possible completions. The matching words are instead stored in the array
+match being stored in var(array), the strings generated internally by the
-parameter given as var(array). In difference to the tt(-O) option this
+completion code are stored. For example,
-does not store the unchanged var(words) given as arguments, but instead
-the strings the completion code generated while matching. For example,
 with a matching specification of `tt(-M "L:|no=")', the string `tt(nof)'
-on the line and the string `tt(foo)' as one of the var(words), this option
+on the command line and the string `tt(foo)' as one of the var(words), this
-will make the string `tt(nofoo)' be stored in the array, whereas the tt(-O)
+option stores the string `tt(nofoo)' in the array, whereas the tt(-O)
 option stores the `tt(foo)' originally given.
 )
 item(tt(-), tt(--))(
@@ -535,9 +530,9 @@ xitem(tt(compset -P) [ var(number) ] var(pattern))
 xitem(tt(compset -s) var(number))
 xitem(tt(compset -S) [ var(number) ] var(pattern))
 xitem(tt(compset -n) var(begin) [ var(end) ])
-item(tt(compset -p) var(beg-pat) [ var(end-pat) ])(
+item(tt(compset -N) var(beg-pat) [ var(end-pat) ])(
-This builtin allows to easily modify the special parameters and at
+This command simplifies modification of the special parameters,
-the same time, to do tests on their values.
+while its return value allows tests on them to be carried out.
 
 The options are:
 
@@ -554,19 +549,19 @@ tt(PREFIX) and appended to tt(IPREFIX).
 
 Without the optional var(number), the longest match is taken, but
 if var(number) is given, anything up to the var(number)'th match is
-moved. If the var(number) is negative, the var(number)'th longest
+moved.  If the var(number) is negative, the var(number)'th longest
 match is moved. For example, if tt(PREFIX) contains the string
-`tt(a=b=c)' doing tt(compset -P '*\=') will move the string `tt(a=b=)' 
+`tt(a=b=c)', then tt(compset -P '*\=') will move the string `tt(a=b=)' 
-into the tt(IPREFIX) parameter, but tt(compset -P 1 '*\=') moves only
+into the tt(IPREFIX) parameter, but tt(compset -P 1 '*\=') will move only
 the string `tt(a=)'.
 )
 item(tt(-s) var(number))(
-Like tt(-p), but prepend the last var(number) characters from the
+As tt(-p), but transfer the last var(number) characters from the
-parameter tt(SUFFIX) to the contents of the parameter tt(ISUFFIX).
+value of tt(SUFFIX) to the front of the value of tt(ISUFFIX).
 )
 item(tt(-S) [ var(number) ] var(pattern))(
-Like tt(-P), but matching from the end of tt(SUFFIX) and moving the
+As tt(-P), but match the last portion of tt(SUFFIX) and transfer the
-matched portion into the parameter tt(ISUFFIX).
+matched portion to the front of the value of tt(ISUFFIX).
 )
 item(tt(-n) var(begin) [ var(end) ])(
 If the current word position as specified by the parameter tt(CURRENT) 
@@ -576,52 +571,51 @@ of the parameter tt(CURRENT) is decremented by var(begin).
 
 If the optional var(end) is given, the modification is done only if
 the current word position is also less than or equal to var(end). In
-this case, the words from position var(end) onwards are removed from
+this case, the words from position var(end) onwards are also removed from
-the tt(words) array, too.
+the tt(words) array.
 
-Both of these numbers may be negative to make them count backwards
+Both var(begin) and var(end) may be negative to count backwards
 from the last element of the tt(words) array.
 )
 item(tt(-N) var(beg-pat) [ var(end-pat) ])(
-If one of the elements of the tt(words) array up to the one at the
+If one of the elements of the tt(words) array before the one at the
 index given by the value of the parameter tt(CURRENT) matches the
-pattern var(beg-pat), all elements up to the matching one are removed
+pattern var(beg-pat), all elements up to and including the matching one are
-from the tt(words) array and the value of tt(CURRENT) is changed to
+removed from the tt(words) array and the value of tt(CURRENT) is changed to
 point to the same word in the changed array.
 
-If the optional pattern var(end-pat) is also given and there is an
+If the optional pattern var(end-pat) is also given, and there is an
 element in the tt(words) array matching this pattern, the parameters
 are modified only if the index of this word is higher than the one
-given by the tt(CURRENT) parameter (meaning that the matching word has 
+given by the tt(CURRENT) parameter (so that the matching word has 
-to be after the cursor). In this case, the words from the word
+to be after the cursor). In this case, the words starting with the one
-matching tt(end-pat) onwards are also removed from the tt(words)
+matching tt(end-pat) are also removed from the tt(words)
 array. If tt(words) contains no word matching var(end-pat), the
-testing and modification is done as if it were not given.
+testing and modification is performed as if it were not given.
 )
 enditem()
 
-In all of these cases the return value is zero if the test succeded
+In all the above cases the return value is zero if the test succeded
-and the parameters were modified, and non-zero otherwise. This allows
+and the parameters were modified and non-zero otherwise. This allows
-one to use this builtin in tests as in:
+one to use this builtin in tests such as:
 
 indent(
 tt(if compset -P '*\='; then ...)
 )
 
-Which makes anything up to and including the last equal sign be
+This forces anything up to and including the last equal sign to be
 ignored by the completion code.
 )
 item(tt(compcall) [ tt(-TD) ])(
 
-This allows one to use completion definitions given with the
+This allows the use of completions defined with the tt(compctl) builtin
-tt(compctl) builtin from within completion widgets. It makes the
+from within completion widgets.  The list of matches will be generated as
-completion code complete the current word according to the
+if one of the non-widget completion function (tt(complete-word), etc.)
-tt(compctl)s defined. Normally only tt(compctl)s given for specific
+had been called, except that only tt(compctl)s given for specific commands
-commands are used. To make the code use the completion flags given to
+are used. To force the code to try completions defined with the tt(-T)
-the tt(-T) option of tt(compctl), one can give the tt(-T) flag to
+option of tt(compctl) and/or the default completion (whether defined by
-tt(compctl). Likewise, the tt(-D) flag to tt(compcall) makes the
+tt(compctl -D) or the builtin default) in the appropriate places, the
-default completion flags given to tt(compctl) with the tt(-D) option
+tt(-T) and/or tt(-D) flags can be passed to tt(compcall).
-be used.
 
 The return value can be used to test if a matching tt(compctl)
 definition was found. It is non-zero if a tt(compctl) was found and
@@ -632,30 +626,25 @@ enditem()
 texinode(Condition Codes)(Examples)(Builtin Commands)(Completion Widgets)
 sect(Condition Codes)
 
-Inside completion widgets not only the builtin commands described
+The following additional condition codes for use within the tt([[ ... ]])
-above can be used, but also some additional condition codes. These
+construct are available in completion widgets.  These work on the special
-work on the special parameters and can be used to easily build
+parameters.  All of these tests can also be performed by the tt(compset)
-completion functions that generate different matches depending on the
+builtin, but in the case of the condition codes the contents of the special
-strings on the line. All of these condition codes perform tests also
+parameters are not modified.
-done by the tt(compset) builtin, but they don't modify the contents of 
-the special parameters.
-
-The following condition codes are made available inside completion
-widgets:
 
 startitem()
 item(tt(-prefix) [ var(number) ] var(pattern))(
-true if the test for the tt(-P) option of tt(compset) would succeed
+true if the test for the tt(-P) option of tt(compset) would succeed.
 )
 item(tt(-suffix) [ var(number) ] var(pattern))(
-true if the test for the tt(-S) option of tt(compset) would succeed
+true if the test for the tt(-S) option of tt(compset) would succeed.
 )
 item(tt(-after) var(beg-pat))(
 true if the test of the tt(-N) option with only the var(beg-pat) given 
-would succeed
+would succeed.
 )
 item(tt(-between) var(beg-pat end-pat))(
-true if the test for the tt(-N) option with both patterns would succeed
+true if the test for the tt(-N) option with both patterns would succeed.
 )
 enditem()
 
@@ -674,17 +663,17 @@ indent(nofill(
 tt(bindkey '^X\t' complete)))
 
 After that the shell function tt(complete-history) will be invoked
-after typing control-X and TAB. The function should then generte the
+after typing control-X and TAB. The function should then generate the
 matches, e.g.:
 
 indent(nofill(
 tt(complete-history LPAR()RPAR() { compgen -H 0 '' })))
 
-In this the function will complete words from the history matching the 
+This function will complete words from the history matching the 
 current word.
 
-For a description of the example completion system from the
+For a description of the widget-based completion system provided with the
-distributions, see
+source code distribution, see
 ifzman(zmanref(zshcompsys))\
 ifnzman(noderef(Completion System))\
 .

Doc/Zsh/guide.yo

@@ -32,6 +32,7 @@ menu(Programmable Completion)
 menu(Completion Widgets)
 menu(Zsh Modules)
 menu(Completion System)
+menu(Zftp Function System)
 
  --- Indices ---
 

Doc/Zsh/mod_zftp.yo

@@ -10,8 +10,11 @@ item(tt(zftp) var(subcommand) [ var(args) ])(
 The tt(zftp) module is a client for FTP (file transfer protocol).  It
 is implemented as a builtin to allow full use of shell command line
 editing, file I/O, and job control mechanisms.  Often, users will
-access it via shell functions providing higher level abilities such as
+access it via shell functions providing a more powerful interface; a set is
-username and password lookup.  However, it is entirely usable in its
+provided with the tt(zsh) distribution and is described in
+ifzman(zmanref(zshzftpsys))\
+ifnzman(noderef(Zftp Function System))\
+.  However, the tt(zftp) command is entirely usable in its
 own right.
 
 All commands consist of the command name tt(zftp) followed by the name

Doc/Zsh/zftpsys.yo

@@ -0,0 +1,435 @@
+texinode(Zftp Function System)()(Completion System)(Top)
+chapter(Zftp Function System)
+cindex(zftp, function system)
+sect(Description)
+
+This describes the set of shell functions supplied with the source
+distribution as an interface to the tt(zftp) builtin command, allowing you
+to perform FTP operations from the shell command line or within functions
+or scripts.  The interface is similar to a traditional FTP client (e.g. the
+manref(ftp)(1) command itself), but as it is entirely done within the shell
+all the familar completion, editing and globbing features, and so on, are
+present, and macros are particularly simple to write as they are just
+ordinary shell functions.
+
+The prerequisite is that the tt(zftp) command, as described in
+ifzman(\
+zmanref(zshmodules)
+)\
+ifnzman(\
+noderef(The zftp Module)
+), must be available in the
+version of tt(zsh) installed at your site.  If the shell is configured to
+load new commands at run time, it probably is: typing tt(zmodload zftp)
+will make sure (if that runs silently, it has worked).  If this is not the
+case, it is possible tt(zftp) was linked into the shell anyway: to test
+this, type tt(which zftp) and if tt(zftp) is available you will get the
+message tt(zftp: shell built-in command).
+
+Commands given directly with tt(zftp) builtin may be interspersed between
+the functions in this suite; in a few cases, using tt(zftp) directly may
+cause some of the status information stored in shell parameters to become
+invalid.  Note in particular the description of the variables
+tt($ZFTP_TMOUT), tt($ZFTP_PREFS) and tt($ZFTP_VERBOSE) for tt(zftp).
+
+startmenu()
+menu(Installation)
+menu(Zftp Functions)
+menu(Miscellaneous Features)
+endmenu()
+
+texinode(Installation)(Zftp Functions)()(Zftp Function System)
+sect(Installation)
+
+You should make sure all the functions from the tt(Functions/Zftp)
+directory of the source distribution are available; they all begin with the
+two letters tt(zf).  They may already have been installed on your system;
+otherwise, you will need to find them and copy them.  The directory should
+appear as one of the elements of the tt($fpath) array, and the functions
+should be autoloaded.  Finally, to initialise the use of the system you
+need to call the tt(zfinit) function.  The following code in your
+tt(.zshrc) will arrange for this; assume the functions are stored in the
+directory tt(~/myfns):
+
+tt(indent(
+nofill(fpath=(~/myfns $fpath))
+nofill(autoload ~/myfns/zf*(:t))
+nofill(zfinit)
+))
+
+Note that tt(zfinit) assumes you are using the tt(zmodload) method to
+load the tt(zftp) command.  If it is already built into the shell, change
+tt(zfinit) to tt(zfinit -n).
+
+texinode(Zftp Functions)(Miscellaneous Features)(Installation)(Zftp Function System)
+sect(Functions)
+
+The sequence of operations in performing a file transfer is essentially the
+same as that in a standard FTP client.
+
+subsect(Opening a connection)
+startitem()
+item(tt(zfparams [ var(host) [ var(user) [ var(password) ... ] ] ]))(
+Set or show the parameters for a future tt(zfopen) with no arguments.  If
+no arguments are given, the current parameters are displayed (the password
+will be shown as a line of asterisks).  If a host is given, and either the
+var(user) or var(password) is not, they will be prompted for; also, any
+parameter given as `tt(?)' will be prompted for.
+
+As tt(zfopen) calls tt(zfparams) to store the parameters, this usually need
+not be called directly.
+)
+item(tt(zfopen [ -1 ] [ var(host) [ var(user) [ var(password) [ var(account) ] ] ] ]))(
+If var(host) is present, open a connection to that host under username
+var(user) with password var(password) (and, on the rare occasions when it
+is necessary account var(account)).  If a necessary parameter is missing or
+given as `tt(?)' it will be prompted for.  If var(host) is not present, use
+a previously stored set of parameters.
+
+If the command was successful, and the terminal is an tt(xterm), a summary
+will appear in the title bar, giving the local tt(host:directory) and the
+remote tt(host:directory); this is handled by the function tt(zftp_chpwd),
+described below.
+
+Normally, the var(host), var(user) and var(password) are internally
+recorded for later re-opening, either by a tt(zfopen) with no arguments, or
+automatically (see below).  With the option tt(-1), no information is
+stored.
+)
+item(tt(zfanon [ -1 ] var(host)))(
+Open a connection var(host) for anonymous FTP.  The username used is
+tt(anonymous).  The password (which will be reported the first time) is
+generated from var(user)tt(@)tt(host); this is then stored in the shell
+parameter tt($EMAIL_ADDR) which can alternatively be set manually to a
+suitable string.
+)
+enditem()
+
+subsect(Directory management)
+startitem()
+xitem(tt(zfcd [ var(dir) ]))
+xitem(tt(zfcd -))
+item(tt(zfcd var(old) var(new)))(
+Change the current directory on the remote server:  this is implemented to
+have many of the features of the shell builtin tt(cd).
+
+In the first form with var(dir) present, change to the directory var(dir).
+The command tt(zfcd ..) is treated specially, so is guaranteed to work on
+non-UNIX servers (note this is handled internall by tt(zftp)).  If var(dir)
+is omitted, has the effect of tt(zfcd ~).
+
+The second form changes to the directory previously current.
+
+The third form attempts to change the current directory by replacing the
+first occurrence of the string var(old) with the string var(new) in the
+current directory.
+
+Note that in this command, and indeed anywhere a remote filename is
+expected, the string which on the local host corresponds to tt(~) is
+converted back to a tt(~) before being passed to the remote machine.
+This is convenient because of the way expansion is performed on the command
+line before tt(zfcd) receives a string.  For example, suppose the command
+is tt(zfcd ~/foo).  The shell will expand this to a full path as in tt(zfcd
+/home/user2/pws/foo).  At this stage, tt(zfcd) recognises the initial path
+as tt(~), and the directory sent to the remote host is tt(~/foo), so that
+the tt(~) will be expanded by the server to the correct remote host
+directory.  Other named directories of the form tt(~name) are not treated
+in this fashion.
+)
+item(tt(zfhere))(
+Change directory on the remote server to the one corresponding to the
+current local directory, with special handling of tt(~) as in tt(zfcd).
+For example, if the current local directory is tt(~/foo/bar), then
+tt(zfhere) performs the effect of tt(zfcd ~/foo/bar).
+)
+item(tt(zfdir [ -rfd ] [ - ] [ var(dir-options) ] [ var(dir) ]))(
+Produce a long directory listing.  The arguments var(dir-options) and
+var(dir) are passed directly to the server and their effect is
+implementation dependent, but specifying a particular remote directory
+var(dir) is usually possible.  The output is passed through pager.
+
+The directory is usually cached for re-use.  In fact, two caches are
+maintained.  One is for use when there is no var(dir-options) or var(dir),
+i.e. a full listing of the current remote directory; it is flushed
+when the current remote directory changes.  The other is
+kept for repeated use of tt(zfdir) with the same arguments; for example,
+repeated use of tt(zfdir /pub/gnu) will only require the directory to be
+retrieved on the first call.  Alternatively, this cache can be re-viewed with
+the tt(-r) option.  As relative directories will confuse
+tt(zfdir), the tt(-f) option can be used to force the cache to be flushed.
+Also, the option tt(-d) will delete both caches without showing a directory
+listing.
+)
+item(tt(zfls) [ var(ls-options) ] [ var(dir) ])(
+List files on the remote server.  With no arguments, this will produce a
+simple list of file names for the current remote directory.  Any arguments
+are passed directory to the server.  No pager and no caching is used.
+)
+enditem()
+
+subsect(Status commands)
+startitem()
+item(tt(zftype) [ var(type) ])(
+With no arguments, show the type of data to be transferred, usually ASCII
+or binary.  With an argument, change the type: the types tt(A) or
+tt(ASCII) for ASCII data and tt(B) or tt(BINARY), tt(I) or tt(IMAGE) for
+binary data are understood case-insensitively.
+)
+item(tt(zfstat) [ -v ])(
+Show the status of the current or last connection, as well as the status of
+some of tt(zftp)'s status variables.  With the tt(-v) option, a more
+verbose listing is produced by querying the server for its version of
+events, too.
+)
+enditem()
+
+subsect(Retrieving files)
+The commands for retrieving files all take at least two options. tt(-G)
+suppresses remote filename expansion which would otherwise be performed
+(see below for a more detailed description of that).  tt(-t) attempts
+to set the modification time of the local file to that of the remote file:
+this requires version 5 of tt(perl), see the description of the function
+tt(zfrtime) below for more information.
+
+startitem()
+item(tt(zfget [ -Gt ] var(file1) ...))(
+Retrieve all the listed files var(file1) ... one at a time from the remote
+server.  If a file contains a `tt(/)', the full name is passed to the
+remote server, but the file is stored locally under the name given by the
+part after the final `tt(/)'.
+)
+item(tt(zfuget [ -Gvst ] var(file1) ...))(
+As tt(zfget), but only retrieve files where the version on the remote
+server is newer (has a later modification time), or where the local file
+does not exist.  If the remote file is older but the files have different
+sizes, or if the sizes are the same but the remote file is newer, the user
+will usually be queried.  With the option tt(-s), the command runs silently
+and will always retrieve the file in either of those two cases.  With the
+option tt(-v), the command prints more information about the files while it
+is working out whether or not to transfer them.
+)
+item(tt(zfcget [ -Gt ] var(file1) ...))(
+As tt(zfget), but if any of the local files exists, and is shorter than
+the corresponding remote file, the command assumes that it is the result of
+a partially completed transfer and attempts to transfer the rest of the
+file.  This is useful on a poor connection which keeps failing.
+
+Note that this requires a commonly implemented, but non-standard, version
+of the FTP protocol, so is not guaranteed to work on all servers.
+)
+xitem(tt(zfgcp [ -Gt ] var(remote-file) var(local-file)))
+item(tt(zfgcp [ -Gt ] var(rfile1) ... var(ldir)))(
+This retrieves files from the remote server with arguments behaving
+similarly to the tt(cp) command.
+
+In the first form, copy var(remote-file) from the server to the local file
+var(local-file).
+
+In the second form, copy all the remote files var(rfile1) ... into the
+local directory var(ldir) retaining the same basenames.  This assumes UNIX
+directory semantics.
+)
+enditem()
+
+subsect(Sending files)
+startitem()
+item(tt(zfput var(file1) ...))(
+Send all the var(file1) ... given separately to the remote server.  If a
+filename contains a `tt(/)', the full filename is used locally to find the
+file, but only the basename is used for the remote file name.
+)
+item(tt(zfuput [ -vs ] var(file1) ...))(
+As tt(zfput), but only send files which are newer than their local
+equivalents, or if the remote file does not exist.  The logic is the same
+as for tt(zfuget), but reversed between local and remote files.
+)
+item(tt(zfcput var(file1) ...))(
+As tt(zfput), but if any remote file already exists and is shorter than the
+local equivalent, assume it is the result of an incomplete transfer and
+send the rest of the file to append to the existing part.  As the FTP
+append command is part of the standard set, this is in principle more
+likely to work than tt(zfcget).
+)
+xitem(tt(zfpcp var(local-file) var(remote-file)))
+item(tt(zfpcp var(lfile1) ... var(rdir)))(
+This sends files to the remote server with arguments behaving similarly to
+the tt(cp) command.
+
+With two arguments, copy var(local-file) to the server as
+var(remote-file).
+
+With more than two arguments, copy all the local files var(lfile1) ... into
+the existing remote directory var(rdir) retaining the same basenames.  This
+assumes UNIX directory semantics.
+
+A problem arises if you attempt to use tt(zfpcp) var(lfile1) var(rdir),
+i.e. the second form of copying but with two arguments, as the command has
+no simple way of knowing if var(rdir) corresponds to a directory or a
+filename.  It attempts to resolve this in various ways.  First, if the
+var(rdir) argument is tt(.) or tt(..) or ends in a slash, it is assumed to
+be a directory.  Secondly, if the operation of copying to a remote file in
+the first form failed, and the remote server sends back the expected
+failure code 553 and a reply including the string `tt(Is a directory)',
+then tt(zfpcp) will retry using the second form.
+)
+enditem()
+
+subsect(Closing the connectino)
+startitem()
+item(tt(zfclose))(
+Close the connection.
+)
+enditem()
+
+subsect(Other functions)
+Mostly, these functions will not be called directly (apart from
+tt(zfinit)), but are described here for completeness.  You may wish to
+alter tt(zftp_chpwd) and tt(zftp_progress), in particular.
+
+startitem()
+item(tt(zfinit [ -n ]))(
+As decribed above, this is used to initialise the zftp function system.
+The tt(-n) option should be used if the zftp command is already built into
+the shell.
+)
+item(tt(zfautocheck [ -dn ]))(
+This function is called to implement automatic reopening behaviour, as
+described in more detail below.  The options must appear in the first
+argument; tt(-n) prevents the command from changing to the old directory,
+while tt(-d) prevents it from setting the variable tt(do_close), which it
+otherwise does as a flag for automatically closing the connection after a
+transfer.  The host and directory for the last session are stored in the
+variable tt($zflastsession), but the internal host/user/password parameters
+must also be correctly set.
+)
+item(tt(zfcd_match var(prefix) var(suffix)))(
+This performs matching for completion of remote directory names.  If the
+remote server is UNIX, it will attempt to persuade the server to list the
+remote directory with subdirectories marked, which usually works but is not
+guaranteed.  On other hosts it simply calls tt(zfget_match) and hence
+completes all files, not just directories.  On some systems, directories
+may not even look like filenames.
+)
+item(tt(zfget_match var(prefix) var(suffix)))(
+This performs matching for completion of remote filenames.  It caches files
+for the current directory (only) in the shell parameter tt($zftp_fcache).
+It is in the form to be called by the tt(-K) option of tt(compctl), but
+also works when called from a widget-style completion function with
+var(prefix) and var(suffix) set appropriately.
+)
+item(tt(zfrglob var(varname)))(
+Perform remote globbing, as describes in more detail below.  var(varname)
+is the name of a variable containing the pattern to be expanded; if there
+were any matches, the same variable will be set to the exanded set of
+filenames on return.
+)
+item(tt(zfrtime var(lfile) var(rfile) [ var(time) ]))(
+Set the local file var(lfile) to have the same modification time as the
+remote file var(rfile), or the explicit time var(time) in FTP format
+tt(CCYYMMDDhhmmSS) for the GMT timezone.
+
+Currently this requires tt(perl) version 5 to perform the conversion from
+GMT to local time.  This is unfortunately difficult to do using shell code
+alone.
+)
+item(tt(zftp_chpwd))(
+This function is called every time a connection is opened, or closed, or
+the remote directory changes.  This version alters the title bar of an
+tt(xterm) or tt(sun-cmd) terminal emulator to reflect the local and remote
+hostnames and current directories.  It works best when combined with the
+function tt(chpwd).  In particular, a function of the form
+
+tt(indent(
+nofill(chpwd() {)
+nofill(  if [[ -n $ZFTP_USER ]]; then)
+nofill(    zftp_chpwd)
+nofill(  else)
+nofill(    # usual chpwd e.g put host:directory in title bar)
+nofill(  fi)
+nofill(})
+))
+
+fits in well.
+)
+item(tt(zftp_progress))(
+This function shows the status of the transfer as the percentage of the
+total so far transferred.  It will not write anything unless the output is
+going to a terminal; however, if you transfer files in the background, you
+should tt(unfunction) this first.  (Background file transfers don't work on
+all OSes.)  Note also that if you alter it, any output em(must) be to
+standard error, as standard output may be a file being received.
+)
+enditem()
+
+texinode(Miscellaneous Features)()(Zftp Functions)(Zftp Function System)
+sect(Miscellaneous Features)
+
+subsect(Remote globbing)
+
+The commands for retrieving files usually perform filename expansion
+(globbing) on their arguments; this can be turned off by passing the option
+tt(-G) to each of the commands.  Normally this operates by retrieving a
+complete list of files for the directory in question, then matching these
+locally against the pattern supplied.  This has the advantage that the full
+range of zsh patterns (respecting the setting of the option
+tt(EXTENDED_GLOB)) can be used.  However, it means that the directory part
+of a filename will not be expanded and must be given exactly.  If the
+remote server does not support the UNIX directory semantics, directory
+handling is problematic and it is recommended that globbing only be used
+within the current directory.  The list of files in the current directory,
+if retrieved, will be cached, so that subsequent globs in the same
+directory without an interventing tt(zfcd) are fast.
+
+If the variable tt($zfrglob) is set to a non-zero length, globbing is
+instead performed on the remote host:  the server is asked for a list of
+matching files.  This is highly dependent on how the server is implemented,
+though typically UNIX servers will provide support for basic glob
+patterns.  This may in some cases be faster, as it avoids retrieving the
+entire list of directory contents.
+
+subsect(Automatic and temporary reopening)
+
+As described for the tt(zfopen) command, a subsequent tt(zfopen) with no
+parameters will reopen the connection to the last host (this includes
+connections made with the tt(zfanon) command).  Opened in this fashion, the
+connection starts in the default remote directory and will remain open
+until explicitly closed.
+
+Automatic re-opening is also available.  If a connection is not currently
+open and a command requiring a connection is given, the last connection is
+implicitly reopened.  In this case the directory which was current when the
+connection was closed again becomes the current directory (unless, of
+course, the command given changes it).  Automatic reopening will also take
+place if the connection was close by the remote server for whatever reason
+(e.g. a timeout).  It is not available if the tt(-1) option to tt(zfopen)
+or tt(zfanon) was used.
+
+Furthermore, if the command issued is a file transfer, the connection will
+be closed after the transfer is finished, hence providing a one-shot mode
+for transfers.  This does not apply to directory changing or listing
+commands; for example a tt(zfdir) may reopen a connection but will leave it
+open.  Also, automatic closure will only ever happen in the same command as
+automatic opening, i.e a tt(zfdir) directly followed by a tt(zfget) will
+never close the connection automatically.
+
+Information about the previous connection is given by the tt(zfstat)
+function.  So, for example, if that reports:
+
+tt(indent(
+nofill(Not connected.)
+nofill(Last session:   ftp.bar.com:/pub/textfiles)
+))
+
+then the command tt(zfget file.txt) will attempt to reopen a connection to
+tt(ftp.bar.com), retrieve the file tt(/pub/textfiles/file.txt), and
+immediately close the connection again.  On the other hand, tt(zfcd ..)
+will open the connection in the directory tt(/pub) and leave it open.
+
+subsect(Completion)
+
+Completion of remote files and directories is supported.  The older,
+tt(compctl)-style completion is defined when tt(zfinit) is called; support
+for the new widget-based completion system is provided in the function
+tt(Completion/Builtins/_zftp), which should be installed with the other
+functions of the completion system and hence should automatically be
+available.

Doc/zsh.yo

@@ -67,6 +67,7 @@ ifnzman(includefile(Zsh/compctl.yo))

 ifnzman(includefile(Zsh/compwid.yo))

 ifnzman(includefile(Zsh/modules.yo))

 ifnzman(includefile(Zsh/compsys.yo))

+ifnzman(includefile(Zsh/zftpsys.yo))

 ifzshall(\
 def(source)(1)(NOTRANS(.so )man1/ARG1NOTRANS(.)1)\
 CMT()
@@ -80,6 +81,7 @@ source(zshcompctl)
 source(zshcompwid)
 source(zshmodules)
 source(zshcompsys)
+source(zshzftpsys)
 manpage(ZSHALL)(1)(date())(zsh version())
 )\
 ifzman(includefile(Zsh/filelist.yo))

Etc/FAQ.yo

@@ -43,27 +43,17 @@ whenlatex(report(ARG1)(ARG2)(ARG3))\
 whenman(report(ARG1)(ARG2)(ARG3))\
 whenms(report(ARG1)(ARG2)(ARG3))\
 whensgml(report(ARG1)(ARG2)(ARG3)))
-myreport(Z-Shell Frequently-Asked Questions)(Peter Stephenson)(1999/02/25)
+myreport(Z-Shell Frequently-Asked Questions)(Peter Stephenson)(1999/04/23)
 COMMENT(-- the following are for Usenet and must appear first)\
 description(
 mydit(Archive-Name:) unix-faq/shell/zsh
-mydit(Last-Modified:) 1999/02/05
+mydit(Last-Modified:) 1999/04/23
 mydit(Submitted-By:) email(pws@ibmth.df.unipi.it (Peter Stephenson))
-mydit(Version:) $Id: FAQ.yo,v 1.1.1.2 1999/04/15 18:20:31 akr Exp $
+mydit(Version:) $Id: FAQ.yo,v 1.1.1.3 1999/04/25 15:43:54 akr Exp $
 mydit(Posting-Frequency:) Monthly
 mydit(Copyright:) (C) P.W. Stephenson, 1995--1999 (see end of document)
 )
 
-bf(Changes since issue posted January 1999:)
-description(
-mydit(1.1)  deleted the bit saying startup files are not mentioned.
-mydit(3.2)  New: about startup files.
-mydit(3.7)  we just found the PRINT_EIGHT_BIT option again...
-mydit(3.22) New: about ${(e)...} and ${${...}}.
-mydit(5.2)  (In wishlist): patch exists for 3.1 to handle tying
-     texinputs/TEXINPUTS etc.
-)
-
 This document contains a list of frequently-asked (or otherwise
 significant) questions concerning the Z-shell, a command interpreter
 for many UNIX systems which is freely available to anyone with FTP
@@ -160,10 +150,12 @@ url(http://sunsite.auc.dk/zsh/FAQ/)(http://sunsite.auc.dk/zsh/FAQ/) .
   The site also contains some contributed zsh scripts and functions;
   we are delighted to add more, or simply links to your own collection.
 
-  This document was originally written in YODL, allowing it to be
+  This document was originally written in YODL, allowing it to be converted
-  converted easily into various other formats.  The master source
+  easily into various other formats.  The master source file lives at
-  file lives at url(http://sunsite.auc.dk/zsh/FAQ/zshfaq.yo)
+  url(http://sunsite.auc.dk/zsh/FAQ/zshfaq.yo)
-(http://sunsite.auc.dk/zsh/FAQ/zshfaq.yo) .
+(http://sunsite.auc.dk/zsh/FAQ/zshfaq.yo) and the plain text version
+  can be found at url(http://sunsite.auc.dk/zsh/FAQ/zshfaq.txt)
+(http://sunsite.auc.dk/zsh/FAQ/zshfaq.txt) .
 
   Another useful source of information is the collection of FAQ articles
   posted frequently to the Usenet news groups comp.unix.questions,
@@ -297,12 +289,13 @@ sect(On what machines will it run?)
 
 sect(What's the latest version?)
 
-  Zsh 3.0.5 is the latest production version. The new major number 3.0
+  Zsh 3.0.5 is the latest production version, however a test version of
-  largely reflects the considerable internal changes in zsh to make it
+  3.0.6 is doing the rounds and should be released soon. The new major
-  more reliable, consistent and (where possible) compatible.  Those
+  number 3.0 largely reflects the considerable internal changes in zsh to
-  planning on upgrading their zsh installation should take a look at
+  make it more reliable, consistent and (where possible) compatible.  Those
-  the list of incompatibilities at the end of link(5.1)(51).  This is
+  planning on upgrading their zsh installation should take a look at the
-  longer than usual due to enhanced sh, ksh and POSIX compatibility.
+  list of incompatibilities at the end of link(5.1)(51).  This is longer
+  than usual due to enhanced sh, ksh and POSIX compatibility.
 
   The beta version 3.1.5 is also available.  Development of zsh is
   usually patch by patch, with each intermediate version publicly
@@ -1886,8 +1879,9 @@ this applies
      mytt(compress file) any more.  For this reason, mytt(\M-n) and
      mytt(\M-p) use tt(history-beginning-search-{forward,backward}) which
      search for a line with the same prefix up to the cursor position.
-     It is possible to write functions which go a little closer to the
+     From 3.1.6, there is likely to be a different implementation which
-     original behaviour; further changes are still possible.
+     makes this closer (though not identical) to the old behaviour.
+     The story for the tt({up,down}-line-or-search) commands is similar.
   it() In vi insert mode, the cursor keys no longer work.  The following
      will bind them:
       COMMENT(-- note space after backslash --)
@@ -2028,19 +2022,47 @@ sect(What's on the wish-list?)
   lexing/parsing/execution might also be an advantage.  Volunteers are
   particularly welcome for these tasks.
 
-  An improved line editor, with user-definable functions and binding
+  Here are some things which are definitely happening, and will probably
-  of multiple functions to keystrokes, is being developed.
+  appear in zsh 3.1.6.
-
   itemize(
-  it() Loadable module support (will be in 3.1 but much work still needs
+  it() Even more powerful new completion system, based on shell functions,
-     doing).
+     allowing much more detailed control both over generation of matches
+     for completion and how they are inserted and displayed.  A set of
+     functions which work `out of the box' will be available, including
+     many functions for external commands:  files in tar archives can
+     be listed for extraction as if they were real files; GNU commands
+     which accept the mytt(--help) option can generate completion lists for
+     themselves on the fly, etc., etc.
+     You can have old-style tt(compctl)-based completions for some commands,
+     and new-style ones for others; you can bind particular completion
+     commands of your own definition to key-strokes.
+  it() Other completion enhancements:  matching control, allowing
+     case-insensitive matching and wild card anchors, e.g. mytt(z_t<TAB>)
+     can allow a wildcard before the mytt(_) so that this will expand
+     to mytt(zle_tricky.c) --- all under user control; completions can
+     be grouped.
+  it() Case-insensitive and approximate matching in the globbing code:
+     for example, mytt((#ia2)readme) matches the string mytt(readme)
+     case-insensitively with up to two errors, such as tt(README),
+     tt(READ.ME), tt(_README_), tt(Read!Me!).  The new completion system
+     knows about these, allowing correcting completion, e.g.
+     mytt(mkaef<TAB>) can be made to complete to mytt(Makefile).
+  it() Associative arrays, declared with mytt(typeset -A aname); syntax
+     for creating, accessing and deleting elements of these.
+  it() Users can create their own tt(foopath)/tt(FOOPATH) array/path
+     combinations, just like tt(path) and tt(PATH).
+  it() A dynamically loadable library for FTP, complete with a suite of
+     functions to make it easy to use.  This allows you to use the shell's
+     capabilities for scripting, line editing, completion, I/O redirection,
+     directory management etc. within an FTP session.
+  )
+
+  Other future possibilities which have been suggested:
+  itemize(
+  it() Further improvements in integrating the line editor with shell
+     functions.
   it() Ksh compatibility could be improved.
   it() Option for glob qualifiers to follow perl syntax (a traditional item).
-  it() Binding of shell functions to key strokes, accessing editing
-     buffer from functions, executing zle functions as a command:  now
-     under development for 3.1. 
-  it() Users should be able to create their own foopath/FOOPATH array/path
-     combinations (now exists as a patch for 3.1).
   )
 
 

Functions/Zftp/README

@@ -0,0 +1,4 @@
+This directory contains a set of functions acting as a front end to the
+zftp command, provided as an add-on module.  They allow you to perform FTP
+tasks from within the shell using as many of the shell's own facilities
+as possible.  For more information, see the zshzftpsys manual page.

Functions/Zftp/zfanon

@@ -0,0 +1,70 @@
+# function zfanon {
+
+emulate -L zsh
+
+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
+# }

Functions/Zftp/zfautocheck

@@ -0,0 +1,33 @@
+# function zfautocheck {
+# This function is used to implement auto-open behaviour.
+#
+# With first argument including n, don't change to the old directory; else do.
+#
+# Set do_close to 1 if the connection was not previously open, 0 otherwise
+# With first arguemnt including d, don't set do_close to 1.  Broadly
+# speaking, we use this mechanism to shut the connection after use
+# if the connection had been explicitly closed (i.e. didn't time out,
+# which zftp test investigates) and we are not using a directory
+# command, which implies we are looking for something so should stay open
+# for it.
+
+# Remember the old session:  zflastsession will be overwritten by
+# a successful open.
+local lastsession=$zflastsession
+
+if [[ -z $ZFTP_HOST ]]; then
+  zfopen || return 1
+  [[ $1 = *d* ]] || do_close=1
+elif zftp test 2>/dev/null; then
+  return 0
+else
+  zfopen || return 1
+fi
+
+if [[ $1 = *n* ]]; then
+  return 0
+elif [[ -n $lastsession && $ZFTP_HOST = ${lastsession%%:*} ]]; then
+  zfcd ${lastsession#*:}
+fi
+
+# }

Functions/Zftp/zfcd

@@ -0,0 +1,52 @@
+# 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.
+
+emulate -L zsh
+
+if [[ $1 = /* ]]; then
+  zfautocheck -dn
+else
+  zfautocheck -d
+fi
+
+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
+print $zflastsession
+# }

Functions/Zftp/zfcd_match

@@ -0,0 +1,42 @@
+# function zfcd_match {
+
+emulate -L zsh
+
+# 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?
+
+local tmpf=${TMPPREFIX}zfcm$$
+
+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.
+  zftp ls -F $dir >$tmpf
+  reply=($(awk '/\/$/ { print substr($1, 0, length($1)-1) }' $tmpf))
+  rm -f $tmpf
+  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
+
+# }

Functions/Zftp/zfcget

@@ -0,0 +1,87 @@
+# 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.
+
+emulate -L zsh
+
+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
+# }

Functions/Zftp/zfclose

@@ -0,0 +1,3 @@
+# function zfclose {
+zftp close
+# }

Functions/Zftp/zfcput

@@ -0,0 +1,76 @@
+# function zfcput {
+# Continuation put of files from remote server.
+# For each file, if it's shorter over there, put the remainder from
+# over here.  This uses append, which is standard, so unlike zfcget it's
+# expected to work on any reasonable server... err, as long as it
+# supports SIZE and MDTM.  (It could be enhanced so you can enter the
+# size so far by hand.)  You should probably be in binary transfer
+# mode, thought it's not enforced.
+#
+# To read from midway through a local file, `tail +<n>c' is used.
+# It would be nice to find a way of doing this which works on all OS's.
+
+emulate -L zsh
+
+local loc rem stat=0 locst remst offs tailtype
+local tmpfile=${TMPPREFIX}zfcget$$ rstat
+
+# find how tail works.  this is intensely annoying, since it's completely
+# standard in C.  od's no use, since we can only skip whole blocks.
+if [[ $(echo abcd | tail +2c) = bcd ]]; then
+  tailtype=c
+elif [[ $(echo abcd | tail --bytes=+2) = bcd ]]; then
+  tailtype=b
+else
+  print "I can't get your \`tail' to start from from arbitrary characters.\n" \
+  "If you know how to do this, let me know." 2>&1
+  return 1
+fi
+
+for loc in $*; do
+  # zfcd directory hack to put the front back to ~
+  rem=$loc
+  if [[ $rem = $HOME || $rem = $HOME/* ]]; then
+    rem="~${rem#$HOME}"
+  fi
+  if [[ ! -r $loc ]]; then
+    print "Can't read file $loc"
+    stat=1
+  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 remote status commands.\n" \
+      "You will have to find out the size by hand and use zftp append." 2>&1
+      stat=1
+      continue
+    elif [[ $rstat = 1 ]]; then
+      # Not found, so just do a standard put.
+      zftp put $rem <$loc
+    elif [[ $remst[1] -gt $locst[1] ]]; then
+      print "Remote file is larger!" 2>&1
+      continue;
+    elif [[ $locst[1] == $remst[1] ]]; then
+      print "Files are already the same size." 2>&1
+      continue
+    else
+      # tail +<N>c takes the count of the character
+      # to start from, not the offset from zero. if we did
+      # this with years, then 2000 would be 1999.  no y2k bug!
+      # brilliant.
+      (( offs = $remst[1] + 1 ))
+      if [[ $tailtype = c ]]; then
+	tail +${offs}c $loc | zftp append $rem || stat=1
+      else
+	tail --bytes=+$offs $loc | zftp append $rem || stat=1
+      fi
+    fi
+  fi
+done
+
+return $stat
+# }

Functions/Zftp/zfdir

@@ -0,0 +1,99 @@
+# 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.;
+# unrecognised options are passed through to dir, but zfdir options must
+# appear first and unmixed with the others.
+
+emulate -L zsh
+setopt extendedglob
+
+local file opt optlist redir i newargs force
+
+while [[ $1 = -* ]]; do
+  if [[ $1 = - || $1 = -- ]]; then
+    shift;
+    break;
+  elif [[ $1 != -[rfd]## ]]; then
+    # pass options through to ls
+    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
+	 ;;
+    esac
+  done
+  shift
+done
+
+zfautocheck -d
+
+# 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
+  if (zftp test); then
+    # Works OK in subshells
+    zftp dir $* | tee $file | eval ${PAGER-:more}
+  else
+    # Doesn't work in subshells (IRIX 6.2 --- why?)
+    zftp dir $* >$file
+    eval ${PAGER-:more} $file
+  fi
+fi
+# }

Functions/Zftp/zfgcp

@@ -0,0 +1,83 @@
+# 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.
+#  zfgcp rfile lfile
+# or
+#  zfgcp 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.
+#
+# If there is no current connection, try to use the existing set of open
+# parameters to establish one and close it immediately afterwards.
+
+emulate -L zsh
+
+local opt optlist nglob remlist rem loc time
+integer stat do_close
+
+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
+
+zfautocheck
+
+# 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
+
+(( $do_close )) && zfclose
+
+return $stat
+# }

Functions/Zftp/zfget

@@ -0,0 +1,64 @@
+# 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.
+#
+# If the connection is not currently open, try to open it with the current
+# parameters (set by a previous zfopen or zfparams), then close it after
+# use.  The file is put in the current directory (i.e. using the basename
+# of the remote file only); for more control, use zfgcp.
+
+emulate -L zsh
+
+local loc rem optlist opt nglob remlist time
+integer stat do_close
+
+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
+
+zfautocheck
+
+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
+
+(( $do_close )) && zfclose
+
+return $stat
+# }

Functions/Zftp/zfget_match

@@ -0,0 +1,27 @@
+# function zfget_match {
+
+emulate -L zsh
+
+# the zfcd hack:  this may not be necessary here
+if [[ $1 == $HOME || $1 == $HOME/* ]]; then
+  1="~${1#$HOME}"
+fi
+
+local tmpf=${TMPPREFIX}zfgm$$
+
+if [[ $ZFTP_SYSTEM == UNIX* && $1 == */* ]]; then
+  # On the first argument to ls, we usually get away with a glob.
+  zftp ls "$1*$2" >$tmpf
+  reply=($(<$tmpf))
+  rm -f $tmpf
+else
+  if (( $#zftp_fcache == 0 )); then
+    # Always cache the current directory and use it
+    # even if the system is UNIX.
+    zftp ls >$tmpf
+    zftp_fcache=($(<$tmpf))
+    rm -f $tmpf
+  fi
+  reply=($zftp_fcache);
+fi
+# }

Functions/Zftp/zfhere

@@ -0,0 +1,5 @@
+# function zfhere {
+# Change to the directory corresponding to $PWD on the server.
+# See zfcd for how this works.
+zfcd $PWD
+# }

Functions/Zftp/zfinit

@@ -0,0 +1,28 @@
+[[ $1 = -n ]] || 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: this is unnecessary with
+# widget-based completion and can be commented out.
+setopt completealiases
+
+#
+# zftp completions: only use these if new-style completion is not
+# active.
+#
+if [[ ${#patcomps} -eq 0 || ${patcomps[(i)zf*]} -gt ${#patcomps} ]]; then
+  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 zfanon zfopen zfparams
+fi

Functions/Zftp/zfls

@@ -0,0 +1,13 @@
+# function zfls {
+
+emulate -L zsh
+
+# directory hack, see zfcd
+if [[ $1 = $HOME || $1 = $HOME/* ]]; then
+  1="~${1#$HOME}"
+fi
+
+zfautocheck -d
+
+zftp ls $*
+# }

Functions/Zftp/zfopen

@@ -0,0 +1,42 @@
+# 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.
+
+emulate -L zsh
+
+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
+# }

Functions/Zftp/zfparams

@@ -0,0 +1,12 @@
+# function zfparams {
+
+emulate -L zsh
+
+# 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 $*
+# }

Functions/Zftp/zfpcp

@@ -0,0 +1,47 @@
+# function zfpcp {
+# ZFTP put as copy:  i.e. first arguments are remote, last is local.
+# Currently only supports
+#  zfcp lfile rfile
+# if there are two arguments, or the second one is . or .., or ends
+# with a slash
+# or
+#  zfcp lfile1 lfile2 lfile3 ... rdir
+# if there are more than two (because otherwise it doesn't
+# know if the last argument is a directory on the remote machine).
+# However, if the remote machine plays ball by telling us `Is a directory'
+# when we try to copy to a directory, zfpcp will then try to do the correct
+# thing.
+
+emulate -L zsh
+
+local rem loc
+integer stat do_close
+
+zfautocheck
+
+if [[ $# -gt 2 || $2 = (.|..) || $2 = */ ]]; then
+  local dir=$argv[-1]
+  argv[-1]=
+  # zfcd directory hack to put the front back to ~
+  if [[ $dir = $HOME || $dir = $HOME/* ]]; then
+    dir="~${dir#$HOME}"
+  fi
+  [[ -n $dir && $dir != */ ]] || dir="$dir/"
+  for loc in $*; do
+    rem=$dir${loc:t}
+    zftp put $rem <$loc || stat=1
+  done
+else
+  zftp put $2 <$1
+  stat=$?
+  if [[ stat -ne 0 && $ZFTP_CODE = 553 && $ZFTP_REPLY = *'Is a directory'* ]]
+  then
+       zftp put $2/$1:t <$1
+       stat=$?
+  fi
+fi
+
+(( $do_close )) && zfclose
+
+return $stat
+# }

Functions/Zftp/zfput

@@ -0,0 +1,23 @@
+# function zfput {
+# Simple put:  dump every file under the same name, but stripping
+# off any directory parts to get the remote filename (i.e. always
+# goes into current remote directory).  Use zfpcp to specify new
+# file name or new directory at remote end.
+
+emulate -L zsh
+
+local loc rem
+integer stat do_close
+
+zfautocheck
+
+for loc in $*; do
+  rem=${loc:t}
+  zftp put $rem <$loc
+  [[ $? == 0 ]] || stat=$?
+done
+
+(( $do_close )) && zfclose
+
+return $stat
+# }

Functions/Zftp/zfrglob

@@ -0,0 +1,70 @@
+# 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.
+
+emulate -L zsh
+setopt extendedglob
+
+local pat dir nondir files i
+
+eval pat=\$$1
+
+# Check if we really need to do anything.  Look for standard
+# globbing characters, and if we are
+# using zsh for the actual pattern matching also look for
+# extendedglob characters.
+if [[ $pat != *[][*?]* &&
+  ( -n $zfrglob || $pat != *[(|)#^]* ) ]]; then
+  return 0
+fi
+local tmpf=${TMPPREFIX}zfrglob$$
+
+if [[ $zfrglob != '' ]]; then
+  zftp ls "$pat" >$tmpf 2>/dev/null
+  eval "$1=(\$(<\$tmpf))"
+  rm -f $tmpf
+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##*/}
+    zftp ls "$dir" 2>/dev/null >$tmpf
+    files=($(<$tmpf))
+    files=(${files:t})
+    rm -f $tmpf
+  else
+    # we just have to do an ls and hope that's right
+    nondir=$pat
+    if (( $#zftp_fcache == 0 )); then
+      # Why does `zftp_fcache=($(zftp ls))' sometimes not work?
+      zftp ls >$tmpf
+      zftp_fcache=($(<$tmpf))
+      rm -f $tmpf
+    fi
+    files=($zftp_fcache)
+  fi
+  # now we want to see which of the $files match $nondir:
+  # ${...:/foo} deletes occurrences of foo matching a complete word,
+  # while the ^ inverts the sense so that anything not matching the
+  # pattern in $nondir is excluded.
+  eval "$1=(\${files:/^\${~nondir}})"
+fi
+# }

Functions/Zftp/zfrtime

@@ -0,0 +1,45 @@
+# 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.
+
+emulate -L zsh
+
+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
+
+# }

Functions/Zftp/zfstat

@@ -0,0 +1,89 @@
+# function zfstat {
+# Give a zftp status report using local variables.
+# With option -v, connect to 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
+
+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."
+  [[ -n $zflastsession ]] && print "Last session:\t$zflastsession"
+  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 "Timeout:\t$ZFTP_TMOUT"
+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
+  zfautocheck -d
+  print "Status of remote server:"
+  # make sure we print the reply
+  local ZFTP_VERBOSE=045
+  zftp quote STAT
+fi
+
+return $stat
+# }

Functions/Zftp/zftp_chpwd

@@ -0,0 +1,39 @@
+# function zftp_chpwd {
+# You may want to alter chpwd to call this when $ZFTP_USER is set.
+
+# 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
+zfotherargs=
+
+if [[ -z $ZFTP_USER ]]; then
+  # last call, after an FTP logout
+
+  # delete the non-current cached directory
+  [[ -n $zfotherdir && -f $zfotherdir ]] && rm -f $zfotherdir
+
+  # don't keep zflastdir between opens (do keep zflastsession)
+  zflastdir=
+
+  # return the display to standard
+  # uncomment the following line if you have a chpwd which shows directories
+  # chpwd
+else
+  [[ -n $ZFTP_PWD ]] && zflastdir=$ZFTP_PWD
+  zflastsession="$ZFTP_HOST:$ZFTP_PWD"
+  local args
+  if [[ -t 1 && -t 2 ]]; then
+    local str=$zflastsession
+    [[ ${#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
+# }

Functions/Zftp/zftp_progress

@@ -0,0 +1,18 @@
+# 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
+# }

Functions/Zftp/zftype

@@ -0,0 +1,30 @@
+# function zftype {
+local type zftmp=${TMPPREFIX}zftype$$
+
+zfautocheck -d
+
+if (( $# == 0 )); then
+  zftp type >$zftmp
+  type=$(<$zftmp)
+  rm -f $zftmp
+  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 == (#i)a(sc(ii|)|) ]]; then
+    type=A
+  elif [[ $1 == (#i)i(m(age|)|) || $1 == (#i)b(in(ary|)|) ]]; then
+    type=I
+  else
+    print "Type not recognised:  $1" 2>&1
+    return 1
+  fi
+  zftp type $type
+fi
+# }

Functions/Zftp/zfuget

@@ -0,0 +1,147 @@
+# 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.
+
+emulate -L zsh
+
+local loc rem locstats remstats doit tmpfile=${TMPPREFIX}zfuget$$
+local rstat remlist verbose optlist opt bad i silent nglob time
+integer stat do_close
+
+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
+
+zfautocheck
+
+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
+
+(( do_close )) && zfclose
+
+return $stat
+# }

Functions/Zftp/zfuput

@@ -0,0 +1,115 @@
+# 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.
+
+emulate -L zsh
+
+local loc rem locstats remstats doit tmpfile=${TMPPREFIX}zfuput$$
+local rstat verbose optlist opt bad i silent
+integer stat do_close
+
+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
+
+zfautocheck
+
+if [[ $ZFTP_VERBOSE = *5* ]]; then
+  # should we turn it off locally?
+  print "Messages with code 550 are harmless." >&2
+fi
+
+for rem in $*; do
+  loc=${rem: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
+
+(( do_close )) && zfclose
+
+return $stat
+# }

Misc/globtests

@@ -75,6 +75,7 @@ f mad.moo.cow   (*~*.*).(*~*.*)
 t moo.cow       (^*.*).(^*.*)
 f sane.moo.cow  (^*.*).(^*.*)
 f mucca.pazza   mu(^c#)?.pa(^z#)?
+f _foo~         _(|*[^~])
 t fff           ((^f))
 t fff           ((^f)#)
 t fff           ((^f)##)

Misc/globtests.ksh

@@ -68,6 +68,7 @@ t foobar        !(foo)*
 t moo.cow       !(*.*).!(*.*)
 f mad.moo.cow   !(*.*).!(*.*)
 f mucca.pazza   mu!(*(c))?.pa!(*(z))?
+f _foo~         _?(*[^~])
 t fff           !(f)
 t fff           *(!(f))
 t fff           +(!(f))

Src/Zle/zle_main.c

@@ -579,12 +579,7 @@ execzlefunc(Thingy func)
 
 	if(!(wflags & ZLE_KEEPSUFFIX))
 	    removesuffix();
-	if(!(wflags & ZLE_MENUCMP) ||
+	if(!(wflags & ZLE_MENUCMP)) {
-	   ((wflags & WIDGET_NCOMP) && compwidget != w)) {
-	    /* If we are doing a special completion, and the widget
-	     * is not the one currently in use for special completion,
-	     * we are starting a new completion.
-	     */
 	    fixsuffix();
 	    invalidatelist();
 	}

Src/Zle/zle_refresh.c

@@ -327,7 +327,7 @@ zrefresh(void)
             vcs = 0;
         else if (!clearflag && lpromptbuf[0]) {
             zputs(lpromptbuf, shout);
-	    if (lpromptw == 0)
+	    if (lpromptw == 0 && lprompth == 1)
 		zputs("\n", shout);	/* works with both hasam and !hasam */
 	}
 	if (clearflag) {
@@ -947,7 +947,7 @@ tc_rightcurs(int cl)
 		zputc('\r', shout);
 	    tc_upcurs(lprompth - 1);
 	    zputs(lpromptbuf, shout);
-	    if (lpromptw == 0)
+	    if (lpromptw == 0 && lprompth == 1)
 		zputs("\n", shout);	/* works with both hasam and !hasam */
 	}
 	i = lpromptw;

Src/Zle/zle_tricky.c

@@ -72,6 +72,10 @@ static int wb, we;
 
 static int offs;
 
+/* the last completion widget called */
+
+static Widget lastcompwidget;
+
 /* These control the type of completion that will be done.  They are      *
  * affected by the choice of ZLE command and by relevant shell options.   *
  * usemenu is set to 2 if we have to start automenu and 3 if we have to   *
@@ -756,10 +760,12 @@ docomplete(int lst)
 
     /* If we are doing a menu-completion... */
 
-    if (menucmp && lst != COMP_LIST_EXPAND) {
+    if (menucmp && lst != COMP_LIST_EXPAND && compwidget &&
+	compwidget == lastcompwidget) {
 	do_menucmp(lst);
 	return;
     }
+    lastcompwidget = compwidget;
 
     /* We may have to reset the cursor to its position after the   *
      * string inserted by the last completion. */
@@ -6970,10 +6976,20 @@ do_single(Cmatch m)
 		t = 1;
 	    else {
 		/* Build the path name. */
-		p = (char *) zhalloc(strlen(prpre) + strlen(str) +
+		if (m->ripre && !*psuf) {
-				 strlen(psuf) + 3);
+		    int ne = noerrs;
-		sprintf(p, "%s%s%s", (prpre && *prpre) ? prpre : "./", str, psuf);
 
+		    p = (char *) zhalloc(strlen(m->ripre) + strlen(str) + 1);
+		    sprintf(p, "%s%s", m->ripre, str);
+		    noerrs = 1;
+		    parsestr(p);
+		    singsub(&p);
+		    noerrs = ne;
+		} else {
+		    p = (char *) zhalloc(strlen(prpre) + strlen(str) +
+				 strlen(psuf) + 3);
+		    sprintf(p, "%s%s%s", (prpre && *prpre) ? prpre : "./", str, psuf);
+		}
 		/* And do the stat. */
 		t = (!(sr = ztat(p, &buf, 0)) && S_ISDIR(buf.st_mode));
 	    }

Src/glob.c

@@ -625,6 +625,36 @@ getglobflags(void)
     return 0;
 }
 
+/**/
+static void
+parse_charset(void)
+{
+    /* Character set: brackets had better match */
+    if (pptr[1] == Outbrack)
+	*++pptr = ']';
+    else if ((pptr[1] == Hat || pptr[1] == '^' || pptr[1] == '!') &&
+	     pptr[2] == Outbrack)
+	*(pptr += 2) = ']';
+    while (*++pptr && *pptr != Outbrack) {
+	if (itok(*pptr)) {
+	    /* POSIX classes: make sure it's a real one,
+	     * leave the Inbrack tokenised if so.
+	     * We need to untokenize the Outbrack since otherwise
+	     * it might look like we got to the end of the range without
+	     * matching; we also need to accept ']' instead of
+	     * Outbrack in case this has already happened.
+	     */
+	    char *nptr;
+	    if (*pptr == Inbrack && pptr[1] == ':'
+		&& (nptr = strchr(pptr+2, ':')) && 
+		(*++nptr == Outbrack || *nptr == ']'))
+		*(pptr = nptr) = ']';
+	    else
+		*pptr = ztokens[*pptr - Pound];
+	}
+    }
+}
+
 /* enum used with ksh-like patterns, @(...) etc. */
 
 enum { KF_NONE, KF_AT, KF_QUEST, KF_STAR, KF_PLUS, KF_NOT };
@@ -853,24 +883,7 @@ parsecomp(int gflag)
 	    if (*pptr != Outang)
 		return NULL;
 	} else if (*pptr == Inbrack) {
-	    /* Character set: brackets had better match */
+	    parse_charset();
-	    if (pptr[1] == Outbrack)
-		*++pptr = ']';
-	    else if ((pptr[1] == Hat || pptr[1] == '^' || pptr[1] == '!') &&
-		     pptr[2] == Outbrack)
-		*(pptr += 2) = ']';
-	    while (*++pptr && *pptr != Outbrack) {
-		if (itok(*pptr)) {
-		    /* POSIX classes: make sure it's a real one, *
-		     * leave the Inbrack tokenised if so.        */
-		    char *nptr;
-		    if (*pptr == Inbrack && pptr[1] == ':'
-			&& (nptr = strchr(pptr+2, ':')) && 
-			*++nptr == Outbrack)
-			pptr = nptr;
-		    *pptr = ztokens[*pptr - Pound];
-		}
-	    }
 	    if (*pptr != Outbrack)
 		return NULL;
 	} else if (itok(*pptr) && *pptr != Star && *pptr != Quest)
@@ -912,7 +925,20 @@ parsecompsw(int gflag)
 		break;
 	    else if (*sptr == Bar && !pct)
 		break;
-	    else if (*sptr == Tilde && !pct) {
+	    else if (*sptr == Inbrack) {
+		/*
+		 * Character classes can have tokenized characters in,
+		 * so we have to parse them properly.
+		 */
+		char *bstart = pptr;
+
+		pptr = sptr;
+		parse_charset();
+		sptr = pptr;
+		pptr = bstart;
+		if (*sptr != Outbrack)
+		    break;
+	    } else if (*sptr == Tilde && !pct) {
 		tail = NULL;
 		break;
 	    }

Src/init.c

@@ -559,6 +559,7 @@ setupvals(void)
     module_path = mkarray(ztrdup(MODULE_DIR));
     modules = newlinklist();
 #endif
+    bltinmodules = newlinklist();
 
     /* Set default prompts */
     if(unset(INTERACTIVE)) {

Src/mkbltnmlst.sh

@@ -61,6 +61,6 @@ for bin_mod in $bin_mods; do
 		exit 1 ;;
 	esac
     done
-    echo "    mod.nam = \"$bin_mod\"; setup_$bin_mod(&mod); boot_$bin_mod(&mod);"
+    echo "    register_module(mod.nam = \"$bin_mod\"); setup_$bin_mod(&mod); boot_$bin_mod(&mod);"
     done_mods="$done_mods$bin_mod "
 done

Src/module.c

@@ -30,6 +30,12 @@
 #include "zsh.mdh"
 #include "module.pro"
 
+/* List of builtin modules. */
+
+/**/
+LinkList bltinmodules;
+
+
 /* The `zsh' module contains all the base code that can't actually be built *
  * as a separate module.  It is initialised by main(), so there's nothing   *
  * for the boot function to do.                                             */
@@ -48,6 +54,17 @@ boot_zsh(Module m)
     return 0;
 }
 
+/* This registers a builtin module.                                   */
+
+/**/
+void
+register_module(char *n)
+{
+    PERMALLOC {
+	addlinknode(bltinmodules, n);
+    } LASTALLOC;
+}
+
 /* addbuiltin() can be used to add a new builtin.  It returns zero on *
  * success, 1 on failure.  The only possible type of failure is that  *
  * a builtin with the specified name already exists.  An autoloaded   *
@@ -573,29 +590,34 @@ load_module(char const *name)
  * about trying to load a module with a full path name in restricted mode.
  * The last argument should be non-zero if this function should signal an
  * error if the module is already loaded.
- * The return value is the module of NULL if the module couldn't be loaded. */
+ * The return value is non-zero if the module was found or loaded. */
 
 /**/
-Module
+int
 require_module(char *nam, char *module, int res, int test)
 {
     Module m = NULL;
     LinkNode node;
 
+    /* First see if the module is linked in. */
+    for (node = firstnode(bltinmodules); node; incnode(node)) {
+	if (!strcmp((char *) getdata(node), nam))
+	    return 1;
+    }
     node = find_module(module);
     if (node && (m = ((Module) getdata(node)))->handle &&
 	!(m->flags & MOD_UNLOAD)) {
 	if (test) {
 	    zwarnnam(nam, "module %s already loaded.", module, 0);
-	    return NULL;
+	    return 0;
 	}
     } else if (res && isset(RESTRICTED) && strchr(module, '/')) {
 	zwarnnam(nam, "%s: restricted", module, 0);
-	return NULL;
+	return 0;
     } else
-	return load_module(module);
+	return !!load_module(module);
 
-    return m;
+    return 1;
 }
 
 /**/

patchlist.txt

@@ -933,3 +933,37 @@ Sven: 6026: _path_files slight rewrite for speed
 pws: 6030: compsys.yo
 
 Sven: 6031: defcomp -> compdef
+
+  pws-16
+
+pws: 6053: compwid.yo
+
+Sven: 6056: compwid.yo
+
+Sven: 6058: small changes
+
+Sven: 6060: don't invalidatelist() in zle_main.c before calling completion
+functions
+
+Sven: 6062: test whether using the same widget when doing menucompletion
+
+Sven: 6066: create list of modules built into the base executable
+
+pws: 6070: ~ in character class in parentheses with extendedglob failed
+
+pws: 6074: zftp function suite moved to Functions/Zftp and provided with
+documentation.
+
+Sven: 6077: do_single() fix for old completion
+
+Tanaka Akira: 6078: _find syntax error
+
+Sven: 6079: compwid.yo typo
+
+pws: zsh-announce/94: FAQ and FAQ.yo updated
+
+Tanaka Akira: 6085: _make can hang when no [mM]akefile
+
+Tanaka Akira: 6092: _find, bad glob pattern
+
+pws: 6101: multi-line prompt ending in '\n' got another newline