zsh-3.1.5-pws-22 zsh-3.1.5-pws-22

23 files changed, 275 insertions, 240 deletions

diff --git a/Doc/Makefile.in b/Doc/Makefile.in
index c0ae8d80d..83bba17f8 100644
--- a/Doc/Makefile.in
+++ b/Doc/Makefile.in
@@ -57,7 +57,7 @@ Zsh/filelist.yo Zsh/files.yo Zsh/func.yo Zsh/grammar.yo Zsh/guide.yo \
 Zsh/index.yo Zsh/intro.yo Zsh/invoke.yo Zsh/jobs.yo Zsh/metafaq.yo \
 Zsh/modules.yo Zsh/mod_cap.yo Zsh/compwid.yo Zsh/compsys.yo \
 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_example.yo Zsh/mod_files.yo Zsh/mod_mapfile.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/zftpsys.yo Zsh/zle.yo
@@ -132,8 +132,8 @@ zshmisc.1: Zsh/grammar.yo Zsh/redirect.yo Zsh/exec.yo Zsh/func.yo \
 
 zshmodules.1: Zsh/modules.yo Zsh/mod_cap.yo 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_sched.yo \
-              Zsh/mod_stat.yo Zsh/mod_zftp.yo Zsh/mod_zle.yo
+              Zsh/mod_example.yo Zsh/mod_files.yo Zsh/mod_mapfile.yo \
+              Zsh/mod_sched.yo Zsh/mod_stat.yo Zsh/mod_zftp.yo Zsh/mod_zle.yo
 
 zshoptions.1: Zsh/options.yo
 
diff --git a/Doc/Zsh/arith.yo b/Doc/Zsh/arith.yo
index f08deb372..f22b35794 100644
--- a/Doc/Zsh/arith.yo
+++ b/Doc/Zsh/arith.yo
@@ -5,16 +5,42 @@ sect(Arithmetic Evaluation)
 )\
 cindex(arithmetic evaluation)
 cindex(evaluation, arithmetic)
-An ability to perform integer arithmetic is provided with the builtin tt(let).
 findex(let, use of)
-Evaluations are performed using em(long) arithmetic.
+The shell can perform integer arithmetic, either using the builtin tt(let),
+or via a substitution of the form tt($((...))).  Usually arithmetic is
+performed with em(long) integers; however, on certain systems where a
+em(long) has 4-byte precision, zsh may be compiled to use 8-byte precision
+instead.  This can be tested, for example, by giving the command
+`tt(print - $(( 12345678901 )))'; if the number appears unchanged, the
+precision is at least 8 bytes.
+
+The tt(let) builtin command takes arithmetic expressions as arguments; each
+is evaluated separately.  Since many of the arithmetic operators, as well
+as spaces, require quoting, an alternative form is provided: for any
+command which begins with a `tt(LPAR()LPAR())', all the characters until a
+matching `tt(RPAR()RPAR())' are treated as a quoted expression and
+arithmetic expansion performed as for an argument of tt(let).  More
+precisely, `tt(LPAR()LPAR())var(...)tt(RPAR()RPAR())' is equivalent to
+`tt(let ")var(...)tt(")'.  For example, the following statement
+
+example((( val = 2 + 1 )))
+
+is equivalent to
+
+example(let "val = 2 + 1")
+
+both assigning the value 3 to the shell variable tt(foo) and returning a
+zero status.
+
+cindex(bases, in arithmetic)
+Numbers can be in bases other than 10.
 A leading `tt(0x)' or `tt(0X)' denotes hexadecimal.
-Otherwise, numbers are of the form `[var(base)tt(#)]var(n)',
+Numbers may also be of the form `var(base)tt(#)var(n)',
 where var(base) is a decimal number between two and thirty-six
 representing the arithmetic base and var(n)
 is a number in that base (for example, `tt(16#ff)' is 255 in hexadecimal).
-If var(base) is omitted
-then base 10 is used.  For backwards compatibility the form
+The var(base)tt(#) may also be omitted, in which case
+base 10 is used.  For backwards compatibility the form
 `tt([)var(base)tt(])var(n)' is also accepted.
 
 cindex(arithmetic operators)
@@ -50,10 +76,17 @@ and XOR operators.
 An expression of the form `tt(#\)var(x)' where var(x) is any character
 gives the ascii value of this character and an expression of the form
 `tt(#)var(foo)' gives the ascii value of the first character of the value
+of the parameter var(foo).  Note that this is different from the expression
+`tt($#)var(foo)', a standard parameter substitution which gives the length
 of the parameter var(foo).
 
 Named parameters and subscripted arrays can be referenced by name within an
-arithmetic expression without using the parameter expansion syntax.
+arithmetic expression without using the parameter expansion syntax.  For
+example,
+
+example((((val2 = val1 * 2))))
+
+assigns twice the value of tt($val1) to the parameter named tt(val2).
 
 An internal integer representation of a named parameter
 can be specified with the tt(integer) builtin.
@@ -63,11 +96,3 @@ findex(integer, use of)
 Arithmetic evaluation is performed on the value of each
 assignment to a named parameter declared integer
 in this manner.
-
-Since many of the arithmetic operators require
-quoting, an alternative form of the tt(let) command is provided.
-For any command which begins with a tt(LPAR()LPAR()),
-all the characters until a matching tt(RPAR()RPAR())
-are treated as a quoted expression.
-More precisely, `tt(LPAR()LPAR()) ... tt(RPAR()RPAR())'
-is equivalent to `tt(let ")...tt(")'.
diff --git a/Doc/Zsh/builtins.yo b/Doc/Zsh/builtins.yo
index 157b3420d..49c9dc26c 100644
--- a/Doc/Zsh/builtins.yo
+++ b/Doc/Zsh/builtins.yo
@@ -981,12 +981,13 @@ shown.
 )
 item(tt(-f))(
 The names refer to functions rather than parameters.  No assignments
-can be made, and the only other valid flags are tt(-t)
-and tt(-u).  The flag tt(-t) turns on execution tracing for this
-function.  The flag tt(-u) causes this function to be marked
-for autoloading.  The tt(fpath) parameter will be searched to find the
-function definition when the function is first referenced; see
-noderef(Functions).
+can be made, and the only other valid flags are tt(-t), tt(-u) and
+tt(-U).  The flag tt(-t) turns on execution tracing for this
+function.  The tt(-u) and tt(-U) flags cause the function to be
+marked for autoloading; tt(-U) also causes alias expansion to be
+suppressed when the function is loaded.  The tt(fpath) parameter
+will be searched to find the function definition when the function
+is first referenced; see noderef(Functions).
 )
 item(tt(-i))(
 Use an internal integer representation.  If var(n) is nonzero it
diff --git a/Doc/Zsh/compctl.yo b/Doc/Zsh/compctl.yo
index 4fecce92f..48c7bf629 100644
--- a/Doc/Zsh/compctl.yo
+++ b/Doc/Zsh/compctl.yo
@@ -1,5 +1,5 @@
-texinode(Programmable Completion)(Completion Widgets)(Zsh Line Editor)(Top)
-chapter(Programmable Completion)
+texinode(Programmable Completion Using compctl)(Completion Widgets)(Zsh Line Editor)(Top)
+chapter(Programmable Completion Using compctl)
 cindex(completion, programmable)
 cindex(completion, controlling)
 findex(compctl)
@@ -33,7 +33,7 @@ menu(Matching Control)
 menu(Example)
 endmenu()
 
-texinode(Command Flags)(Option Flags)()(Programmable Completion)
+texinode(Command Flags)(Option Flags)()(Programmable Completion Using compctl)
 sect(Command Flags)
 Completion of the arguments of a command may be different for each
 command or may use the default.  The behavior when completing the
@@ -56,7 +56,7 @@ from immediate expansion; for example the command string tt('foo*')
 arranges for completion of the words of any command beginning with
 tt(foo).  When completion is attempted, all pattern completions are
 tried in the reverse order of their definition until one matches.  By
-default, completion then procedes as normal, i.e. the shell will try to
+default, completion then proceeds as normal, i.e. the shell will try to
 generate more matches for the specific command on the command line; this
 can be overridden by including tt(-tn) in the flags for the pattern
 completion.
@@ -88,9 +88,7 @@ the standard behavior for all commands.  For example, if your access
 to the user database is too slow and/or it contains too many users (so
 that completion after `tt(~)' is too slow to be usable), you can use
 
-indent(
-tt(compctl -T -x 's[~] C[0,[^/]#]' -k friends -S/ -tn)
-)
+example(compctl -T -x 's[~] C[0,[^/]#]' -k friends -S/ -tn)
 
 to complete the strings in the array tt(friends) after a `tt(~)'.
 The tt(C[...]) argument is necessary so that this form of ~-completion is
@@ -118,7 +116,7 @@ options specified by the tt(-D) flag.
 The form with tt(-M) as the first and only option defines global
 matching specifications, as described below in noderef(Matching Control).
 
-texinode(Option Flags)(Alternative Completion)(Command Flags)(Programmable Completion)
+texinode(Option Flags)(Alternative Completion)(Command Flags)(Programmable Completion Using compctl)
 sect(Option Flags)
 startlist()
 list([ tt(-fcFBdeaRGovNAIOPZEnbjrzu/) ])
@@ -256,10 +254,8 @@ of space- or comma-separated values in parentheses, in which any
 delimiter may be escaped with a backslash; in this case the argument
 should be quoted.  For example,
 
-indent(
-nofill(tt(compctl -k "(cputime filesize datasize stacksize
-	       coredumpsize resident descriptors)" limit))
-)
+example(compctl -k "(cputime filesize datasize stacksize
+	       coredumpsize resident descriptors)" limit)
 )
 item(tt(-g) var(globstring))(
 The var(globstring) is expanded using filename globbing; it should be
@@ -281,7 +277,7 @@ resulting files.  Note that tt(-g) is faster for filenames.
 )
 item(tt(-K) var(function))(
 Call the given function to get the completions.  Unless the name
-starts with an underscode, the function is
+starts with an underscore, the function is
 passed two arguments: the prefix and the suffix of the word on which
 completion is to be attempted, in other words those characters before
 the cursor position, and those from the cursor position onwards.  The
@@ -293,10 +289,8 @@ should not be made local to the function.  From such a function the
 command line can be accessed with the tt(-c) and tt(-l) flags to
 the tt(read) builtin.  For example,
 
-indent(
-nofill(tt(function whoson { reply=(`users`); }
-compctl -K whoson talk))
-)
+example(function whoson { reply=(`users`); }
+compctl -K whoson talk)
 
 completes only logged-on users after `tt(talk)'.  Note that `tt(whoson)' must
 return an array, so `tt(reply=`users`)' would be incorrect.
@@ -315,9 +309,7 @@ zero or negative the whole history is searched and if var(pattern) is
 the empty string all words are taken (as with `tt(*)').  A typical
 use is
 
-indent(
-tt(compctl -D -f PLUS() -H 0 '')
-)
+example(compctl -D -f PLUS() -H 0 '')
 
 which forces completion to look back in the history list for a word if
 no filename matches.
@@ -345,9 +337,7 @@ The var(prefix) is inserted just before the completed string; any
 initial part already typed will be completed and the whole var(prefix)
 ignored for completion purposes.  For example,
 
-indent(
-tt(compctl -j -P "%" kill)
-)
+example(compctl -j -P "%" kill)
 
 inserts a `%' after the kill command and then completes job names.
 )
@@ -362,9 +352,7 @@ With directory var(file-prefix):  for command, file, directory and
 globbing completion (options tt(-c), tt(-f), tt(-/), tt(-g)), the file
 prefix is implicitly added in front of the completion.  For example,
 
-indent(
-tt(compctl -/ -W ~/Mail maildirs)
-)
+example(compctl -/ -W ~/Mail maildirs)
 
 completes any subdirectories to any depth beneath the directory
 tt(~/Mail), although that prefix does not appear on the command line.
@@ -393,9 +381,7 @@ option. If the var(cmd) string is empty the first word in the range
 is instead taken as the command name, and command name completion
 performed on the first word in the range.  For example,
 
-indent(
-tt(compctl -x 'r[-exec,;]' -l '' -- find)
-)
+example(compctl -x 'r[-exec,;]' -l '' -- find)
 
 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
@@ -419,7 +405,7 @@ tt(-K) option) which can examine the word components passed to it
 use its own criteria to decide what matches.  If there is no
 completion, the original word is retained.  Since the produced 
 possible completions seldom seldom have interesting common prefixes
-and suffixes, menucompletion is started immediatly if tt(AUTO_MENU) is
+and suffixes, menucompletion is started immediately if tt(AUTO_MENU) is
 set and this flag is used.
 )
 item(tt(-y) var(func-or-var))(
@@ -499,9 +485,7 @@ group name are stored in that group.
 This can be useful with non-exclusive alternative completions.  For
 example, in
 
-indent(
-tt(compctl -f -J files -t+ + -v -J variables foo)
-)
+example(compctl -f -J files -t+ + -v -J variables foo)
 
 both files and variables are possible completions, as the tt(-t+) forces
 both sets of alternatives before and after the tt(+) to be considered at
@@ -521,7 +505,7 @@ of the var(match-spec) string is described below in noderef(Matching Control).
 )
 enditem()
 
-texinode(Alternative Completion)(Extended Completion)(Option Flags)(Programmable Completion)
+texinode(Alternative Completion)(Extended Completion)(Option Flags)(Programmable Completion Using compctl)
 sect(Alternative Completion)
 startlist()
 list(tt(compctl) [ tt(-CDT) ] var(options) tt(PLUS()) var(options) [ tt(PLUS()) ... ] \
@@ -536,7 +520,7 @@ up to that point, default completion is tried.
 If the list of flags contains a tt(-t) with a tt(PLUS()) character, the next
 list of flags is used even if the current list produced matches.
 
-texinode(Extended Completion)(Matching Control)(Alternative Completion)(Programmable Completion)
+texinode(Extended Completion)(Matching Control)(Alternative Completion)(Programmable Completion Using compctl)
 sect(Extended Completion)
 startlist()
 list(nofill(tt(compctl) [ tt(-CDT) ] var(options) \
@@ -612,9 +596,7 @@ considered part of the completion, but the rest will.  var(index) may
 be negative to count from the end: in most cases, var(index) will be
 1 or -1.  For example,
 
-indent(
-tt(compctl -s '`users`' -x 'n[1,@]' -k hosts -- talk)
-)
+example(compctl -s '`users`' -x 'n[1,@]' -k hosts -- talk)
 
 will usually complete usernames, but if you insert an tt(@) after the
 name, names from the array var(hosts) (assumed to contain hostnames,
@@ -648,7 +630,7 @@ completion is done in backticks and var(str) starts with a `b'.
 )
 enditem()
 
-texinode(Matching Control)(Example)(Extended Completion)(Programmable Completion)
+texinode(Matching Control)(Example)(Extended Completion)(Programmable Completion Using compctl)
 sect(Matching Control)
 
 It is possible by use of the tt(-M) var(spec) flag to specify how the
@@ -732,10 +714,10 @@ following alters the matching rules so that the prefix tt(no) and any
 underscore are ignored when trying to match the trial completions
 generated and uppercase letters on the line match the corresponding
 lowercase letters in the words:
-indent(
-nofill(tt(compctl -M 'L:|[nN][oO]= M:_= M:{A-Z}={a-z}' \ 
-  -o setopt unsetopt))
-)
+
+example(compctl -M 'L:|[nN][oO]= M:_= M:{A-Z}={a-z}' \ 
+  -o setopt unsetopt)
+
 The first part says that the pattern `tt([nN][oO])' at the beginning
 (the empty anchor before the pipe symbol) of the string on the
 line matches the empty string in the list of words generated by
@@ -752,14 +734,13 @@ The second example makes completion case insensitive.  By using
 tt(compctl) with the tt(-M) option alone this applies to every
 completion.  This is just the same as in the tt(setopt) example, except
 here we wish to retain the characters in the list of completions:
-indent(
-tt(compctl -M 'm:{a-z}={A-Z}')
-)
+
+example(compctl -M 'm:{a-z}={A-Z}')
+
 This makes lowercase letters match their uppercase counterparts.
 To make uppercase letters match the lowercase forms as well:
-indent(
-tt(compctl -M 'm:{a-zA-Z}={A-Za-z}')
-)
+
+example(compctl -M 'm:{a-zA-Z}={A-Za-z}')
 
 A nice example for the use of tt(*) patterns is partial word
 completion. Sometimes you would like to make strings like tt(c.s.u)
@@ -770,10 +751,10 @@ however, that the case where each part of the word, i.e. tt(comp),
 tt(source) and tt(unix) in this example, is to be completed separately
 is a different problem to be solved by extended completion.  The
 example can be handled by:
-indent(
-nofill(tt(compctl -M 'r:|.=* r:|=*' \ 
-  -k '(comp.sources.unix comp.sources.misc ...)' ngroups))
-)
+
+example(compctl -M 'r:|.=* r:|=*' \ 
+  -k '(comp.sources.unix comp.sources.misc ...)' ngroups)
+
 The first specification says that tt(lpat) is the empty string, while
 tt(anchor) is a dot; tt(tpat) is tt(*), so this can match anything
 except for the `tt(.)' from the anchor in
@@ -795,9 +776,9 @@ empty string at the end of the string on the line matches any characters
 at the end of the trial completion.
 
 More generally, the specification
-indent(
-tt(compctl -M 'r:|[.,_-]=* r:|=*')
-)
+
+example(compctl -M 'r:|[.,_-]=* r:|=*')
+
 allows one to complete words with abbreviations before any of the
 characters in the square brackets in any completion.  For example, to
 complete tt(veryverylongfile.c) rather than tt(veryverylongheader.h)
@@ -817,9 +798,9 @@ the string on the command line as a substring, not just at the
 beginning.  Since this might produce more matches than we want,
 we arrange for it to be tried only if the matchers described above don't
 produce any matches:
-indent(
-tt(compctl -M 'r:|[.,_-]=* r:|=*' 'l:|=* r:|=*')
-)
+
+example(compctl -M 'r:|[.,_-]=* r:|=*' 'l:|=* r:|=*')
+
 Here, if the string on the command line is tt(foo.bar), tt(compctl)
 first tries matching tt(foo)var(anything)tt(.bar)var(anything), as
 with the previous example.  If that fails, the two descriptions in the
@@ -828,13 +809,12 @@ and end of the string on the command line can match any set of
 characters at the beginning or end of the trial completion, so it will
 look for var(anything)tt(foo.bar)var(anything).
 
-texinode(Example)()(Matching Control)(Programmable Completion)
+texinode(Example)()(Matching Control)(Programmable Completion Using compctl)
 sect(Example)
-indent(
-nofill(
-tt(compctl -u -x 's[tt(PLUS())] c[-1,-f],s[-f+PLUS()]' \ 
-  -g '~/Mail/*(:t)' - 's[-f],c[-1,-f]' -f -- mail))
-)
+
+example(compctl -u -x 's[tt(PLUS())] c[-1,-f],s[-f+PLUS()]' \ 
+  -g '~/Mail/*(:t)' - 's[-f],c[-1,-f]' -f -- mail)
+
 This is to be interpreted as follows:
 
 If the current command is tt(mail), then
diff --git a/Doc/Zsh/compsys.yo b/Doc/Zsh/compsys.yo
index 94533415e..572660de3 100644
--- a/Doc/Zsh/compsys.yo
+++ b/Doc/Zsh/compsys.yo
@@ -51,7 +51,7 @@ sect(Initialisation)
 
 The script tt(compinstall) can be run by a user to set up the completion
 system for use.  It will usually insert code into tt(.zshrc), although if
-that is not writeable it will save it in another file and tell you that
+that is not writable it will save it in another file and tell you that
 file's locations.  Note that it is up to you to make sure that the lines
 added to tt(.zshrc) are actually run; you may, for example, need to move
 them to an earlier place in the file if tt(.zshrc) usually returns early.
@@ -89,13 +89,13 @@ 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, or, if that is not writeable by the
+but with tt(.dump) appended to the end, or, if that is not writable 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 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
 its full pathname, and the option tt(FUNCTION_ARGZERO) is set, as it is by
 default unless tt(zsh) is emulating tt(sh) or tt(ksh), this is unnecessary
@@ -106,7 +106,7 @@ the completion functions (see below).
 
 If the number of completion files changes, tt(compinit) will recognise this
 and produce a new dump file.  However, if the name of a function or the
-arguments in the first line of a tt(#compdef) funcion (as described below)
+arguments in the first line of a tt(#compdef) function (as described below)
 change, it is easiest to delete the dump file by hand so that the next time
 tt(compinit) will re-create it.
 
@@ -153,7 +153,7 @@ var(pattern) (a standard globbing pattern).  Note that only one
 var(pattern) may be given.
 )
 item(tt(#compdef -k) var(style key-sequences...))(
-This can be used bind special completion functions to the
+This can be used to bind special completion functions to the
 var(key-sequences).  It creates a widget behaving like the builtin widget
 var(style), which must be one of those that perform completion, namely
 tt(complete-word), tt(delete-char-or-list), tt(expand-or-complete),
@@ -252,9 +252,7 @@ set of functions to try is taken from the colon-separated list in the
 configuration key tt(completer). For example, to use normal
 completion and correction if that doesn't generate any matches:
 
-indent(
-nofill(tt(compconf completer=_complete:_correct))
-)
+example(compconf completer=_complete:_correct)
 
 after sourcing tt(compinit). The default value for this configuration key
 set up in tt(compinit) is `tt(_complete)', i.e. normally only ordinary
@@ -355,9 +353,7 @@ counted. The resulting list of corrected and completed strings is then
 presented to the user. The intended use of this completer function is to
 try after the normal tt(_complete) completer by setting:
 
-indent(
-nofill(tt(compconf completer=_complete:_approximate))
-)
+example(compconf completer=_complete:_approximate)
 
 This will give correcting completion if and only if
 normal completion doesn't yield any possible completions. When
@@ -379,9 +375,7 @@ If the value for this key contains a lower- or upper-case `tt(n)', the
 completer function will take any numeric argument as the
 maximum number of errors allowed. For example, with
 
-indent(
-nofill(tt(compconf approximate_accept=2n))
-)
+example(compconf approximate_accept=2n)
 
 two errors will be allowed if no numeric argument is given. However,
 with a numeric argument of six (as in `tt(ESC-6 TAB)'), up to six
@@ -443,10 +437,8 @@ configuration parameters beginning tt(correct_) are used.
 
 For example, with:
 
-indent(tt(
-nofill(compconf completer=_complete:_correct:_approximate)
-nofill(compconf correct_accept='2n!' approximate_accept=3n))
-)
+example(compconf completer=_complete:_correct:_approximate
+compconf correct_accept='2n!' approximate_accept=3n)
 
 correction will accept up to two errors. If a numeric argument is
 given, correction will not be performed, but correcting completion will be,
@@ -464,7 +456,7 @@ generated by the tt(_correct) completer -- and probably more.
 item(tt(_match))(
 This completer is intended to be used after the tt(_complete)
 completer. It allows one to give patterns on the command line and
-to complete all strings metching these patterns from the set of possible
+to complete all strings matching these patterns from the set of possible
 completions for the context the cursor is in, without having to set
 the tt(GLOB_COMPLETE) option.
 
@@ -498,9 +490,7 @@ non-empty string it should be an expression usable inside a `tt($((...)))'
 arithmetical expression. In this case, expansion of substitutions will
 be done if the expression evaluates to `tt(1)'. For example, with
 
-indent(
-nofill(tt(compconf expand_substitute='NUMERIC != 1'))
-)
+example(compconf expand_substitute='NUMERIC != 1')
 
 substitution will be performed only if given an explicit numeric
 argument other than `tt(1)', as by typing `tt(ESC 2 TAB)'.
@@ -556,9 +546,7 @@ should be set to an expression usable inside a `tt($((...)))'
 arithmetical expression. In this case, delaying will be done if the
 expression evaluates to `tt(1)'. For example, with
 
-indent(
-nofill(tt(compconf list_condition='NUMERIC != 1'))
-)
+example(compconf list_condition='NUMERIC != 1')
 
 delaying will be done only if given an explicit numeric argument
 other than `tt(1)'.
@@ -614,6 +602,7 @@ continues with the existing list of completions.  If this key is set to
 tt(never), however, a new completion is started if the old list was
 generated by a different completion command (the behaviour without the
 tt(_oldlist) completer).
+
 For example, suppose you type tt(^Xc) to generate a list of corrections,
 and menu completion is started in one of the usual ways.  Usually, typing
 tt(TAB) at this point would start trying to complete the line as it now
@@ -704,7 +693,7 @@ over which filenames should be ignored as done by the tt(fignore)
 parameter in normal completion.
 
 The function tt(_files) calls tt(_path_files) with all the arguments
-it was passed and, if that generated no matches, call tt(_path_files) again
+it was passed and, if that generated no matches, calls tt(_path_files) again
 without any tt(-g) or tt(-/) option, thus generating all filenames.
 
 These functions also accept the `tt(-J)', `tt(-V)', `tt(-X)', `tt(-P)',
@@ -764,11 +753,9 @@ not start with a square bracket or parenthesis, it should be the name of a
 command (probably with arguments) that should be invoked to complete 
 after the equal sign. Example:
 
-indent(
-nofill(tt(_long_options '*\*'     '(yes no)' \))
-nofill(tt(              '*=FILE*' '_files' \))
-nofill(tt(              '*=DIR*'  '_files -/'))
-)
+example(_long_options '*\*'     '(yes no)' \ 
+              '*=FILE*' '_files' \ 
+              '*=DIR*'  '_files -/')
 
 Here, `tt(yes)' and `tt(no)' will be completed as the argument of
 options whose description ends in a star, file names for options that
diff --git a/Doc/Zsh/compwid.yo b/Doc/Zsh/compwid.yo
index d30adc0f1..7f5ffe442 100644
--- a/Doc/Zsh/compwid.yo
+++ b/Doc/Zsh/compwid.yo
@@ -1,4 +1,4 @@
-texinode(Completion Widgets)(Zsh Modules)(Programmable Completion)(Top)
+texinode(Completion Widgets)(Zsh Modules)(Programmable Completion Using compctl)(Top)
 chapter(Completion Widgets)
 cindex(completion, widgets)
 cindex(completion, programmable)
@@ -10,9 +10,7 @@ ifzman(zmanref(zshzle))\
 ifnzman(noderef(The zle Module))\
 ). For example,
 
-indent(
-nofill(tt(zle -C complete expand-or-complete completer))
-)
+example(zle -C complete expand-or-complete completer)
 
 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
@@ -73,10 +71,8 @@ not considered part of the list of matches.  Typically, a string is
 transferred from the beginning of tt(PREFIX) to the end of tt(IPREFIX), for
 example:
 
-tt(indent(
-nofill(IPREFIX=${PREFIX%%\=*}=)
-nofill(PREFIX=${PREFIX#*=})
-))
+example(IPREFIX=${PREFIX%%\=*}=
+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.
@@ -182,9 +178,7 @@ item(tt(matcher))(
 When completion is performed with a global match specification as defined
 by
 
-indent(
-nofill(tt(compctl -M) var(spec1 ... specN ...))
-)
+indent(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.
@@ -229,7 +223,7 @@ the tt(ALWAYS_LAST_PROMPT) option.
 )
 item(tt(insert))(
 This controls the manner in which a match is inserted into the command
-line.  On entry to the widget fuction, if it is unset the command line is
+line.  On entry to the widget function, if it is unset the command line is
 not to be changed; if set to tt(unambiguous), any prefix common to all
 matches is to be inserted; if set to tt(menu) or tt(automenu) the usual
 behaviour of the tt(MENU_COMPLETE) or tt(AUTO_MENU) options, respectively,
@@ -262,7 +256,7 @@ 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.  This will
 usually be the case if and only if the previous editing operation was a
-completion widget or one of the builtin completion fuctions.  If there is a
+completion widget or one of the builtin completion functions.  If there is a
 valid list and it is also currently shown on the screen, the value of this
 key is tt(shown).
 
@@ -330,7 +324,7 @@ Generate matches according to the given var(flags).  These can be any of
 the normal option flags (not those for extended completion) supported by
 the tt(compctl) builtin command (see
 ifzman(zmanref(zshcompctl))\
-ifnzman(noderef(Programmable Completion))\
+ifnzman(noderef(Programmable Completion Using compctl))\
 ) except for the tt(-t) and tt(-l) flags.  However, when using the tt(-K)
 flag, the function given as argument to it cannot access the command
 line with the tt(read) builtin command.
@@ -339,7 +333,7 @@ The matches will be generated in the same way as if the completion code
 generated them directly from a tt(compctl)-definition with the same
 flags. The completion code will consider only those matches as
 possible completions that match the prefix and suffix from the special 
-parameters desribed above. These strings will be compared with the
+parameters described 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 via the tt(compctl -M )var(spec1 ...)
@@ -366,9 +360,7 @@ non-zero if no matches were added.
 The completion code breaks the string to complete into seven fields in
 the order: 
 
-indent(
-var(<ipre><apre><hpre><word><hsuf><asuf><isuf>)
-)
+indent(var(<ipre><apre><hpre><word><hsuf><asuf><isuf>))
 
 The first field
 is an ignored prefix taken from the command line, the contents of the
@@ -620,20 +612,18 @@ 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 
+currently 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
+In all the above cases the return value is zero if the test succeeded
 and the parameters were modified and non-zero otherwise. This allows
 one to use this builtin in tests such as:
 
-indent(
-tt(if compset -P '*\='; then ...)
-)
+example(if compset -P '*\='; then ...)
 
 This forces anything up to and including the last equal sign to be
 ignored by the completion code.
@@ -685,21 +675,18 @@ sect(Examples)
 
 The first step is to define the widget:
 
-indent(nofill(
-tt(zle -C complete complete-word complete-history)))
+example(zle -C complete complete-word complete-history)
 
 Then the widget can be bound to a key using the tt(bindkey) builtin
 command:
 
-indent(nofill(
-tt(bindkey '^X\t' complete)))
+example(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 generate the
 matches, e.g.:
 
-indent(nofill(
-tt(complete-history LPAR()RPAR() { compgen -H 0 '' })))
+example(complete-history LPAR()RPAR() { compgen -H 0 '' })
 
 This function will complete words from the history matching the 
 current word.
diff --git a/Doc/Zsh/expn.yo b/Doc/Zsh/expn.yo
index 7fdf973b4..5cc9fe4e3 100644
--- a/Doc/Zsh/expn.yo
+++ b/Doc/Zsh/expn.yo
@@ -277,7 +277,8 @@ If tt(<) is used, then the file passed as an argument will
 be a named pipe connected to the output of the var(list) process.
 For example,
 
-nofill(tt(paste <LPAR()cut -f1) var(file1)tt(RPAR() <LPAR()cut -f3) var(file2)tt(RPAR() | tee >LPAR())var(process1)tt(RPAR() >LPAR())var(process2)tt(RPAR() >/dev/null))
+nofill(tt(paste <LPAR()cut -f1) var(file1)tt(RPAR() <LPAR()cut -f3) var(file2)tt(RPAR() |
+tee >LPAR())var(process1)tt(RPAR() >LPAR())var(process2)tt(RPAR() >/dev/null))
 
 cuts fields 1 and 3 from the files var(file1) and var(file2) respectively,
 pastes the results together, and sends it to the processes
@@ -427,9 +428,9 @@ the flags tt(M), tt(R), tt(B), tt(E) and tt(N) are not useful.
 
 For example,
 
-nofill(tt(foo="twinkle twinkle little star" sub="t*e" rep="spy")
-tt(print ${foo//${~sub}/$rep})
-tt(print ${(S)foo//${~sub}/$rep}))
+example(foo="twinkle twinkle little star" sub="t*e" rep="spy"
+print ${foo//${~sub}/$rep}
+print ${(S)foo//${~sub}/$rep})
 
 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
@@ -728,7 +729,7 @@ account of whether the current value is a scalar or an array, whether the
 whole substitution is in double quotes, and what flags are supplied to the
 current level of substitution, just as if the nested substitution were the
 outermost.  The flags are not propagated up to enclosing
-substitutions; the nested subsitution will return either a scalar or an
+substitutions; the nested substitution 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
@@ -1221,11 +1222,11 @@ matching the pattern var(foo).
 As a shorthand, `tt(**/)' is equivalent to `tt((*/)#)'.
 Thus:
 
-nofill(tt(ls (*/)#bar))
+example(ls (*/)#bar)
 
 or
 
-nofill(tt(ls **/bar))
+example(ls **/bar)
 
 does a recursive directory search for files named `tt(bar)', not following
 symbolic links.  To follow links, use `tt(***/)'.
@@ -1468,26 +1469,26 @@ name of any existing file can be followed by a modifier of the form
 `tt((:..))' even if no actual filename generation is performed.
 Thus:
 
-nofill(tt(ls *(-/)))
+example(ls *(-/))
 
 lists all directories and symbolic links that point to directories,
 and
 
-nofill(tt(ls *(%W)))
+example(ls *(%W))
 
 lists all world-writable device files in the current directory, and
 
-nofill(tt(ls *(W,X)))
+example(ls *(W,X))
 
 lists all files in the current directory that are
 world-writable or world-executable, and
 
-nofill(tt(echo /tmp/foo*(u0^@:t)))
+example(echo /tmp/foo*(u0^@:t))
 
 outputs the basename of all root-owned files beginning with the string
 `tt(foo)' in tt(/tmp), ignoring symlinks, and
 
-nofill(tt(ls *.*~(lex|parse).[ch](^D^l1)))
+example(ls *.*~(lex|parse).[ch](^D^l1))
 
 lists all files having a link count of one whose names contain a dot
 (but not those starting with a dot, since tt(GLOB_DOTS) is explicitly
diff --git a/Doc/Zsh/files.yo b/Doc/Zsh/files.yo
index 17b29677b..54fa800dc 100644
--- a/Doc/Zsh/files.yo
+++ b/Doc/Zsh/files.yo
@@ -26,7 +26,7 @@ tt($ZDOTDIR/.zlogin) are read.
 
 When a login shell exits, the files tt($ZDOTDIR/.zlogout) and then
 tt(/etc/zlogout) are read.  This happens with either an explicit exit
-via the tt(exit) or tt(logout) commands, or an implict exit by reading
+via the tt(exit) or tt(logout) commands, or an implicit 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.
diff --git a/Doc/Zsh/func.yo b/Doc/Zsh/func.yo
index c2fc71d55..0b32acc4a 100644
--- a/Doc/Zsh/func.yo
+++ b/Doc/Zsh/func.yo
@@ -5,7 +5,8 @@ sect(Functions)
 )\
 cindex(functions)
 findex(function)
-The tt(function) reserved word is used to define shell functions.
+Shell functions are defined with the tt(function) reserved word or the
+special syntax `var(funcname) tt(())'.
 Shell functions are read in and stored internally.
 Alias names are resolved when the function is read.
 Functions are executed like commands with the arguments
diff --git a/Doc/Zsh/grammar.yo b/Doc/Zsh/grammar.yo
index 51783dc70..80c132ab7 100644
--- a/Doc/Zsh/grammar.yo
+++ b/Doc/Zsh/grammar.yo
@@ -203,6 +203,11 @@ Normally, only one var(word) is provided; multiple var(word)s
 are usually only useful for setting traps.
 The body of the function is the var(list) between
 the tt({) and tt(}).  See noderef(Functions).
+
+If the option tt(SH_GLOB) is set for compatibility with other shells, then
+whitespace may appear between between the left and right parentheses when
+there is a single var(word);  otherwise, the parentheses will be treated as
+forming a globbing pattern in that case.
 )
 cindex(timing)
 item(tt(time) [ var(pipeline) ])(
diff --git a/Doc/Zsh/guide.yo b/Doc/Zsh/guide.yo
index f9c485875..d1f3e3aa9 100644
--- a/Doc/Zsh/guide.yo
+++ b/Doc/Zsh/guide.yo
@@ -28,7 +28,7 @@ menu(Parameters)
 menu(Options)
 menu(Shell Builtin Commands)
 menu(Zsh Line Editor)
-menu(Programmable Completion)
+menu(Programmable Completion Using compctl)
 menu(Completion Widgets)
 menu(Zsh Modules)
 menu(Completion System)
@@ -98,7 +98,7 @@ menu(Arguments)
 menu(Completion)
 menu(Miscellaneous)
 
-Programmable Completion
+Programmable Completion Using compctl
 
 menu(Command Flags)
 menu(Option Flags)
diff --git a/Doc/Zsh/jobs.yo b/Doc/Zsh/jobs.yo
index 752181f02..62e945f23 100644
--- a/Doc/Zsh/jobs.yo
+++ b/Doc/Zsh/jobs.yo
@@ -9,7 +9,7 @@ command, and assigns them small integer numbers.
 When a job is started asynchronously with `tt(&)',
 the shell prints a line which looks like:
 
-nofill(tt([1] 1234))
+example([1] 1234)
 
 indicating that the job which was started asynchronously was job number
 1 and had one (top-level) process, whose process ID was 1234.
diff --git a/Doc/Zsh/metafaq.yo b/Doc/Zsh/metafaq.yo
index 569d91716..c8273da47 100644
--- a/Doc/Zsh/metafaq.yo
+++ b/Doc/Zsh/metafaq.yo
@@ -12,7 +12,7 @@ cindex(author)
 Zsh was originally written by Paul Falstad tt(<pf@zsh.org>).
 Zsh is now maintained by the members of the zsh-workers mailing
 list tt(<zsh-workers@sunsite.auc.dk>).  The development is currently
-coordinated by Andrew Main (Zefram) tt(<zefram@zsh.org>).  The coordinator
+coordinated by Peter Stephenson tt(<pws@zsh.org>).  The coordinator
 can be contacted at tt(<coordinator@zsh.org>), but matters relating to
 the code should generally go to the mailing list.
 texinode(Availability)(Mailing Lists)(Author)(Introduction)
diff --git a/Doc/Zsh/mod_compctl.yo b/Doc/Zsh/mod_compctl.yo
index cfd615b2d..91f6112ee 100644
--- a/Doc/Zsh/mod_compctl.yo
+++ b/Doc/Zsh/mod_compctl.yo
@@ -3,7 +3,7 @@ sect(The compctl Module)
 The tt(compctl) module makes available several builtin commands. tt(compctl),
 is the standard way to control completions for ZLE.  See
 ifzman(zmanref(zshcompctl))\
-ifnzman(noderef(Programmable Completion))\
+ifnzman(noderef(Programmable Completion Using compctl))\
 .
 The other builtin commands can be used in user-defined completion widgets,
 see
diff --git a/Doc/Zsh/mod_mapfile.yo b/Doc/Zsh/mod_mapfile.yo
index 6d0475711..e6c388823 100644
--- a/Doc/Zsh/mod_mapfile.yo
+++ b/Doc/Zsh/mod_mapfile.yo
@@ -34,11 +34,13 @@ handled, zsh's internal memory management may be arbitrarily baroque.  Thus
 it should not automatically be assumed that use of tt(mapfile) represents a
 gain in efficiency over use of other mechanisms.  Note in particular that
 the whole contents of the file will always reside physically in memory when
-accessed (possibly multiple times, due to standard parameter subsitution
-operations).
+accessed (possibly multiple times, due to standard parameter substitution
+operations).  In particular, this means handling of sufficiently long files
+(greater than the machine's swap space, or than the range of the pointer
+type) will be incorrect.
 
 No errors are printed or flagged for non-existent, unreadable, or
-unwriteable files, as the parameter mechanism is too low in the shell
+unwritable files, as the parameter mechanism is too low in the shell
 execution hierarchy to make this convenient.
 
 It is unfortunate that the mechanism for loading modules does not yet allow
diff --git a/Doc/Zsh/mod_zftp.yo b/Doc/Zsh/mod_zftp.yo
index ec16aa531..7b64882b4 100644
--- a/Doc/Zsh/mod_zftp.yo
+++ b/Doc/Zsh/mod_zftp.yo
@@ -80,7 +80,7 @@ will be deleted if the tt(zftp) module is unloaded.
 
 For example,
 
-nofill(tt(zftp params ftp.elsewhere.xx juser '?'))
+example(zftp params ftp.elsewhere.xx juser '?')
 
 will store the host tt(ftp.elsewhere.xx) and the user tt(juser) and
 then prompt the user for the corresponding password.
@@ -89,8 +89,8 @@ This command may also be used to set up a transfer which then takes
 place completely in the background, freeing tt(zftp) for concurrent
 foreground use.  For example,
 
-nofill(tt(zftp params ftp.soreeyes.ca bubble squeak))
-nofill(tt(LPAR()zftp open; zftp get foo >bar; zftp close)tt(RPAR() &))
+example(zftp params ftp.soreeyes.ca bubble squeak
+(zftp open; zftp get foo >bar; zftp close) &)
 
 --- here, the connection is restricted to a background subshell and
 you are free to open a simultaneous connection in the foreground.
@@ -110,7 +110,7 @@ supported on this system) is printed instead.
 
 It is useful to put the code
 
-nofill(tt([[ -n $ZFTP_HOST ]] && zftp test))
+example([[ -n $ZFTP_HOST ]] && zftp test)
 
 into the shell function tt(precmd) for testing the connection before
 every prompt.  However, tt(zftp) will call tt(test) at the start of any
@@ -209,7 +209,7 @@ item(tt(mkdir) var(directory))(
 Create a new directory var(directory) on the server.
 )
 item(tt(rmdir) var(directory))(
-Delete the diretory var(directory)  on the server.
+Delete the directory var(directory)  on the server.
 )
 item(tt(rename) var(old-name) var(new-name))(
 Rename file var(old-name) to var(new-name) on the server.
@@ -221,7 +221,7 @@ only need this if instructed by the server to use it.
 item(tt(quote) var(args...))(
 Send the raw FTP command sequence to the server.  You should be
 familiar with the FTP command set as defined in RFC959 before doing
-this.  Useful comands may include tt(STAT) and tt(HELP).  Note also
+this.  Useful commands may include tt(STAT) and tt(HELP).  Note also
 the mechanism for returning messages as described for the variable
 tt(ZFTP_VERBOSE) below, in particular that all messages from the
 control connection are sent to standard error.
@@ -335,7 +335,7 @@ digit reply code is defined by RFC959 to correspond to:
 
 startitem()
 item(1.)(
-A positive prelimnary reply.
+A positive preliminary reply.
 )
 item(2.)(
 A positive completion reply.
@@ -442,7 +442,7 @@ until the next call to tt(zftp).  Other status changes in subshells
 will not be reflected by changes to the variables (but should
 be otherwise harmless).
 
-On some operatings systems, the control connection is not valid after a
+On some operating systems, the control connection is not valid after a
 fork(), so that operations in subshells or on the left hand side of a
 pipeline are not possible.
 
diff --git a/Doc/Zsh/params.yo b/Doc/Zsh/params.yo
index bfb2238ed..be820f160 100644
--- a/Doc/Zsh/params.yo
+++ b/Doc/Zsh/params.yo
@@ -16,7 +16,7 @@ To assign an array value, use `tt(set -A) var(name) var(value) ...'.
 findex(set, use of)
 The value of a parameter may also be assigned by writing:
 
-nofill(var(name)tt(=)var(value))
+indent(var(name)tt(=)var(value))
 
 If the integer attribute, tt(-i), is set for var(name), the var(value)
 is subject to arithmetic evaluation.  See noderef(Array Parameters)
@@ -38,19 +38,19 @@ texinode(Array Parameters)(Positional Parameters)()(Parameters)
 sect(Array Parameters)
 The value of an array parameter may be assigned by writing:
 
-nofill(var(name)tt(=LPAR())var(value) ...tt(RPAR()))
+indent(var(name)tt(=LPAR())var(value) ...tt(RPAR()))
 
 If no parameter var(name) exists, an ordinary array parameter is created.
 Associative arrays must be declared first, by `tt(typeset -A) var(name)'.
 When var(name) refers to an associative array, the parenthesized list is
 interpreted as alternating keys and values:
 
-nofill(var(name)tt(=LPAR())var(key) var(value) ...tt(RPAR()))
+indent(var(name)tt(=LPAR())var(key) var(value) ...tt(RPAR()))
 
 Every var(key) must have a var(value) in this case.  To create an empty
 array or associative array, use:
 
-nofill(var(name)tt(=LPAR()RPAR()))
+indent(var(name)tt(=LPAR()RPAR()))
 
 Individual elements of an array may be selected using a
 subscript.  A subscript of the form `tt([)var(exp)tt(])'
@@ -59,6 +59,7 @@ an arithmetic expression which will be subject to arithmetic
 expansion as if it were surrounded by `tt($LPAR()LPAR())...tt(RPAR()RPAR())'.
 The elements are numbered beginning with 1 unless the
 tt(KSH_ARRAYS) option is set when they are numbered from zero.
+cindex(subscripts)
 pindex(KSH_ARRAYS, use of)
 
 The same subscripting syntax is used for associative arrays,
@@ -72,9 +73,8 @@ except when they appear within double quotes.
 
 A subscript of the form `tt([)var(exp1)tt(,)var(exp2)tt(])'
 selects all elements in the range var(exp1) to var(exp2),
-inclusive.
-(Associative arrays are unordered, and so do not support ranges.)
-If one of the subscripts evaluates to a negative number,
+inclusive. (Associative arrays are unordered, and so do not support
+ranges.) If one of the subscripts evaluates to a negative number,
 say tt(-)var(n), then the var(n)th element from the end
 of the array is used.  Thus `tt($foo[-3])' is the third element
 from the end of the array tt(foo), and
@@ -95,7 +95,7 @@ element or range is replaced by the expression on the right side.  An
 array (but not an associative array) may be created by assignment to a
 range or element.  Arrays do not nest, so assigning a parenthesized list
 of values to an element or range changes the number of elements in the
-array, shifting the other elements to accomodate the new values.  (This
+array, shifting the other elements to accommodate the new values.  (This
 is not supported for associative arrays.)
 
 To delete an element of an ordinary array, assign `tt(LPAR()RPAR())' to
@@ -180,7 +180,7 @@ values) any of the positions from 1 to var(n) that do not already have
 values.  Note that, because the positional parameters form an array, an
 array assignment of the form `var(n)tt(=LPAR())var(value) ...tt(RPAR())' is
 allowed, and has the effect of shifting all the values at positions greater
-than var(n) by as many positions as necessary to accomodate the new values.
+than var(n) by as many positions as necessary to accommodate the new values.
 
 texinode(Local Parameters)(Parameters Set By The Shell)(Positional Parameters)(Parameters)
 sect(Local Parameters)
diff --git a/Doc/Zsh/redirect.yo b/Doc/Zsh/redirect.yo
index b642f1b5f..b44b07e63 100644
--- a/Doc/Zsh/redirect.yo
+++ b/Doc/Zsh/redirect.yo
@@ -107,7 +107,7 @@ The shell evaluates each redirection in terms of the
 association at the time of evaluation.
 For example:
 
-nofill(... tt(1>)var(fname) tt(2>&1))
+indent(... tt(1>)var(fname) tt(2>&1))
 
 first associates file descriptor 1 with file var(fname).
 It then associates file descriptor 2 with the file associated with file
@@ -123,12 +123,12 @@ the shell opens the file descriptor as a pipe to a process that copies
 its input to all the specified outputs, similar to bf(tee),
 provided the tt(MULTIOS) option is set.  Thus:
 
-nofill(tt(date >foo >bar))
+example(date >foo >bar)
 
 writes the date to two files, named `tt(foo)' and `tt(bar)'.
 Note that a pipe is an implicit redirection; thus
 
-nofill(tt(date >foo | cat))
+example(date >foo | cat)
 
 writes the date to the file `tt(foo)', and also pipes it to cat.
 
@@ -136,14 +136,14 @@ If the tt(MULTIOS)
 option is set, the word after a redirection operator is also subjected
 to filename generation (globbing).  Thus
 
-nofill(tt(: > *))
+example(: > *)
 
 will truncate all files in the current directory,
 assuming there's at least one.  (Without the tt(MULTIOS)
 option, it would create an empty file called `tt(*)'.)
 Similarly, you can do
 
-nofill(tt(echo exit 0 >> *.sh))
+example(echo exit 0 >> *.sh)
 
 If the user tries to open a file descriptor for reading more than once,
 the shell opens the file descriptor as a pipe to a process that copies
@@ -151,17 +151,17 @@ all the specified inputs to its output in the order
 specified, similar to bf(cat),
 provided the tt(MULTIOS) option is set.  Thus
 
-nofill(tt(sort <foo <fubar))
+example(sort <foo <fubar)
 
 or even
 
-nofill(tt(sort <f{oo,ubar}))
+example(sort <f{oo,ubar})
 
 is equivalent to `tt(cat foo fubar | sort)'.
 
 Note that a pipe is an implicit redirection; thus
 
-nofill(tt(cat bar | sort <foo))
+example(cat bar | sort <foo)
 
 is equivalent to `tt(cat bar foo | sort)' (note the order of the inputs).
 
@@ -169,7 +169,7 @@ If the tt(MULTIOS) option is em(un)set,
 each redirection replaces the previous redirection for that file descriptor.
 However, all files redirected to are actually opened, so
 
-nofill(tt(echo foo > bar > baz))
+example(echo foo > bar > baz)
 
 when tt(MULTIOS) is unset will truncate bar, and write `tt(foo)' into baz.
 
@@ -178,6 +178,6 @@ and zero or more parameter assignments, but no command name,
 the command named in the shell variable tt(READNULLCMD) is assumed.
 (If tt(READNULLCMD) is empty or not set, `tt(cat)' is used.)  Thus
 
-nofill(tt(< file))
+example(< file)
 
 copies the contents of tt(file) to the standard output.
diff --git a/Doc/Zsh/zftpsys.yo b/Doc/Zsh/zftpsys.yo
index 6983dedb9..60f5be60d 100644
--- a/Doc/Zsh/zftpsys.yo
+++ b/Doc/Zsh/zftpsys.yo
@@ -8,7 +8,7 @@ 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
 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,
+within the shell all the familiar completion, editing and globbing features,
 and so on, are present, and macros are particularly simple to write as they
 are just ordinary shell functions.
 
@@ -45,21 +45,22 @@ 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)
-))
+appear as one of the elements of the tt($fpath) array (this should already
+be the case if they were installed), and at least the function tt(zfinit)
+should be autoloaded; it will autoload the rest.  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):
+
+example(fpath=(~/myfns $fpath)
+autoload zfinit
+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).
+tt(zfinit) to tt(zfinit -n).  It is helpful (though not essential) if the
+call to tt(zfinit) appears after any code to initialise the new completion
+system, else unnecessary tt(compctl) commands will be given.
 
 texinode(Zftp Functions)(Miscellaneous Features)(Installation)(Zftp Function System)
 sect(Functions)
@@ -115,7 +116,7 @@ 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)
+non-UNIX servers (note this is handled internally by tt(zftp)).  If var(dir)
 is omitted, has the effect of `tt(zfcd ~)'.
 
 The second form changes to the directory previously current.
@@ -274,13 +275,48 @@ then tt(zfpcp) will retry using the second form.
 )
 enditem()
 
-subsect(Closing the connectino)
+subsect(Closing the connection)
 startitem()
 item(tt(zfclose))(
 Close the connection.
 )
 enditem()
 
+subsect(Bookmarks)
+The two functions tt(zfmark) and tt(zfgoto) allow you to `bookmark' the
+present location (host, user and directory) of the current FTP connection
+for later use.  The file to be used for storing and retrieving bookmarks is
+given by the parameter tt($ZFTP_BMFILE); if not set when one of the two
+functions is called, it will be set to the file tt(.zfbfmarks) in the
+directory where your zsh startup files live (usually tt(~)).
+
+startitem()
+item(tt(zfmark [ )var(bookmark)tt( ]))(
+If given an argument, mark the current host, user and directory under the
+name var(bookmark) for later use by tt(zfgoto).  If there is no connection
+open, use the values for the last connection immediately before it was
+closed; it is an error if there is none.  Any existing bookmark
+under the same name will be silently replaced.
+
+If not given an argument, list the existing bookmarks and the points to
+which they refer in the form var(user)tt(@)var(host)tt(:)var(directory).
+)
+item(tt(zfgoto [ -n ] )var(bookmark))(
+Return to the location given by var(bookmark), as previously set by
+tt(zfmark).  If the location has user `tt(ftp)' or `tt(anonymous)', open
+the connection with tt(zfanon), so that no password is required.  If the
+user and host parameters match those currently stored, those will be used,
+and again no password is required.  Otherwise a password will be prompted
+for.
+
+With the option tt(-n), the bookmark is taken to be a nickname stored by
+the tt(ncftp) program in its bookmark file, which is assumed to be
+tt(~/.ncftp/bookmarks).  The function works identically in other ways.
+Note that there is no mechanism for adding or modifying tt(ncftp) bookmarks
+from the zftp functions.
+)
+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
@@ -288,7 +324,7 @@ 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.
+As described 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.
 )
@@ -320,7 +356,7 @@ 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
+were any matches, the same variable will be set to the expanded set of
 filenames on return.
 )
 item(tt(zfrtime var(lfile) var(rfile) [ var(time) ]))(
@@ -339,15 +375,13 @@ 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(})
-))
+example(chpwd() {
+  if [[ -n $ZFTP_USER ]]; then
+    zftp_chpwd
+  else
+    # usual chpwd e.g put host:directory in title bar
+  fi
+})
 
 fits in well.
 )
@@ -378,7 +412,7 @@ 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.
+directory without an intervening 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
@@ -415,10 +449,8 @@ 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)
-))
+example(Not connected.
+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
@@ -427,9 +459,9 @@ 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
+Completion of remote files, directories and bookmarks 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.
diff --git a/Doc/Zsh/zle.yo b/Doc/Zsh/zle.yo
index c4809b02d..743fb7f93 100644
--- a/Doc/Zsh/zle.yo
+++ b/Doc/Zsh/zle.yo
@@ -1,4 +1,4 @@
-texinode(Zsh Line Editor)(Programmable Completion)(Shell Builtin Commands)(Top)
+texinode(Zsh Line Editor)(Programmable Completion Using compctl)(Shell Builtin Commands)(Top)
 chapter(Zsh Line Editor)
 cindex(line editor)
 cindex(editor, line)
@@ -83,7 +83,7 @@ simply to perform some small action.  The ZLE commands that key sequences
 in keymaps are bound to are in fact widgets.  Widgets can be user-defined
 or built in.
 
-There are 162 standard widgets built in to ZLE (see sectref(Standard Widgets)).
+There are 162 standard widgets built in to ZLE (see Standard Widgets below).
 Other built-in widgets can be defined by other modules (see
 ifzman(zmanref(zshmodules))\
 ifnzman(noderef(Zsh Modules))\
@@ -157,7 +157,7 @@ vindex(keys)
 item(tt(keys) (array))(
 The keys typed to invoke this widget, one element per
 key. Control-keys are reported with a leading `tt(^)', as in `tt(^A)',
-and meta-keys are repoted with a leading `tt(M-)', as in `tt(M-a)' and 
+and meta-keys are reported with a leading `tt(M-)', as in `tt(M-a)' and 
 `tt(M-^A)'.
 )
 vindex(NUMERIC)
diff --git a/Doc/zman.yo b/Doc/zman.yo
index 7d7fc120e..657e046a6 100644
--- a/Doc/zman.yo
+++ b/Doc/zman.yo
@@ -162,6 +162,12 @@ def(itemiz)(1)(\
 
 COMMENT(--- special effects ---)
 
+def(example)(1)(\
+  NOTRANS(.RS)NL()NOTRANS(.nf)NL()\
+  NOTRANS(\fB)ARG1NOTRANS(\fP)\
+  NL()NOTRANS(.fi)NL()NOTRANS(.RE)\
+)
+
 def(nofill)(1)(\
   NOTRANS(.nf)NL()\
   ARG1\
@@ -169,9 +175,9 @@ def(nofill)(1)(\
 )
 
 def(indent)(1)(\
-  NOTRANS(.RS)\
+  NOTRANS(.RS)NL()NOTRANS(.nf)NL()\
   ARG1\
-  NOTRANS(.RE)\
+  NL()NOTRANS(.fi)NL()NOTRANS(.RE)\
 )
 
 COMMENT(--- hyperlink menus ---)
diff --git a/Doc/zsh.yo b/Doc/zsh.yo
index 98cb9e340..b9279e660 100644
--- a/Doc/zsh.yo
+++ b/Doc/zsh.yo
@@ -17,7 +17,7 @@ def(ifzshall)(1)()\
 )\
 ifztexi(\
 texinfo(zsh.info)(zsh)
-NOTRANS(@setchapternewpage odd
+NOTRANS(@setchapternewpage off
 @iftex
 @finalout
 @afourpaper
diff --git a/Doc/ztexi.yo b/Doc/ztexi.yo
index 231a70b84..c3c1928cf 100644
--- a/Doc/ztexi.yo
+++ b/Doc/ztexi.yo
@@ -11,7 +11,7 @@ def(CMT)(0)(NOTRANS(@c))
 
 ATEXIT(\
   NL()\
-  NOTRANS(@setchapternewpage odd)NL()\
+  NOTRANS(@setchapternewpage off)NL()\
   NOTRANS(@contents)NL()\
   NOTRANS(@bye)NL()\
 )
@@ -207,8 +207,16 @@ def(nofill)(1)(\
   USECHARTABLE(standard)\
 )
 
+def(example)(1)(\
+  NOTRANS(@example)NL()\
+  ARG1\
+  NL()NOTRANS(@end example)\
+)
+
 def(indent)(1)(\
+  NOTRANS(@display)NL()\
   ARG1\
+  NL()NOTRANS(@end display)\
 )
 
 COMMENT(--- hyperlink menus ---)