Spelling corrections in the docs (11315)

16 files changed, 247 insertions, 65 deletions

diff --git a/ChangeLog b/ChangeLog
index 8418c9bd4..72e96753c 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,6 +1,13 @@
 2000-05-11  Oliver Kiddle  <opk@zsh.org>
 
-	* 11xxx: Src/params.c: remove return value from uniqarray which
+	* 11315: Doc/Zsh/builtins.yo, Doc/Zsh/compsys.yo, Doc/Zsh/compwid.yo,
+	Doc/Zsh/expn.yo, Doc/Zsh/grammar.yo, Doc/Zsh/mod_complist.yo,
+	Doc/Zsh/mod_computil.yo, Doc/Zsh/mod_deltochar.yo,
+	Doc/Zsh/mod_mathfunc.yo, Doc/Zsh/mod_parameter.yo, Doc/Zsh/mod_zle.yo,
+	Doc/Zsh/mod_zutil.yo, Doc/Zsh/options.yo, Doc/Zsh/params.yo,
+	Doc/Zsh/zftpsys.yo: Fix spelling in docs
+
+	* 11316: Src/params.c: remove return value from uniqarray which
 	caused a compiler error on IRIX
 
 2000-05-10  Peter Stephenson  <pws@pwstephenson.fsnet.co.uk>
diff --git a/Doc/Zsh/builtins.yo b/Doc/Zsh/builtins.yo
index a65ff4717..3ab87ece8 100644
--- a/Doc/Zsh/builtins.yo
+++ b/Doc/Zsh/builtins.yo
@@ -104,7 +104,7 @@ the function be loaded using ksh-style or zsh-style autoloading,
 respectively. If neither is given, the current setting of the
 tt(KSH_AUTOLOAD) options determines how the function is loaded. With
 ksh-style autoloading, the contents of the file will not be executed
-immediatly. Instead, the function created will contain the contents of 
+immediately. Instead, the function created will contain the contents of 
 the file plus a call to the function itself appended to it, thus given 
 normal ksh autoloading behaviour on the first call to the function.
 
diff --git a/Doc/Zsh/compsys.yo b/Doc/Zsh/compsys.yo
index b345b8d42..395121f31 100644
--- a/Doc/Zsh/compsys.yo
+++ b/Doc/Zsh/compsys.yo
@@ -713,7 +713,7 @@ for makefile targets
 )
 kindex(types, completion tag)
 item(tt(types))(
-for types of whatever (e.g. adress types for the tt(xhost) command)
+for types of whatever (e.g. address types for the tt(xhost) command)
 )
 kindex(urls, completion tag)
 item(tt(urls))(
@@ -2596,13 +2596,13 @@ and, if there is at least one, zero is returned. If no more tag
 labels are to be used, a non-zero status is returned.
 
 The tt(-12JV) options and the first three arguments are given to the
-tt(_desciption) function using the tag label instead of the first
+tt(_description) function using the tag label instead of the first
 argument as appropriate. The var(options) given after the var(descr)
 should be other options to be used for tt(compadd) or whatever
 function is to be called to add the matches. tt(_next_label) will store these 
 var(options) in the parameter whose var(name) is given as the second
 argument. This is done in such a way that the description given by the 
-user to the tt(tag-order) style is prefered over the one given to
+user to the tt(tag-order) style is preferred over the one given to
 tt(_next_label).
 
 Note that this function must not be called without a previous call to
@@ -2675,7 +2675,7 @@ If the var(name) and the var(descr) are given, tt(_requested) calls the
 tt(_description) function with these arguments, including the options.
 
 If the var(command) is given, the tt(_all_labels) function will be called
-immediatly with the same arguments.
+immediately with the same arguments.
 
 This is often useful to do both the testing of the tag,
 getting the description for the matches and adding the matches at
@@ -3292,7 +3292,7 @@ specified so that it will not be completed automatically. The
 `tt((two))' at the beginning says that if the value `tt(one)' is on
 the line, the value `tt(two)' will not be  considered to be a possible
 completion anymore. Finally, the last value (`tt(two)') is described
-as `tt(another number)' and gets an optional argument decribed as
+as `tt(another number)' and gets an optional argument described as
 `tt(second count)' which will be completed from the strings `tt(1)',
 `tt(2)', and `tt(3)'. The tt(_values) function will complete lists of
 these values separated by commas.
@@ -3332,7 +3332,7 @@ remaining arguments specify a completion as a set of regular
 expressions with actions.  The generated function has the structure of a
 finite-state machine whose states corresponds to the state (i.e. the
 context) of the completion. This state machine uses a command line,
-which comes from concatentating the tt(words) array up to the current
+which comes from concatenating the tt(words) array up to the current
 cursor position using null characters as separators with no extra
 quotation.  This is analysed and at the end the appropriate action is
 executed.
diff --git a/Doc/Zsh/compwid.yo b/Doc/Zsh/compwid.yo
index bb283ffed..957cb0bf9 100644
--- a/Doc/Zsh/compwid.yo
+++ b/Doc/Zsh/compwid.yo
@@ -282,7 +282,7 @@ option being set); if set to tt(menu) or tt(automenu) menucompletion
 will be started for the matches currently generated (in the
 latter case this will happen because the tt(AUTO_MENU) is set). The
 value may also contain the string `tt(tab)' when the completion code
-woul normally not really do completion, but only insert the TAB
+would normally not really do completion, but only insert the TAB
 character.
 
 On exit it may be set to any of the values above (where setting it to
diff --git a/Doc/Zsh/expn.yo b/Doc/Zsh/expn.yo
index 5d9b20974..bea2888bc 100644
--- a/Doc/Zsh/expn.yo
+++ b/Doc/Zsh/expn.yo
@@ -102,7 +102,7 @@ nearest other history reference preceding them on the current command
 line, or to the previous command if there is no preceding reference.
 
 The character sequence `tt(^)var(foo)tt(^)var(bar)' (where `tt(^)' is
-actually the second charcter of the tt(histchars) parameter)
+actually the second character of the tt(histchars) parameter)
 repeats the last command, replacing the string var(foo) with var(bar).
 More precisely, the sequence `tt(^)var(foo)tt(^)var(bar)tt(^)' is
 synonymous with `tt(!!:s)tt(^)var(foo)tt(^)var(bar)tt(^)', hence other
diff --git a/Doc/Zsh/grammar.yo b/Doc/Zsh/grammar.yo
index c78aed4b4..3325e2185 100644
--- a/Doc/Zsh/grammar.yo
+++ b/Doc/Zsh/grammar.yo
@@ -25,6 +25,11 @@ If a command name is given, the parameter assignments modify
 the environment of the command when it is executed.
 The value of a simple command is its exit status,
 or 128 plus the signal number if terminated by a signal.
+For example,
+
+example(echo foo)
+
+is a simple command with arguments.
 
 cindex(pipeline)
 A em(pipeline) is either a simple command, or a sequence of two or more
@@ -37,6 +42,12 @@ command to the standard input of the next.  The value of a pipeline
 is the value of the last command, unless the pipeline is preceded by
 `tt(!)' in which case the value is the logical inverse of the value of the
 last command.
+For example,
+
+example(echo foo | sed 's/foo/bar/')
+
+is a pipeline, where the output (`tt(foo)' plus a newline) of the first
+command will be passed to the input of the second.
 
 findex(coproc)
 cindex(coprocess)
@@ -45,6 +56,8 @@ a two-way pipe is established between it and the parent shell.  The
 shell can read from or write to the coprocess by means of the `tt(>&p)'
 and `tt(<&p)' redirection operators or with `tt(print -p)' and `tt(read -p)'.
 A pipeline cannot be preceded by both `tt(coproc)' and `tt(!)'.
+If job control is active, the coprocess can be treated in other than input
+and output as an ordinary background job.
 
 cindex(sublist)
 A em(sublist) is either a single pipeline, or a sequence of two or more
@@ -54,6 +67,14 @@ by `tt(&&)', the second pipeline is executed only if the first succeeds
 second is executed only if the first fails (returns a nonzero value).
 Both operators have equal precedence and are left associative.
 The value of the sublist is the value of the last pipeline executed.
+For example,
+
+example(dmesg | grep panic && print yes)
+
+is a sublist consisting of two pipelines, the second just a simple command
+which will be executed if and only if the tt(grep) command returns a zero
+value.  If it does not, the value of the sublist is that return value, else
+it is the value returned by the tt(print) (almost certainly zero).
 
 cindex(list)
 A em(list) is a sequence of zero or more sublists, in which each sublist
@@ -65,9 +86,15 @@ or `tt({)...tt(})'.  When a
 sublist is terminated by `tt(;)' or newline, the shell waits for it to
 finish before executing the next sublist.  If a sublist is terminated
 by a `tt(&)', `tt(&|)', or `tt(&!)',
-the shell executes it in the background, and
-does not wait for it to finish.
-A backgrounded sublist returns a status of zero.
+the shell executes the last pipeline in it in the background, and
+does not wait for it to finish (note the difference from other shells
+which execute the whole sublist in the background).
+A backgrounded pipeline returns a status of zero.
+
+More generally, a list can be seen as a set of any shell commands
+whatsoever, including the complex commands below; this is implied wherever
+the word `list' appears in later descriptions.  For example, the commands
+in a shell function form a special sort of list.
 texinode(Precommand Modifiers)(Complex Commands)(Simple Commands & Pipelines)(Shell Grammar)
 sect(Precommand Modifiers)
 cindex(precommand modifiers)
@@ -87,7 +114,9 @@ Filename generation (globbing) is not performed on any of
 the words.
 )
 item(tt(nocorrect))(
-Spelling correction is not done on any of the words.
+Spelling correction is not done on any of the words.  This must appear
+before any other precommand modifier, as it is interpreted immediately,
+before any parsing is done.  It has no effect in non-interactive shells.
 )
 item(tt(exec))(
 The command is executed in the parent shell without forking.
@@ -173,12 +202,13 @@ findex(select)
 cindex(user selection)
 cindex(selection, user)
 item(tt(select) var(name) [ tt(in) var(word) ... var(term) ] tt(do) var(list) tt(done))(
-where var(term) is one ore more newline or tt(;).
+where var(term) is one or more newline or tt(;) to terminate the var(word)s.
 Print the set of var(word)s, each preceded by a number.
 If the tt(in) var(word) is omitted, use the positional parameters.
-The tt(PROMPT3) prompt is printed and a line is read from standard
-input.  If this line consists of the number of one of the listed
-var(word)s, then the parameter var(name)
+The tt(PROMPT3) prompt is printed and a line is read from the line editor
+if the shell is interactive and that is active, or else standard input.
+If this line consists of the
+number of one of the listed var(word)s, then the parameter var(name)
 is set to the var(word) corresponding to this number.
 If this line is empty, the selection list is printed again.
 Otherwise, the value of the parameter var(name) is set to null.
@@ -203,6 +233,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) ])(
@@ -229,11 +264,26 @@ versions of complex commands should be considered deprecated and may be
 removed in the future.  The versions in the previous section should be
 preferred instead.  The short versions below only work if var(sublist)
 is of the form `tt({) var(list) tt(})' or if the tt(SHORT_LOOPS)
-option is set.
+option is set.  In this case, the test part of the loop must also be
+suitably delimited, such as by `tt([[ ... ]])' or `tt((( ... )))', else
+the end of the test will not be recognized.
 
 startitem()
 item(tt(if) var(list) tt({) var(list) tt(}) [ tt(elif) var(list) tt({) var(list) tt(}) ] ... [ tt(else {) var(list) tt(}) ])(
-An alternate form of tt(if).
+An alternate form of tt(if).  The rules mean that
+
+example(if [[ -o ignorebraces ]] {
+  print yes
+})
+
+works, but
+
+example(if true {  # Does not work!
+  print yes
+}
+)
+
+does em(not), since the test is not suitably delimited.
 )
 item(tt(if) var(list) var(sublist))(
 A short form of the alternate `if'.
@@ -307,9 +357,9 @@ cindex(aliases, global)
 An alias is defined using the tt(alias) builtin; global aliases
 may be defined using the tt(-g) option to that builtin.
 
-Alias substitution is done on the shell input before any
-other substitution except history substitution.  Therefore,
-if an alias is defined for the word tt(foo), alias substitution
+Alias expansion is done on the shell input before any
+other expansion except history expansion.  Therefore,
+if an alias is defined for the word tt(foo), alias expansion
 may be avoided by quoting part of the word, e.g. tt(\foo).
 But there is nothing to prevent an alias being defined
 for tt(\foo) as well.
@@ -328,7 +378,13 @@ string by using the `tt(\')' escape.
 
 All characters enclosed between a pair of single quotes (tt('')) that
 is not preceded by a `tt($)' are quoted.  A single quote cannot appear
-within single quotes.
+within single quotes unless the option tt(RC_QUOTES) is set, in which case
+a pair of single quotes are turned into a single quote.  For example,
+
+example(print '''')
+
+outputs nothing apart from a newline if tt(RC_QUOTES) is not set, but one
+single quote if it is set.
 
 Inside double quotes (tt("")), parameter and
 command substitution occurs, and `tt(\)' quotes the characters
diff --git a/Doc/Zsh/mod_complist.yo b/Doc/Zsh/mod_complist.yo
index ac0fdc252..5dd84310d 100644
--- a/Doc/Zsh/mod_complist.yo
+++ b/Doc/Zsh/mod_complist.yo
@@ -212,7 +212,7 @@ control sequence as for the `tt(%S)' escape in prompts is used.
 
 If there are more matches than fit on the screen and the parameter
 tt(MENUPROMPT) is set, its value will be shown below the matches. It
-supports the sames escape sequences as tt(LISTPROMPT), but the number
+supports the same escape sequences as tt(LISTPROMPT), but the number
 of the match or line shown will be that of the one where the mark is
 placed. If its value is the empty string, a default prompt will be
 used.
@@ -316,7 +316,7 @@ xitem(tt(complete-word), tt(menu-complete), tt(expand-or-complete))
 item(tt(expand-or-complete-prefix), tt(menu-expand-or-complete))(
 moves the mark to the next match
 )
-item(tt(reverse-menu-omplete))(
+item(tt(reverse-menu-complete))(
 moves the mark to the previous match
 )
 enditem()
diff --git a/Doc/Zsh/mod_computil.yo b/Doc/Zsh/mod_computil.yo
index fc1959bf1..00a9c4d49 100644
--- a/Doc/Zsh/mod_computil.yo
+++ b/Doc/Zsh/mod_computil.yo
@@ -1,31 +1,36 @@
-texinode(The computil Module)(The deltochar Module)(The complist Module)(Zsh Modules)
-sect(The computil Module)
+COMMENT(!MOD!zsh/computil
+A module with utility builtins needed for the shell function based
+completion system.
+!MOD!)
 cindex(completion, utility)
-The tt(computil) module adds four builtin commands that are used by
+The tt(zsh/computil) module adds several builtin commands that are used by
 some of the completion functions in the shell function based
 completions system (see
 ifzman(zmanref(zshcompsys))\
 ifnzman(noderef(Completion System))
-). Except for tt(compdisplay) these builtin commands are very
+). Except for tt(compquote) these builtin commands are very
 specialised and thus not very interesting when writing your own
 completion functions. In short, these builtin commands are:
 
 startitem()
-item(tt(compdisplay) var(name) var(string) var(defs) ...)(
-The var(defs) are strings should be of the form
-`var(str)tt(:)var(descr)' (the intended use is that the var(descr)
-describes the var(str)) and tt(compdisplay) will convert them to
-strings in which the colon is replaced by the var(string) given as the 
-second argument and spaces are inserted before that so that they are
-aligned over all strings. These resultings strings are then assigned
-to an array with the var(name) given as the first argument.
+item(tt(compquote) var(names) ...)(
+There may be reasons to write completion functions that have to add
+the matches using the tt(-Q) option to tt(compadd) and do the quoting
+themselves. Instead of interpreting the first character of the
+tt(all_quotes) key of the tt(compstate) special association and using
+the tt(q) flag for parameter expansions, one can use this builtin
+command. The arguments are the names of scalar or array parameters
+and the values of these parameters are quoted as needed for the
+innermost quoting level.
+
+The return value is non-zero in case of an error and zero otherwise.
 )
 item(tt(compdescribe))(
 This is used by the tt(_describe) function to build the displays for
 the matches and to get the strings to add as matches with their
 options. The first call has to give the tt(-i) or tt(-I) option as the 
 first argument. In the first case, display strings without the
-descriptions will be generated, inthe second case, the string used to
+descriptions will be generated, in the second case, the string used to
 separate the matches from their descriptions has to be given as the
 second argument and the descriptions (if any) will be shown. All other 
 arguments are like the definition arguments to tt(_describe) itself.
@@ -48,4 +53,7 @@ to access the state information to decide what should be completed.
 item(tt(compvalues))(
 Like tt(comparguments), but for the tt(_values) function.
 )
+item(tt(comptags), tt(comptry))(
+This implements the internals of the tags mechanism.
+)
 enditem()
diff --git a/Doc/Zsh/mod_deltochar.yo b/Doc/Zsh/mod_deltochar.yo
index f92a3da0d..6f0461d43 100644
--- a/Doc/Zsh/mod_deltochar.yo
+++ b/Doc/Zsh/mod_deltochar.yo
@@ -1,6 +1,7 @@
-texinode(The deltochar Module)(The example Module)(The compctl Module)(Zsh Modules)
-sect(The deltochar Module)
-The tt(deltochar) module makes available one ZLE function:
+COMMENT(!MOD!zsh/deltochar
+A ZLE function duplicating EMACS' tt(zap-to-char).
+!MOD!)
+The tt(zsh/deltochar) module makes available two ZLE functions:
 
 startitem()
 tindex(delete-to-char)
@@ -8,5 +9,11 @@ item(tt(delete-to-char))(
 Read a character from the keyboard, and
 delete from the cursor position up to and including the next
 (or, with repeat count var(n), the var(n)th) instance of that character.
+Negative repeat counts mean delete backwards.
+)
+tindex(zap-to-char)
+item(tt(zap-to-char))(
+This behaves like tt(delete-to-char), except that the final occurrence of
+the character itself is not deleted.
 )
 enditem()
diff --git a/Doc/Zsh/mod_mathfunc.yo b/Doc/Zsh/mod_mathfunc.yo
index bc69d2b20..05ce9fe45 100644
--- a/Doc/Zsh/mod_mathfunc.yo
+++ b/Doc/Zsh/mod_mathfunc.yo
@@ -1,8 +1,10 @@
-texinode(The mathfunc Module)(The parameter Module)(The mapfile Module)(Zsh Modules)
-sect(The mathfunc Module)
+COMMENT(!MOD!zsh/mathfunc
+Standard scientific functions for use in mathematical evaluations.
+!MOD!)
 cindex(functions, mathematical)
 cindex(mathematical functions)
-The tt(mathfunc) module provides standard mathematical functions for use when
+The tt(zsh/mathfunc) module provides standard
+mathematical functions for use when
 evaluating mathematical formulae.  The syntax agrees with normal C and
 FORTRAN conventions, for example,
 
@@ -32,10 +34,10 @@ The function tt(signgam) takes no arguments, and returns an integer, which
 is the C variable of the same name, as described in manref(gamma)(3).  Note
 that it is therefore only useful immediately after a call to tt(gamma) or
 tt(lgamma).  Note also that `tt(signgam())' and `tt(signgam)' are distinct
-expresssions.
+expressions.
 
 The following functions take two floating point arguments: tt(copysign),
-tt(drem), tt(fmod), tt(hypot), tt(nextafter).
+tt(fmod), tt(hypot), tt(nextafter).
 
 The following take an integer first argument and a floating point second
 argument: tt(jn), tt(yn).
diff --git a/Doc/Zsh/mod_parameter.yo b/Doc/Zsh/mod_parameter.yo
index c84dd18eb..c7ac62280 100644
--- a/Doc/Zsh/mod_parameter.yo
+++ b/Doc/Zsh/mod_parameter.yo
@@ -1,8 +1,9 @@
-texinode(The parameter Module)(The sched Module)(The files Module)(Zsh Modules)
-sect(The parameter Module)
+COMMENT(!MOD!zsh/parameter
+Access to internal hash tables via special associative arrays.
+!MOD!)
 cindex(parameters, special)
-The tt(parameter) module gives access to some of the internal hash
-tables used by the shell, by defining four special associative arrays.
+The tt(zsh/parameter) module gives access to some of the internal hash
+tables used by the shell by defining some special parameters.
 
 startitem()
 vindex(options)
@@ -16,7 +17,7 @@ the option, respectively. Unsetting a key in this array is like
 setting it to the value tt(off).
 )
 vindex(commands)
-item(tt(command))(
+item(tt(commands))(
 This array gives access to the command hash table. The keys are the
 names of external commands, the values are the pathnames of the files
 that would be executed when the command would be invoked. Setting a
@@ -27,10 +28,51 @@ hash table.
 )
 vindex(functions)
 item(tt(functions))(
-This association maps function names to their definitions. Setting a
-key in it is like defining a function with the name given by the key
-and the body given by the value. Unsetting a key removes the
-definition for the function named by the key.
+This association maps names of enabled functions to their
+definitions. Setting a key in it is like defining a function with the
+name given by the key and the body given by the value. Unsetting a key
+removes the definition for the function named by the key.
+)
+vindex(dis_functions)
+item(tt(dis_functions))(
+Like tt(functions) but for disabled functions.
+)
+vindex(builtins)
+item(tt(builtins))(
+This association gives information about the builtin commands
+currently enabled. The keys are the names of the builtin commands and
+the values are either `tt(undefined)' for builtin commands that will
+automatically be loaded from a module if invoked or `tt(defined)' for
+builtin commands that are already loaded.
+)
+vindex(dis_builtins)
+item(tt(dis_builtins))(
+Like tt(builtins) but for disabled builtin commands.
+)
+vindex(reswords)
+item(tt(reswords))(
+This array contains the enabled reserved words.
+)
+vindex(dis_reswords)
+item(tt(dis_reswords))(
+Like tt(reswords) but for disabled reserved words.
+)
+vindex(aliases)
+item(tt(aliases))(
+This maps the names of the regular aliases currently enabled to their
+expansions.
+)
+vindex(dis_aliases)
+item(tt(dis_aliases))(
+Like tt(raliases) but for disabled regular aliases.
+)
+vindex(galiases)
+item(tt(galiases))(
+Like tt(raliases), but for global aliases.
+)
+vindex(dis_galiases)
+item(tt(dis_galiases))(
+Like tt(galiases) but for disabled global aliases.
 )
 vindex(parameters)
 item(tt(parameters))(
@@ -46,4 +88,64 @@ noderef(Parameter Expansion)
 .
 Setting or unsetting keys in this array is not possible.
 )
+vindex(modules)
+item(tt(modules))(
+An association giving information about module. The keys are the names
+of the modules builtin, loaded, or registered to be autoloaded. The
+value says which state the named module is in and is one of the
+strings tt(builtin), tt(loaded), or tt(autoloaded).
+
+Setting or unsetting keys in this array is not possible.
+)
+vindex(dirstack)
+item(tt(dirstack))(
+A normal array holding the elements of the directory stack. Note that
+the output of the tt(dirs) builtin command includes one more
+directory, the current working directory.
+)
+vindex(history)
+item(tt(history))(
+This association maps history event numbers to the full history lines.
+)
+vindex(historywords)
+item(tt(historywords))(
+A special array containing the words stored in the history.
+)
+vindex(jobdirs)
+item(tt(jobdirs))(
+This association maps job numbers to the directories from which the job was started (which may not be the current directory of the job).
+)
+vindex(jobtexts)
+item(tt(jobtexts))(
+This association maps job numbers to the texts of the command lines
+that were used to start the jobs.
+)
+vindex(jobstates)
+item(tt(jobstates))(
+This association gives information about the states of the jobs
+currently known. The keys are the job numbers and the values are
+strings of the form
+`var(job-state):var(pid)tt(=)var(state)tt(...)'. The var(job-state)
+gives the state the whole job is currently in, one of `tt(running)',
+`tt(suspended)', or `tt(done)'. This is followed by one
+`var(pid)tt(=)var(state)' for every process in the job. The var(pid)s
+are, of course, the process IDs and the var(state) describes the state 
+of that process.
+)
+vindex(nameddirs)
+item(tt(nameddirs))(
+This association maps the names of named directories to the pathnames
+they stand for.
+)
+vindex(userdirs)
+item(tt(userdirs))(
+This association maps user names to the pathnames of their home
+directories.
+)
+vindex(funcstack)
+item(tt(funcstack))(
+This array contains the names of the functions currently being
+executed. The first element is the name of the function using the
+parameter.
+)
 enditem()
diff --git a/Doc/Zsh/mod_zle.yo b/Doc/Zsh/mod_zle.yo
index d301b4de3..15ed17547 100644
--- a/Doc/Zsh/mod_zle.yo
+++ b/Doc/Zsh/mod_zle.yo
@@ -170,7 +170,7 @@ the prompt to display at the left.  If the tt(-r) flag is given,
 the following string gives the prompt to display at the right.  If the
 tt(-h) flag is specified, the history can be accessed from ZLE. If the 
 tt(-e) flag is given, typing tt(^D) (Control-D) on an empty line
-causes tt(vared) to exit immediatly with a non-zero return value.
+causes tt(vared) to exit immediately with a non-zero return value.
 )
 findex(zle)
 cindex(widgets, rebinding)
@@ -254,8 +254,8 @@ var(string)s are given but the tt(-c) option is used such a list is
 cleared.
 
 Note that this option is only useful for widgets that do not exit
-immediatly after using it because the strings displayed will be erased 
-immediatly after return from the widget.
+immediately after using it because the strings displayed will be erased 
+immediately after return from the widget.
 )
 item(tt(-M) var(string))(
 As with the tt(-R) option, the var(string) will be displayed below the 
diff --git a/Doc/Zsh/mod_zutil.yo b/Doc/Zsh/mod_zutil.yo
index 891ebef11..b58d860b8 100644
--- a/Doc/Zsh/mod_zutil.yo
+++ b/Doc/Zsh/mod_zutil.yo
@@ -88,7 +88,7 @@ is selected with the tt(-f) option. If this is given, the var(format)
 string will be modified by replacing sequences starting with a percent 
 sign in it with strings from the var(specs). Each var(spec) has to be
 of the form `var(char)tt(:)var(string)' and this will make every
-appearence of the sequence `tt(%)var(char)' in var(format) be replaced 
+appearance of the sequence `tt(%)var(char)' in var(format) be replaced 
 with the var(string). The `tt(%)' sequence may also contain optional
 minimum and maximum field width specifications between the `tt(%)' and 
 the `var(char)' in the form `tt(%)var(min)tt(.)var(max)tt(c)',
diff --git a/Doc/Zsh/options.yo b/Doc/Zsh/options.yo
index 9b2d34b92..b87eb788b 100644
--- a/Doc/Zsh/options.yo
+++ b/Doc/Zsh/options.yo
@@ -218,7 +218,7 @@ pindex(CHASE_DOTS)
 cindex(cd, with .. in argument)
 item(tt(CHASE_DOTS))(
 When changing to a directory containing a path segment `tt(..)' which would
-otherwise be treated as cancelling the previous segment in the path (in
+otherwise be treated as canceling the previous segment in the path (in
 other words, `tt(foo/..)' would be removed from the path, or if `tt(..)' is
 the first part of the path, the last part of tt($PWD) would be deleted),
 instead resolve the path to the physical directory.  This option is
diff --git a/Doc/Zsh/params.yo b/Doc/Zsh/params.yo
index ac90d095d..0ba4b37b2 100644
--- a/Doc/Zsh/params.yo
+++ b/Doc/Zsh/params.yo
@@ -146,7 +146,7 @@ makes the keys be interpreted as patterns and returns the first value
 whose key matches the var(exp).
 )
 item(tt(K))(
-On an associtation this is like `tt(k)' but returns all values whose
+On an association this is like `tt(k)' but returns all values whose
 keys match the var(exp). On other types of parameters this has the
 same effect as `tt(R)'.
 )
@@ -216,7 +216,7 @@ any outer parameter of the same name remains hidden.
 Special parameters may also be made local; they retain their special
 attributes unless either the existing or the newly-created parameter
 has the tt(-h) (hide) attribute.  This may have unexpected effects:
-there is no default value, so if there is no assigment at the
+there is no default value, so if there is no assignment at the
 point the variable is made local, it will be set to an empty value (or zero
 in the case of integers).  
 The following:
@@ -342,7 +342,7 @@ The line number of the current line within the current script, sourced
 file, or shell function being executed, whichever was started most
 recently.  Note that in the case of shell functions the line
 number refers to the function as it appeared in the original definition,
-not necesarily as displayed by the tt(functions) builtin.
+not necessarily as displayed by the tt(functions) builtin.
 )
 vindex(LOGNAME)
 item(tt(LOGNAME))(
diff --git a/Doc/Zsh/zftpsys.yo b/Doc/Zsh/zftpsys.yo
index 783de107f..4291c9a23 100644
--- a/Doc/Zsh/zftpsys.yo
+++ b/Doc/Zsh/zftpsys.yo
@@ -358,7 +358,7 @@ item(tt(zftransfer) var(sess1)tt(:)var(file1) var(sess2)tt(:)var(file2))(
 Transfer files between two sessions; no local copy is made.  The file
 is read from the session var(sess1) as var(file1) and written to session
 var(sess1) as file var(file2); var(file1) and var(file2) may be relative to
-the current directories of the sesssion.  Either var(sess1) or var(sess2)
+the current directories of the session.  Either var(sess1) or var(sess2)
 may be omitted (though the colon should be retained if there is a
 possibility of a colon appearing in the file name) and defaults to the
 current session; var(file2) may be omitted or may end with a slash, in