13 files changed, 218 insertions, 169 deletions

diff --git a/Doc/Makefile.in b/Doc/Makefile.in
index f7dbf3866..c0ae8d80d 100644
--- a/Doc/Makefile.in
+++ b/Doc/Makefile.in
@@ -174,7 +174,7 @@ install.man: $(MAN)
 # install info pages, creating install directory if necessary
 install.info: zsh.info
 	$(sdir_top)/mkinstalldirs $(infodir)
-	for file in zsh.info zsh.info-[1-9]; do \
+	for file in zsh.info zsh.info-[1-9]*; do \
 	  if test -f $$file; then \
 	    $(INSTALL_DATA) $$file $(infodir); \
 	  elif test -f $(sdir)/$$file; then \
@@ -198,7 +198,7 @@ uninstall.man:
 
 # uninstall info pages
 uninstall.info:
-	rm -f $(infodir)/zsh.info $(infodir)/zsh.info-[1-9]
+	rm -f $(infodir)/zsh.info $(infodir)/zsh.info-[1-9]*
 
 # ========== DEPENDENCIES FOR CLEANUP ==========
 
diff --git a/Doc/Zsh/.distfiles b/Doc/Zsh/.distfiles
index f3e7352a5..3fbde5ef1 100644
--- a/Doc/Zsh/.distfiles
+++ b/Doc/Zsh/.distfiles
@@ -1,10 +1,12 @@
 DISTFILES_SRC='
     .distfiles
-    arith.yo builtins.yo compat.yo compctl.yo compwid.yo cond.yo exec.yo
-    expn.yo filelist.yo files.yo func.yo grammar.yo guide.yo index.yo intro.yo
-    invoke.yo jobs.yo metafaq.yo mod_cap.yo mod_clone.yo mod_comp1.yo
+    arith.yo builtins.yo compat.yo compctl.yo compsys.yo compwid.yo
+    cond.yo exec.yo expn.yo filelist.yo files.yo func.yo grammar.yo
+    guide.yo index.yo intro.yo invoke.yo jobs.yo metafaq.yo
+    mod_cap.yo mod_clone.yo mod_comp1.yo
     mod_compctl.yo mod_deltochar.yo mod_example.yo mod_files.yo
-    mod_mapfile.yo mod_sched.yo mod_stat.yo mod_zftp.yo mod_zle.yo
+    mod_mapfile.yo mod_parameter.yo mod_sched.yo mod_stat.yo
+    mod_zftp.yo mod_zle.yo
     modules.yo options.yo params.yo 
-    prompt.yo redirect.yo restricted.yo seealso.yo zle.yo
+    prompt.yo redirect.yo restricted.yo seealso.yo zftpsys.yo zle.yo
 '
diff --git a/Doc/Zsh/builtins.yo b/Doc/Zsh/builtins.yo
index 7cbdb1114..157b3420d 100644
--- a/Doc/Zsh/builtins.yo
+++ b/Doc/Zsh/builtins.yo
@@ -315,9 +315,9 @@ With the tt(-D) flag, tt(fc) prints elapsed times.
 
 cindex(history, file)
 cindex(file, history)
-tt(fc -R) reads the history from the given file,
-tt(fc -W) writes the history out to the given file,
-and tt(fc -A) appends the history out to the given file.
+`tt(fc -R)' reads the history from the given file,
+`tt(fc -W)' writes the history out to the given file,
+and `tt(fc -A)' appends the history out to the given file.
 If no filename is specified, the tt($HISTFILE) is assumed.
 If the tt(-I) option is added to tt(-R), only those events that are
 not already contained within the internal history list are added.
diff --git a/Doc/Zsh/compat.yo b/Doc/Zsh/compat.yo
index 26f8fe896..43fa40390 100644
--- a/Doc/Zsh/compat.yo
+++ b/Doc/Zsh/compat.yo
@@ -7,19 +7,15 @@ cindex(compatibility)
 cindex(sh, compatibility)
 cindex(ksh, compatibility)
 Zsh tries to emulate bf(sh) or bf(ksh) when it is invoked as
-tt(sh) or tt(ksh) respectively.  More precisely, it looks at the first
-letter of the name passed to it, which may not necessarily be the
-name of the executable file, ignoring any initial `tt(-)' as well as
-`tt(r)' (for restricted); an `tt(s)' or `tt(b)' will force
-bf(sh) compatibility, while `tt(k)' will force bf(ksh) compatibility.  An
-exception is if the name excluding any `tt(-)' is tt(su), in which case
-the environment variable tt(SHELL) will be used to test the emulation;
-this is to workaround a problem under some operating systems where the
-tt(su) command does not change the name when executing a user shell.  Note
-that, from within zsh itself, this mechanism can be invoked by `tt(ARGV0=sh
-zsh ...)'.
+tt(sh) or tt(ksh) respectively; more precisely, it looks at the first
+letter of the name by which it was invoked, excluding any initial `tt(r)'
+(assumed to stand for `restricted'), and if that is `tt(s)' or `tt(k)' it
+will emulate bf(sh) or bf(ksh).  Furthermore, if invoked as tt(su) (which
+happens on certain systems when the shell is executed by the tt(su)
+command), the shell will try to find an alternative name from the tt(SHELL)
+environment variable and perform emulation based on that.
 
-In this emulation mode, the following
+In bf(sh) and bf(ksh) compatibility modes the following
 parameters are not special and not initialized by the shell:
 tt(ARGC),
 tt(argv),
diff --git a/Doc/Zsh/compctl.yo b/Doc/Zsh/compctl.yo
index 7b672dd68..4fecce92f 100644
--- a/Doc/Zsh/compctl.yo
+++ b/Doc/Zsh/compctl.yo
@@ -128,7 +128,7 @@ list([ tt(-K) var(function) ] [ tt(-i) var(function) ])
 list([ tt(-Q) ] [ tt(-P) var(prefix) ] [ tt(-S) var(suffix) ])
 list([ tt(-W) var(file-prefix) ] [ tt(-H) var(num pattern) ])
 list([ tt(-q) ] [ tt(-X) var(explanation) ] [ tt(-Y) var(explanation) ])
-list([ tt(-y) var(func-or-var) ] [ tt(-l) var(cmd) ] [ tt(-U) ])
+list([ tt(-y) var(func-or-var) ] [ tt(-l) var(cmd) ] [ tt(-h) var(cmd) ] [ tt(-U) ])
 list([ tt(-t) var(continue) ] [ tt(-J) var(name) ] [ tt(-V) var(name) ])
 list([ tt(-M) var(match-spec) ])
 endlist()
@@ -401,6 +401,15 @@ completes arguments between `tt(-exec)' and the following `tt(;)' (or the end
 of the command line if there is no such string) as if they were
 a separate command line.
 )
+item(tt(-h) var(cmd))(
+Normally zsh completes quoted strings as a whole. With this option,
+completion can be done separately on different parts of such
+strings. It works like the tt(-l) option but makes the completion code 
+work on the parts of the current word that are separated by
+spaces. These parts are completed as if they were arguments to the
+given var(cmd). If var(cmd) is the empty string, the first part is
+completed as a command name, as with tt(-l).
+)
 item(tt(-U))(
 Use the whole list of possible completions, whether or not they
 actually match the word on the command line.  The word typed so far
@@ -631,6 +640,12 @@ omitted, it matches if the cursor is after a word with prefix var(str1).
 item(tt(R[)var(str1)tt(,)var(str2)tt(])...)(
 Like tt(r) but using pattern matching instead.
 )
+item(tt(q[)var(str)tt(])...)(
+Matches the word currently being completed is in single quotes and the 
+var(str) begins with the letter `s', or if completion is done in
+double quotes and var(str) starts with the letter `d', or if
+completion is done in backticks and var(str) starts with a `b'.
+)
 enditem()
 
 texinode(Matching Control)(Example)(Extended Completion)(Programmable Completion)
diff --git a/Doc/Zsh/compsys.yo b/Doc/Zsh/compsys.yo
index 90f6b2910..94533415e 100644
--- a/Doc/Zsh/compsys.yo
+++ b/Doc/Zsh/compsys.yo
@@ -89,9 +89,11 @@ To speed up the running of tt(compinit), it can be made to produce a dumped
 configuration which will be read in on future invocations.  The easiest way
 to do this is by adding the option tt(-d) whenever tt(compinit) is sourced.
 In this case the dumped file will have the same name as the sourced file,
-but with tt(.dump) appended to the end; alternatively, an explicit file
-name can be given following the tt(-d).  On the next call to tt(compinit
--d), the dumped file will be read instead.
+but with tt(.dump) appended to the end, or, if that is not writeable by the
+user, the file tt(.zcompdump) in the same directory as the startup files
+(i.e. tt($ZDOTDIR) or tt($HOME)); alternatively, an explicit file name can
+be given following the tt(-d).  On the next call to tt(compinit -d), the
+dumped file will be read instead.
 
 The other option accepted by tt(compinit) is tt(-f var(dir)), which gives
 the directory in which tt(compinit) resides.  If you source tt(compinit) by
@@ -331,6 +333,11 @@ Default implementations are supplied for each of these
 contexts, in most cases named after the context itself
 (e.g. completion for the `tt(-tilde-)' context is done by the function 
 named `tt(_tilde)').
+
+Before trying to find a function for a specific context, tt(_complete) 
+checks if the parameter `tt(compcontext)' is set to a non-empty
+value. If it is, the value is taken as the name of the context to use
+and the function defined for that context will be called.
 )
 item(tt(_approximate))(
 This completer function uses the tt(_complete) completer to generate
@@ -615,13 +622,6 @@ list of completions.
 )
 enditem()
 )
-item(tt(_closequotes))(
-When a completion starts in quotes, this completer will recognise the fact
-and insert a matching closing quote if there is not already one later on
-the line.  It should come earlier in the list of completers than any of the
-completers which generate matches.  It can be confused by some of the more
-sophisticated forms of completion.
-)
 enditem()
 
 texinode(Completion Functions)()(Control Functions)(Completion System)
diff --git a/Doc/Zsh/compwid.yo b/Doc/Zsh/compwid.yo
index d74054a9c..d30adc0f1 100644
--- a/Doc/Zsh/compwid.yo
+++ b/Doc/Zsh/compwid.yo
@@ -81,6 +81,13 @@ 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(QIPREFIX))(
+This parameter is read-only and contains the quoted string up to the
+word being completed. E.g. when completing `tt("foo)', this parameter
+contains the double quote. If the tt(-q) option of tt(compset) is used 
+(see below), and the original string was `tt("foo bar)' with the
+cursor on the `tt(bar)', this parameter contains `tt("foo )'.
+)
 item(tt(SUFFIX))(
 Initially this will be set to the part of the current word from the
 cursor position to the end; it may be altered to give a common suffix for
@@ -93,6 +100,9 @@ As tt(IPREFIX), but for a suffix that should not be considered part
 of the matches; note that the tt(ISUFFIX) string follows the tt(SUFFIX)
 string.
 )
+item(tt(QISUFFIX))(
+Like tt(QIPREFIX), but containing the suffix.
+)
 item(tt(compstate))(
 This is an associative array with various keys and values that the
 completion code uses to exchange information with the completion widget.
@@ -544,7 +554,8 @@ 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 -N) var(beg-pat) [ var(end-pat) ])(
+xitem(tt(compset -N) var(beg-pat) [ var(end-pat) ])
+item(tt(compset -q))(
 This command simplifies modification of the special parameters,
 while its return value allows tests on them to be carried out.
 
@@ -607,6 +618,13 @@ 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 performed as if it were not given.
 )
+item(tt(-q))(
+If the cursor is currently inside single or double quotes, the word
+currenly being completed is split in separate words at the spaces. The 
+resulting words are stored in the tt(words) array, and tt(PREFIX),
+tt(SUFFIX), tt(QIPREFIX), and tt(QISUFFIX) are modified to reflect the 
+word part that is completed.
+)
 enditem()
 
 In all the above cases the return value is zero if the test succeded
diff --git a/Doc/Zsh/expn.yo b/Doc/Zsh/expn.yo
index 5853d792f..7fdf973b4 100644
--- a/Doc/Zsh/expn.yo
+++ b/Doc/Zsh/expn.yo
@@ -332,9 +332,9 @@ a letter, digit, or underscore that is not to be interpreted
 as part of var(name).  In addition, more complicated forms of substitution
 usually require the braces to be present; exceptions, which only apply if
 the option tt(KSH_ARRAYS) is not set, are a single subscript or any colon
-modifiers appearing after the name, or any of the characters tt(^), tt(=),
-tt(~), tt(#) or tt(+) appearing before the name, all of which work with or
-without braces.
+modifiers appearing after the name, or any of the characters `tt(^)',
+`tt(=)', `tt(~)', `tt(#)' or `tt(+)' appearing before the name, all of
+which work with or without braces.
 
 If var(name) is an array parameter, then the value of each
 element of var(name) is substituted, one element per word.
@@ -375,8 +375,8 @@ containing a colon, then the shell only checks whether
 var(name) is set, not whether its value is null.
 
 In the following expressions, when var(name) is an array and
-the substitution is not quoted, or if the tt((@)) flag or the
-`var(name)tt([@])' syntax is used, matching and replacement is
+the substitution is not quoted, or if the `tt((@))' flag or the
+var(name)tt([@]) syntax is used, matching and replacement is
 performed on each array element separately.
 
 startitem()
@@ -404,7 +404,7 @@ item(tt(${)var(name)tt(:#)var(pattern)tt(}))(
 If the var(pattern) matches the value of var(name), then substitute
 the empty string; otherwise, just substitute the value of var(name).
 If var(name) is an array
-the matching array elements are removed (use the tt((M)) flag to
+the matching array elements are removed (use the `tt((M))' flag to
 remove the non-matched elements).
 )
 xitem(tt(${)var(name)tt(/)var(pattern)tt(/)var(repl)tt(}))
@@ -412,15 +412,15 @@ item(tt(${)var(name)tt(//)var(pattern)tt(/)var(repl)tt(}))(
 Replace by string var(repl), the longest possible match of
 var(pattern) in the expansion of parameter var(name).  The first form
 replaces just the first occurrence, the second form all occurrences.
-The var(pattern) may begin with a var(#), in which case the
-var(pattern) must match at the start of the string, or var(%), in
+The var(pattern) may begin with a `tt(#)', in which case the
+var(pattern) must match at the start of the string, or `tt(%)', in
 which case it must match at the end of the string.  The var(repl) may
-be an empty string, in which case the final tt(/) may also be omitted.
-To quote the final tt(/) in other cases it should be preceded by two
+be an empty string, in which case the final `tt(/)' may also be omitted.
+To quote the final `tt(/)' in other cases it should be preceded by two
 backslashes (i.e., a quoted backslash); this is not necessary if the
-tt(/) occurs inside a substituted parameter.
+`tt(/)' occurs inside a substituted parameter.
 
-The first tt(/) may be preceded by a tt(:), in which case the match
+The first `tt(/)' may be preceded by a `tt(:)', in which case the match
 will only succeed if it matches the entire word.  Note also the
 effect of the tt(I) and tt(S) parameter expansion flags below; however,
 the flags tt(M), tt(R), tt(B), tt(E) and tt(N) are not useful.
@@ -431,7 +431,7 @@ nofill(tt(foo="twinkle twinkle little star" sub="t*e" rep="spy")
 tt(print ${foo//${~sub}/$rep})
 tt(print ${(S)foo//${~sub}/$rep}))
 
-Here, the tt(~) ensures that the text of tt($sub) is treated as a
+Here, the `tt(~)' ensures that the text of tt($sub) is treated as a
 pattern rather than a plain string.  In the first case, the longest
 match for tt(t*e) is substituted and the result is `tt(spy star)',
 while in the second case, the shortest matches are taken and the
@@ -442,8 +442,8 @@ If var(spec) is one of the above substitutions, substitute
 the length in characters of the result instead of
 the result itself.  If var(spec) is an array expression,
 substitute the number of elements of the result.
-Note that tt(^), tt(=), and tt(~), below, must appear
-to the left of tt(#) when these forms are combined.
+Note that `tt(^)', `tt(=)', and `tt(~)', below, must appear
+to the left of `tt(#)' when these forms are combined.
 )
 item(tt(${^)var(spec)tt(}))(
 pindex(RC_EXPAND_PARAM, use of)
@@ -452,7 +452,7 @@ cindex(rc, array expansion style)
 Turn on the tt(RC_EXPAND_PARAM) option for the
 evaluation of var(spec); if the `tt(^)' is doubled, turn it off.
 When this option is set, array expansions of the form
-`var(foo)tt(${)var(xx)tt(})var(bar)',
+var(foo)tt(${)var(xx)tt(})var(bar),
 where the parameter var(xx)
 is set to tt(LPAR())var(a b c)tt(RPAR()), are substituted with
 `var(fooabar foobbar foocbar)' instead of the default
@@ -498,10 +498,19 @@ tt($LPAR())...tt(RPAR()) type command substitution is used in place of
 var(name) above, it is expanded first and the result is used as if
 it were the value of var(name).  Thus it is
 possible to perform nested operations:  tt(${${foo#head}%tail})
-substitutes the value of tt($foo) with both tt(head) and tt(tail)
+substitutes the value of tt($foo) with both `tt(head)' and `tt(tail)'
 deleted.  The form with tt($LPAR())...tt(RPAR()) is often useful in
 combination with the flags described next; see the examples below.
 
+Note that double quotes may appear around nested substitutions, in which
+case only the part inside is treated as quoted; for example,
+tt(${(f)"$(foo)"}) quotes the result of tt($(foo)), but the flag `tt((f))'
+(see below) is applied using the rules for unquoted substitutions.  Note
+further that quotes are themselves nested in this context; for example, in
+tt("${(@f)"$(foo)"}"), there are two sets of quotes, one surrounding the
+whole expression, the other (redundant) surrounding the tt($(foo)) as
+before.
+
 subsect(Parameter Expansion Flags)
 cindex(parameter expansion flags)
 cindex(flags, parameter expansion)
@@ -526,8 +535,8 @@ when creating an associative array.
 )
 item(tt(@))(
 In double quotes, array elements are put into separate words.
-E.g., `tt("${(@)foo}")' is equivalent to `tt("${foo[@]}")' and
-`tt("${(@)foo[1,2]}")' is the same as `tt("$foo[1]" "$foo[2]")'.
+E.g., tt("${(@)foo}") is equivalent to tt("${foo[@]}") and
+tt("${(@)foo[1,2]}") is the same as tt("$foo[1]" "$foo[2]").
 )
 item(tt(e))(
 Perform em(parameter expansion), em(command substitution) and
@@ -541,7 +550,7 @@ type parameter expression or a tt($LPAR())...tt(RPAR()) type command
 substitution in place of the parameter name this flag makes the result
 of the expansion be taken as a parameter name which is then
 used. E.g. if you have `tt(foo=bar)' and `tt(bar=baz)', the strings
-`tt(${(P)foo})' and `tt(${(P)${foo}})' will be expanded to `tt(baz)'.
+tt(${(P)foo}) and tt(${(P)${foo}}) will be expanded to `tt(baz)'.
 )
 item(tt(o))(
 Sort the resulting words in ascending order.
@@ -722,7 +731,7 @@ outermost.  The flags are not propagated up to enclosing
 substitutions; the nested subsitution will return either a scalar or an
 array as determined by the flags, possibly adjusted for quoting.  All the
 following steps take place where applicable at all levels of substitution.
-Note that, unless the tt((P)) flag is present, the flags and any subscripts
+Note that, unless the `tt((P))' flag is present, the flags and any subscripts
 apply directly to the value of the nested substitution; for example, the
 expansion tt(${${foo}}) behaves exactly the same as tt(${foo}).
 )
@@ -749,57 +758,57 @@ arrays are not modified).  If the tt((j)) flag is present, that is used for
 joining instead of tt($IFS).
 )
 item(tt(5.) em(Nested Subscripting))(
-Any remaining subscript (i.e. of a nested substitution) is evaluated at
-this point, based on whether the value is an array or a scalar; if it was
-an array, a second subscript for the character in the word may also appear.
-Note that tt(${foo[2,4][2]}) is thus equivalent to tt(${${foo[2,4]}[2]})
-and also to tt("${${(@)foo[2,4]}[2]}") (the nested substitution returns an
-array in both cases), but not to tt("${${foo[2,4]}[2]}") (the nested
-substitution returns a scalar because of the quotes).
+Any remaining subscripts (i.e. of a nested substitution) are evaluated at
+this point, based on whether the value is an array or a scalar.  As with
+tt(2.), multiple subscripts can appear.  Note that tt(${foo[2,4][2]}) is
+thus equivalent to tt(${${foo[2,4]}[2]}) and also to
+tt("${${(@)foo[2,4]}[2]}") (the nested substitution returns an array in
+both cases), but not to tt("${${foo[2,4]}[2]}") (the nested substitution
+returns a scalar because of the quotes).
 )
 item(tt(6.) em(Modifiers))(
-Any modifiers, as specified by a trailing tt(#), tt(%), tt(/)
+Any modifiers, as specified by a trailing `tt(#)', `tt(%)', `tt(/)'
 (possibly doubled) or by a set of modifiers of the form tt(:...) (see
 noderef(Modifiers) in noderef(History Expansion)), are applied to the words
 of the value at this level.
 )
 item(tt(7.) em(Forced Joining))(
-If the tt((j)) flag is present, or no tt((j)) flag is present but
+If the `tt((j))' flag is present, or no `tt((j))' flag is present but
 the string is to be split as given by rules tt(8.) or tt(9.), and joining
 did not take place at step tt(4.), any words in the value are joined
 together using the given string or the first character of tt($IFS) if none.
-Note that the tt((F)) flag implicitly supplies a string for joining in this
+Note that the `tt((F))' flag implicitly supplies a string for joining in this
 manner.
 )
 item(tt(8.) em(Forced Splitting))(
-If one of the tt((s)) or tt((f)) flags are present, or the tt(=)
+If one of the `tt((s))' or `tt((f))' flags are present, or the `tt(=)'
 specifier was present (e.g. tt(${=)var(var)tt(})), the word is split on
 occurrences of the specified string, or (for tt(=) with neither of the two
 flags present) any of the characters in tt($IFS).
 )
 item(tt(9.) em(Shell Word Splitting))(
-If no tt((s)), tt((f)) or tt(=) was given, but the word is not
+If no `tt((s))', `tt((f))' or `tt(=)' was given, but the word is not
 quoted and the option tt(SH_WORD_SPLIT) is set, the word is split on
 occurrences of any of the characters in tt($IFS).  Note this step, too,
 take place at all levels of a nested substitution.
 )
 item(tt(10.) em(Re-Evaluation))(
-Any tt((e)) flag is applied to the value, forcing it to be re-examined for
-new parameter substitutions, but also for command and arithmetic
+Any `tt((e))' flag is applied to the value, forcing it to be re-examined
+for new parameter substitutions, but also for command and arithmetic
 substitutions.
 )
 item(tt(11.) em(Padding))(
-Any padding of the value by the tt(LPAR()l.)var(fill)tt(.RPAR()) or
-tt(LPAR()r.)var(fill)tt(.RPAR()) flags is applied.
+Any padding of the value by the `tt(LPAR()l.)var(fill)tt(.RPAR())' or
+`tt(LPAR()r.)var(fill)tt(.RPAR())' flags is applied.
 )
 enditem()
 
 subsect(Examples)
 The flag tt(f) is useful to split a double-quoted substitution line by
-line.  For example, `tt("${(f)$LPAR()<)var(file)tt(RPAR()}")'
+line.  For example, tt("${(f)$LPAR()<)var(file)tt(RPAR()}")
 substitutes the contents of var(file) divided so that each line is
 an element of the resulting array.  Compare this with the effect of
-`tt($)tt(LPAR()<)var(file)tt(RPAR())' alone, which divides the file
+tt($)tt(LPAR()<)var(file)tt(RPAR()) alone, which divides the file
 up by words, or the same inside double quotes, which makes the entire
 content of the file a single string.
 
@@ -811,19 +820,19 @@ item(tt("${(@)${foo}[1]}"))(
 This produces the result tt(b).  First, the inner substitution
 tt("${foo}"), which has no array (tt(@)) flag, produces a single word
 result tt("bar baz").  The outer substitution tt("${(@)...[1]}") detects
-that this is a scalar, so that (despite the tt((@)) flag) the subscript
+that this is a scalar, so that (despite the `tt((@))' flag) the subscript
 picks the first character. 
 )
 item(tt("${${(@)foo}[1]}"))(
-The produces the result tt(bar).  In this case, the inner substitution
-tt("${(@)foo}") produces the array tt(LPAR()bar baz)tt(RPAR()).  The outer
+The produces the result `tt(bar)'.  In this case, the inner substitution
+tt("${(@)foo}") produces the array `tt(LPAR()bar baz)tt(RPAR())'.  The outer
 substitution tt("${...[1]}") detects that this is an array and picks the
 first word.  This is similar to the simple case tt("${foo[1]}").
 )
 enditem()
 
 As an example of the rules for word splitting and joining, suppose tt($foo)
-contains the array tt(LPAR()ax1 bx1)tt(RPAR()).  Then
+contains the array `tt(LPAR()ax1 bx1)tt(RPAR())'.  Then
 
 startitem()
 item(tt(${(s/x/)foo}))(
@@ -1371,21 +1380,21 @@ be taken (e.g. `tt(u:foo:)' or `tt(u[foo])' for user `tt(foo)')
 item(tt(g)var(id))(
 like tt(u)var(id) but with group IDs or names
 )
-item(tt(a)[tt(Mwhm)][tt(-)|tt(PLUS())]var(n))(
-files accessed exactly var(n) days ago.  Files accessed within the
-last var(n) days are selected using a negative value for var(n)
-(tt(-)var(n)).  Files accessed more than var(n) days ago are selected by a
-positive var(n) value (tt(PLUS())var(n)).  Optional unit specifiers `tt(M)',
-`tt(w)', `tt(h)' or `tt(m)' (e.g. `tt(ah5)') cause the check to be
-performed with months (of 30 days), weeks, hours, or minutes instead of
-days, respectively.  For instance, `tt(echo *(ah-5))' would echo files
-accessed within the last five hours.
-)
-item(tt(m)[tt(Mwhm)][tt(-)|tt(PLUS())]var(n))(
+item(tt(a)[tt(Mwhms)][tt(-)|tt(PLUS())]var(n))(
+files accessed exactly var(n) days ago.  Files accessed within the last
+var(n) days are selected using a negative value for var(n) (tt(-)var(n)).
+Files accessed more than var(n) days ago are selected by a positive var(n)
+value (tt(PLUS())var(n)).  Optional unit specifiers `tt(M)', `tt(w)',
+`tt(h)', `tt(m)' or `tt(s)' (e.g. `tt(ah5)') cause the check to be
+performed with months (of 30 days), weeks, hours, minutes or seconds
+instead of days, respectively.  For instance, `tt(echo *(ah-5))' would
+echo files accessed within the last five hours.
+)
+item(tt(m)[tt(Mwhms)][tt(-)|tt(PLUS())]var(n))(
 like the file access qualifier, except that it uses the file modification
 time.
 )
-item(tt(c)[tt(Mwhm)][tt(-)|tt(PLUS())]var(n))(
+item(tt(c)[tt(Mwhms)][tt(-)|tt(PLUS())]var(n))(
 like the file access qualifier, except that it uses the file inode change
 time.
 )
diff --git a/Doc/Zsh/files.yo b/Doc/Zsh/files.yo
index 9ff59fe19..17b29677b 100644
--- a/Doc/Zsh/files.yo
+++ b/Doc/Zsh/files.yo
@@ -8,13 +8,12 @@ cindex(shutdown files)
 pindex(NO_RCS, use of)
 pindex(NO_GLOBAL_RCS, use of)
 Commands are first read from tt(/etc/zshenv); this cannot be overridden.
-If the tt(RCS) option is unset, no further files are read; changing this
-option after this point has no effect on initialization files, but may
-affect behaviour on logout.  Subsequent behaviour is also modified by the
-option tt(GLOBAL_RCS).  If it is unset at any point during initialisation,
-later files in the tt(/etc) directory will not be read.  It is also
-possible for a file in tt($ZDOTDIR) to re-enable tt(GLOBAL_RCS). Both
-tt(RCS) and tt(GLOBAL_RCS) are set by default.
+Subsequent behaviour is modified by the tt(RCS) and
+tt(GLOBAL_RCS) options; the former affects all startup files, while the
+second only affects those in the tt(/etc) directory.  If one of the options
+is unset at any point, the corresponding startup file(s) will not be read.
+It is also possible for a file in tt($ZDOTDIR) to re-enable
+tt(GLOBAL_RCS). Both tt(RCS) and tt(GLOBAL_RCS) are set by default.
 
 Commands are then read from tt($ZDOTDIR/.zshenv).
 pindex(LOGIN, use of)
@@ -31,6 +30,9 @@ via the tt(exit) or tt(logout) commands, or an implict exit by reading
 end-of-file from the terminal.  However, if the shell terminates due
 to tt(exec)'ing another process, the logout files are not read.
 These are also affected by the tt(RCS) and tt(GLOBAL_RCS) options.
+Note also that the tt(RCS) option affects the saving of history files,
+i.e. if tt(RCS) is unset when the shell exits, no history file will be
+saved.
 
 If tt(ZDOTDIR) is unset, tt(HOME) is used instead.
 Those files listed above as being in tt(/etc) may be in another
diff --git a/Doc/Zsh/metafaq.yo b/Doc/Zsh/metafaq.yo
index 1d1636942..569d91716 100644
--- a/Doc/Zsh/metafaq.yo
+++ b/Doc/Zsh/metafaq.yo
@@ -31,26 +31,26 @@ tt(http://www.zsh.org/pub/zsh/))
 item(Australia)(
 nofill(tt(ftp://ftp.zsh.org/pub/zsh/)
 tt(http://www.zsh.org/pub/zsh/)
-tt(ftp://ftp.ips.oz.au/pub/packages/zsh/)  em((G))  em((H)))
+tt(ftp://ftp.ips.gov.au/pub/packages/zsh/)  em((G))  em((H)))
 )
 item(Denmark)(
 nofill(tt(ftp://sunsite.auc.dk/pub/unix/shells/zsh/))
 )
 item(Finland)(
-nofill(tt(ftp://ftp.funet.fi/pub/unix/shells/zsh/)  em((H)))
+nofill(tt(ftp://ftp.funet.fi/pub/unix/shells/zsh/))
 )
 item(France)(
 nofill(tt(ftp://ftp.cenatls.cena.dgac.fr/pub/shells/zsh/))
 )
 item(Germany)(
 nofill(tt(ftp://ftp.fu-berlin.de/pub/unix/shells/zsh/)  em((H))
-tt(ftp://ftp.gmd.de/packages/zsh/)  em((H))
-tt(ftp://ftp.uni-trier.de/pub/unix/shell/zsh/)  em((H)))
+tt(ftp://ftp.gmd.de/packages/zsh/)
+tt(ftp://ftp.uni-trier.de/pub/unix/shell/zsh/))
 )
 item(Hungary)(
 nofill(tt(ftp://ftp.cs.elte.hu/pub/zsh/)
 tt(http://www.cs.elte.hu/pub/zsh/)
-tt(ftp://ftp.kfki.hu/pub/packages/zsh/)  em((H)))
+tt(ftp://ftp.kfki.hu/pub/packages/zsh/))
 )
 item(Israel)(
 nofill(tt(ftp://ftp.math.technion.ac.il/mirror/ftp.zsh.org/pub/zsh/)
@@ -58,10 +58,11 @@ tt(http://www.math.technion.ac.il/mirror/ftp.zsh.org/pub/zsh/))
 )
 item(Japan)(
 nofill(tt(ftp://ftp.tohoku.ac.jp/mirror/zsh/)  em((H))
-tt(ftp://ftp.nis.co.jp/pub/shells/zsh/)  em((H)))
+tt(ftp://ftp.nisiq.net/pub/shells/zsh/)  em((H))
+tt(ftp://ftp.win.ne.jp/pub/shell/zsh/))
 )
 item(Norway)(
-nofill(tt(ftp://ftp.uit.no/pub/unix/shells/zsh/)  em((H)))
+nofill(tt(ftp://ftp.uit.no/pub/unix/shells/zsh/))
 )
 item(Romania)(
 nofill(tt(ftp://ftp.roedu.net/pub/mirrors/ftp.zsh.org/pub/zsh/))
@@ -70,17 +71,17 @@ item(Slovenia)(
 nofill(tt(ftp://ftp.siol.net/pub/unix/shells/zsh/)  em((H)))
 )
 item(Sweden)(
-nofill(tt(ftp://ftp.lysator.liu.se/pub/unix/zsh/)  em((H)))
+nofill(tt(ftp://ftp.lysator.liu.se/pub/unix/zsh/))
 )
 item(UK)(
-nofill(tt(ftp://ftp.net.lut.ac.uk/zsh/)  em((H))
-tt(ftp://sunsite.doc.ic.ac.uk/packages/unix/shells/zsh/)  em((G)))
+nofill(tt(ftp://ftp.net.lut.ac.uk/zsh/)
+tt(ftp://sunsite.org.uk/packages/zsh/))
 )
 item(USA)(
 nofill(tt(ftp://ftp.math.gatech.edu/pub/zsh/)
 tt(ftp://uiarchive.uiuc.edu/pub/packages/shells/zsh/)
 tt(ftp://ftp.sterling.com/zsh/)  em((G))  em((H))
-tt(ftp://ftp.rge.com/pub/shells/zsh/)  em((G))  em((H))
+tt(ftp://ftp.rge.com/pub/shells/zsh/)
 tt(ftp://foad.org/pub/zsh/)
 tt(http://foad.org/zsh/))
 )
diff --git a/Doc/Zsh/options.yo b/Doc/Zsh/options.yo
index c34736107..472364d3e 100644
--- a/Doc/Zsh/options.yo
+++ b/Doc/Zsh/options.yo
@@ -119,7 +119,8 @@ pindex(AUTO_REMOVE_SLASH)
 cindex(slash, removing trailing)
 item(tt(AUTO_REMOVE_SLASH))(
 When the last character resulting from a completion is a slash and the next
-character typed is a word delimiter or a slash, remove the slash.
+character typed is a word delimiter, a slash, or a character that ends 
+a command (such as a semicolon or an ampersand), remove the slash.
 )
 pindex(AUTO_RESUME)
 cindex(jobs, resuming automatically)
@@ -304,7 +305,8 @@ cindex(history, timestamping)
 item(tt(EXTENDED_HISTORY))(
 Save each command's beginning timestamp (in seconds since the epoch)
 and the duration (in seconds) to the history file.  The format of
-this prefixed data is
+this prefixed data is:
+
 `tt(:)var(<beginning time>)tt(:)var(<elapsed seconds>)tt(:)var(<command>)'.
 )
 pindex(FLOW_CONTROL)
@@ -327,15 +329,14 @@ item(tt(GLOB) (tt(PLUS()F), ksh: tt(PLUS()f)))(
 Perform filename generation (globbing).
 (See noderef(Filename Generation).)
 )
-pindex(GLOBAL_RCS_FIRST)
-cindex(startup files, changing order)
-cindex(files, startup, changing order)
-item(tt(GLOBAL_RCS_FIRST) (tt(-d)))(
-If this option is set, and the tt(RCS) option is also set (as it is by
-default), then the order in which startup files are sourced after
-tt(/etc/zshenv) changes to tt(/etc/zprofile), tt(/etc/zshrc),
-tt(/etc/zlogin), tt(.zshenv), tt(.zprofile), tt(.zshrc), tt(.zlogin).
-The order of tt(.zlogout) and tt(/etc/zlogout) is not affected.
+pindex(GLOBAL_RCS)
+cindex(startup files, global, inhibiting)
+cindex(files, global startup, inhibiting)
+item(tt(GLOBAL_RCS) (tt(-d)))(
+If this option is unset, the startup files tt(/etc/zprofile),
+tt(/etc/zshrc), tt(/etc/zlogin) and tt(/etc/zlogout) will not be run.  It
+can be disabled and re-enabled at any time, including inside local startup
+files (tt(.zshrc), etc.).
 )
 pindex(GLOB_ASSIGN)
 item(tt(GLOB_ASSIGN))(
@@ -409,13 +410,13 @@ isn't there.
 pindex(HIST_EXPIRE_DUPS_FIRST)
 cindex(history, expiring duplicates)
 item(tt(HIST_EXPIRE_DUPS_FIRST))(
-If the history needs to be trimmed to add a new line, setting this
-option will cause the oldest duplicate history line to be lost before
-losing a unique line from the internal history list.
+If the internal history needs to be trimmed to add a new line,
+setting this option will cause the oldest duplicate history line to
+be lost before losing a unique line from the list.
 )
 pindex(HIST_IGNORE_ALL_DUPS)
 cindex(history, ignoring all duplicates)
-item(tt(HIST_IGNORE_ALL_DUPS) (tt(-h)))(
+item(tt(HIST_IGNORE_ALL_DUPS))(
 If a new command line being added to the history list duplicates an
 older one, the older command is removed from the list (even if it is
 not the previous event).
@@ -482,11 +483,11 @@ to avoid the shell hanging if its tty goes away.
 pindex(INC_APPEND_HISTORY)
 cindex(history, incremental appending to a file)
 item(tt(INC_APPEND_HISTORY))(
-This options works like APPEND_HISTORY except that new history lines
-are added to the tt($HISTFILE) when they finish running, rather than
-waiting until the shell is killed. The file is periodically trimmed
-to the number of lines specified by tt($SAVEHIST), but can exceed this
-value between trimmings.
+This options works like tt(APPEND_HISTORY) except that new history lines
+are added to the tt($HISTFILE) incrementally (as soon as they are
+entered), rather than waiting until the shell is killed.
+The file is periodically trimmed to the number of lines specified by
+tt($SAVEHIST), but can exceed this value between trimmings.
 )
 pindex(INTERACTIVE)
 item(tt(INTERACTIVE) (tt(-i), ksh: tt(-i)))(
@@ -568,7 +569,8 @@ tt(XTRACE) and tt(PRINT_EXIT_VALUE) options are restored.  Hence
 if this is explicitly unset by a shell function the other options in
 force at the point of return will remain so.
 A shell function can also guarantee itself a known shell configuration
-with a formulation like `tt(emulate zsh; setopt localoptions)'.
+with a formulation like `tt(emulate -L zsh)'; the tt(-L) activates
+tt(LOCAL_OPTIONS).
 )
 pindex(LOGIN)
 item(tt(LOGIN) (tt(-l), ksh: tt(-l)))(
@@ -795,7 +797,10 @@ After tt(/etc/zshenv) is sourced on startup, source the
 tt(.zshenv), tt(/etc/zprofile), tt(.zprofile),
 tt(/etc/zshrc), tt(.zshrc), tt(/etc/zlogin), tt(.zlogin), and tt(.zlogout)
 files, as described in noderef(Files).
-If this option is unset, only the tt(/etc/zshenv) file is sourced.
+If this option is unset, the tt(/etc/zshenv) file is still sourced, but any
+of the others will not be; it can be set at any time to prevent the
+remaining startup files after the currently executing one from
+being sourced.
 )
 pindex(REC_EXACT)
 cindex(completion, exact matches)
@@ -833,21 +838,22 @@ cindex(history, sharing)
 item(tt(SHARE_HISTORY))(
 
 This option both imports new commands from the history file, and also
-causes your typed commands to be appended to the history file (like
-specifiying tt(INCREMENTAL_APPEND_HISTORY)).  The history lines are also
-output with timestamps ala tt(EXTENDED_HISTORY) (which makes it easier to
-find the spot where we left off reading the file after it gets re-written).
+causes your typed commands to be appended to the history file (the
+latter is like specifying tt(INC_APPEND_HISTORY)).
+The history lines are also output with timestamps ala
+tt(EXTENDED_HISTORY) (which makes it easier to find the spot where
+we left off reading the file after it gets re-written).
 
-By default, history movement commands visit the imported lines as well as
-the local lines, but you can toggle this on and off with the
+By default, history movement commands visit the imported lines as
+well as the local lines, but you can toggle this on and off with the
 set-local-history zle binding.  It is also possible to create a zle
-widget that will make some commands ignore imported commands, and some
-include them.
+widget that will make some commands ignore imported commands, and
+some include them.
 
 If you find that you want more control over when commands
 get imported, you may wish to turn tt(SHARE_HISTORY) off,
-tt(INCREMENTAL_APPEND_HISTORY) on, and then manually import
-commands whenever you need them using `fc -RI'.
+tt(INC_APPEND_HISTORY) on, and then manually import
+commands whenever you need them using `tt(fc -RI)'.
 )
 pindex(SH_FILE_EXPANSION)
 cindex(sh, expansion style)
diff --git a/Doc/Zsh/zftpsys.yo b/Doc/Zsh/zftpsys.yo
index f20a0a6c3..6983dedb9 100644
--- a/Doc/Zsh/zftpsys.yo
+++ b/Doc/Zsh/zftpsys.yo
@@ -7,10 +7,10 @@ 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.
+tt(ftp) command itself, see manref(ftp)(1)), 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(\
@@ -20,11 +20,11 @@ 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)
+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).
+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
@@ -43,7 +43,7 @@ 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;
+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
@@ -93,13 +93,13 @@ 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
+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
+generated as var(user)tt(@)var(host); this is then stored in the shell
 parameter tt($EMAIL_ADDR) which can alternatively be set manually to a
 suitable string.
 )
@@ -114,9 +114,9 @@ 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
+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 ~).
+is omitted, has the effect of `tt(zfcd ~)'.
 
 The second form changes to the directory previously current.
 
@@ -125,22 +125,22 @@ 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.
+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.
+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).
+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).
+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
@@ -163,7 +163,7 @@ 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.
+are passed directly to the server.  No pager and no caching is used.
 )
 enditem()
 
@@ -171,9 +171,9 @@ 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.
+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
@@ -266,9 +266,9 @@ 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
+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.
 )
diff --git a/Doc/ztexi.yo b/Doc/ztexi.yo
index 7388c61aa..231a70b84 100644
--- a/Doc/ztexi.yo
+++ b/Doc/ztexi.yo
@@ -33,7 +33,7 @@ COMMENT(--- emphasised text ---)
 
 def(em)(1)(NOTRANS(@emph{)ARG1NOTRANS(}))
 def(bf)(1)(NOTRANS(@cite{)ARG1NOTRANS(}))
-def(tt)(1)(NOTRANS(@code{)ARG1NOTRANS(}))
+def(tt)(1)(NOTRANS(@t{)ARG1NOTRANS(}))
 def(var)(1)(NOTRANS(@var{)ARG1NOTRANS(}))
 
 COMMENT(--- man page headers ---)