about summary refs log tree commit diff
path: root/Doc
diff options
context:
space:
mode:
Diffstat (limited to 'Doc')
-rw-r--r--Doc/Zsh/arith.yo19
-rw-r--r--Doc/Zsh/builtins.yo94
-rw-r--r--Doc/Zsh/cond.yo11
-rw-r--r--Doc/Zsh/expn.yo24
-rw-r--r--Doc/Zsh/grammar.yo15
-rw-r--r--Doc/Zsh/options.yo18
-rw-r--r--Doc/Zsh/params.yo12
-rw-r--r--Doc/Zsh/redirect.yo9
-rw-r--r--Doc/Zsh/zle.yo317
9 files changed, 265 insertions, 254 deletions
diff --git a/Doc/Zsh/arith.yo b/Doc/Zsh/arith.yo
index 5c334ce9c..1dcd18cad 100644
--- a/Doc/Zsh/arith.yo
+++ b/Doc/Zsh/arith.yo
@@ -7,7 +7,8 @@ cindex(arithmetic evaluation)
 cindex(evaluation, arithmetic)
 findex(let, use of)
 The shell can perform integer and floating point arithmetic, either using
-the builtin tt(let), or via a substitution of the form tt($((...))).  For
+the builtin tt(let), or via a substitution of the form
+tt($LPAR()LPAR())var(...)tt(RPAR()RPAR()).  For
 integers, the shell is usually compiled to use 8-byte precision where this
 is available, otherwise precision is 4 bytes.  This can be tested, for
 example, by giving the command `tt(print - $(( 12345678901 )))'; if the
@@ -40,7 +41,7 @@ cindex(arithmetic base)
 cindex(bases, in arithmetic)
 Integers can be in bases other than 10.
 A leading `tt(0x)' or `tt(0X)' denotes hexadecimal and a leading
-`tt(0b)' or `tt(0B) binary.
+`tt(0b)' or `tt(0B)' binary.
 Integers 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)
@@ -100,8 +101,8 @@ shown may vary).
 
 pindex(C_BASES, use of)
 pindex(OCTAL_ZEROES, use of)
-If the tt(C_BASES) option is set, hexadecimal numbers in the standard C
-format, for example tt(0xFF) instead of the usual `tt(16#FF)'.  If the
+If the tt(C_BASES) option is set, hexadecimal numbers are output in the standard C
+format, for example `tt(0xFF)' instead of the usual `tt(16#FF)'.  If the
 option tt(OCTAL_ZEROES) is also set (it is not by default), octal numbers
 will be treated similarly and hence appear as `tt(077)' instead of
 `tt(8#77)'.  This option has no effect on the output of bases other than
@@ -175,7 +176,7 @@ endsitem()
 
 Note the precedence of exponentiation in both cases is below
 that of unary operators, hence `tt(-3**2)' evaluates as `tt(9)', not
-tt(-9).  Use parentheses where necessary: `tt(-(3**2))'.  This is
+`tt(-9)'.  Use parentheses where necessary: `tt(-(3**2))'.  This is
 for compatibility with other shells.
 
 cindex(mathematical functions, use of)
@@ -190,12 +191,12 @@ functions.
 
 An expression of the form `tt(##)var(x)' where var(x) is any character
 sequence such as `tt(a)', `tt(^A)', or `tt(\M-\C-x)' gives the value of
-this character and an expression of the form `tt(#)var(foo)' gives the
-value of the first character of the contents of the parameter var(foo).
+this character and an expression of the form `tt(#)var(name)' gives the
+value of the first character of the contents of the parameter var(name).
 Character values are according to the character set used in the current
 locale; for multibyte character handling the option tt(MULTIBYTE) must be
-set.  Note that this form is different from `tt($#)var(foo)', a standard
-parameter substitution which gives the length of the parameter var(foo).
+set.  Note that this form is different from `tt($#)var(name)', a standard
+parameter substitution which gives the length of the parameter var(name).
 `tt(#\)' is accepted instead of `tt(##)', but its use is deprecated.
 
 Named parameters and subscripted arrays can be referenced by name within an
diff --git a/Doc/Zsh/builtins.yo b/Doc/Zsh/builtins.yo
index c4acf7672..5b25290b0 100644
--- a/Doc/Zsh/builtins.yo
+++ b/Doc/Zsh/builtins.yo
@@ -5,7 +5,8 @@ sect(Shell Builtin Commands)
 )\
 def(prefix)(1)(\
 item(tt(ARG1) var(simple command))(
-See noderef(Precommand Modifiers).
+See ifzman(the section `Precommand Modifiers' in zmanref(zshmisc))\
+ifnzman(noderef(Precommand Modifiers)).
 )\
 )\
 def(alias)(2)(\
@@ -95,7 +96,7 @@ which may have effects on shell parameters.  A zero exit status is returned.
 findex(alias)
 cindex(aliases, defining)
 cindex(aliases, listing)
-item(tt(alias) [ {tt(PLUS()|tt(-))}tt(gmrsL) ] [ var(name)[tt(=)var(value)] ... ])(
+item(tt(alias) [ {tt(PLUS())|tt(-)}tt(gmrsL) ] [ var(name)[tt(=)var(value)] ... ])(
 For each var(name) with a corresponding var(value), define an alias
 with that value.  A trailing space in var(value) causes the next word
 to be checked for alias expansion.  If the tt(-g) flag is present,
@@ -135,8 +136,8 @@ alias in a manner suitable for putting in a startup script.  The exit
 status is nonzero if a var(name) (with no var(value)) is given for
 which no alias has been defined.
 
-For more on aliases, include common problems,
-ifzman(see the section ALIASING in zmanref(zshmisc))\
+For more on aliases, include common problems, see
+ifzman(the section ALIASING in zmanref(zshmisc))\
 ifnzman(noderef(Aliasing)).
 )
 findex(autoload)
@@ -273,7 +274,8 @@ searched instead of that in tt($path). With the tt(-v) flag, tt(command)
 is similar to tt(whence) and with tt(-V), it is equivalent to tt(whence
 -v).
 
-See also noderef(Precommand Modifiers).
+See also ifzman(the section `Precommand Modifiers' in zmanref(zshmisc))\
+ifnzman(noderef(Precommand Modifiers)).
 )
 module(comparguments)(zsh/computil)
 module(compcall)(zsh/compctl)
@@ -353,7 +355,7 @@ setting here.  For example, if tt(EXTENDED_GLOB) is not active,
 the pattern tt(^) is ineffective even if `tt(disable -p "^")' has
 not been issued.  The list below indicates any option settings
 that restrict the use of the pattern.  It should be noted that
-setting tt(SH_GLOB) has a wider effect then merely disabling patterns
+setting tt(SH_GLOB) has a wider effect than merely disabling patterns
 as certain expressions, in particular those involving parentheses,
 are parsed differently.
 
@@ -361,6 +363,7 @@ The following patterns may be disabled; all
 the strings need quoting on the command line to prevent them from
 being interpreted immediately as patterns and the patterns are
 shown below in single quotes as a reminder.
+
 startitem()
 item(tt('?'))(
 The pattern character tt(?) wherever it occurs, including when preceding
@@ -370,7 +373,7 @@ item(tt('*'))(
 The pattern character tt(*) wherever it occurs, including recursive
 globbing and when preceding a parenthesis with tt(KSH_GLOB).
 )
-item('LSQUARE()')(
+item(tt('LSQUARE()'))(
 Character classes.
 )
 item(tt('<') (tt(NO_SH_GLOB)))(
@@ -615,12 +618,14 @@ the same as if the commands had been executed directly by the shell;
 if there are no var(args) or they contain no commands (i.e. are
 an empty string or whitespace) the return status is zero.
 )
-item(tt(exec) [ tt(-cl) ] [ tt(-a) var(argv0) ] [ var(command) [ var(arg) ... ]])(
+item(tt(exec) [ tt(-cl) ] [ tt(-a) var(argv0) ] [ var(command) [ var(arg) ... ] ])(
 Replace the current shell with an external var(command) rather than forking.
 With tt(-c) clear the environment; with tt(-l) prepend tt(-) to the
 tt(argv[0]) string of the command executed (to simulate a login shell);
 with tt(-a) var(argv0) set the tt(argv[0]) string of the command
-executed.  See noderef(Precommand Modifiers).
+executed.
+See ifzman(the section `Precommand Modifiers' in zmanref(zshmisc))\
+ifnzman(noderef(Precommand Modifiers)).
 
 cindex(redirection, current shell's I/O)
 If var(command) is omitted but any redirections are specified,
@@ -775,13 +780,13 @@ Bring each specified var(job) in turn to the foreground.
 If no var(job) is specified, resume the current job.
 )
 findex(float)
-item(tt(float) [ {tt(PLUS())|tt(-)}tt(EFHghlprtux) ] [ tt(-LRZ) [ var(n) ]] \
-[ var(name)[tt(=)var(value)] ... ])(
+item(tt(float) [ {tt(PLUS())|tt(-)}tt(Hghlprtux) ] \
+[ {tt(PLUS())|tt(-)}tt(EFLRZ) [ var(n) ] ] [ var(name)[tt(=)var(value)] ... ])(
 Equivalent to tt(typeset -E), except that options irrelevant to floating
 point numbers are not permitted.
 )
 findex(functions)
-xitem(tt(functions) [ {tt(PLUS())|tt(-)}tt(UXkmtTuz) ] [ var(name) ... ])
+xitem(tt(functions) [ {tt(PLUS())|tt(-)}tt(UkmtTuz) ] [ var(name) ... ])
 xitem(tt(functions -M) var(mathfn) [ var(min) [ var(max) [ var(shellfn) ] ] ])
 xitem(tt(functions -M) [ tt(-m) var(pattern) ... ])
 item(tt(functions +M) [ tt(-m) ] var(mathfn) ... )(
@@ -834,7 +839,7 @@ cindex(line, reading)
 cindex(reading a line)
 item(tt(getln) [ tt(-AclneE) ] var(name) ...)(
 Read the top value from the buffer stack and put it in
-the shell parameter tt(name).  Equivalent to
+the shell parameter var(name).  Equivalent to
 tt(read -zr).
 )
 findex(getopts)
@@ -922,8 +927,8 @@ the form of a call to hash.
 )
 alias(history)(fc -l)
 findex(integer)
-item(tt(integer) [ {tt(PLUS())|tt(-)}tt(Hghilprtux) ] \
-[ tt(-LRZ) [ var(n) ]] [ var(name)[tt(=)var(value)] ... ])(
+item(tt(integer) [ {tt(PLUS())|tt(-)}tt(Hghlprtux) ] \
+[ {tt(PLUS())|tt(-)}tt(LRZi) [ var(n) ] ] [ var(name)[tt(=)var(value)] ... ])(
 Equivalent to tt(typeset -i), except that options irrelevant to
 integers are not permitted.
 )
@@ -1058,8 +1063,8 @@ shell starts in a mode emulating another shell.  It can be made available
 with the command `tt(zmodload -F zsh/rlimits b:limit)'.
 )
 findex(local)
-item(tt(local) [ {tt(PLUS())|tt(-)}tt(AEFHUahlprtux) ] \
-[ tt(-LRZi) [ var(n) ]] [ var(name)[tt(=)var(value)] ] ...)(
+item(tt(local) [ {tt(PLUS())|tt(-)}tt(AHUahlprtux) ] \
+[ {tt(PLUS())|tt(-)}tt(EFLRZi) [ var(n) ] ] [ var(name)[tt(=)var(value)] ... ])(
 Same as tt(typeset), except that the options tt(-g), and
 tt(-f) are not permitted.  In this case the tt(-x) option does not force
 the use of tt(-g), i.e. exported variables will be local to functions.
@@ -1078,12 +1083,12 @@ Same as tt(exit), except that it only works in a login shell.
 )
 prefix(noglob)
 findex(popd)
-item(tt(popd) [ [-q] {tt(PLUS())|tt(-)}var(n) ])(
+item(tt(popd) [ tt(-q) ] [ {tt(PLUS())|tt(-)}var(n) ])(
 Remove an entry from the directory stack, and perform a tt(cd) to
 the new top directory.  With no argument, the current top entry is
 removed.  An argument of the form `tt(PLUS())var(n)' identifies a stack
 entry by counting from the left of the list shown by the tt(dirs) command,
-starting with zero.  An argument of the form tt(-n) counts from the right.
+starting with zero.  An argument of the form tt(-)var(n) counts from the right.
 pindex(PUSHD_MINUS, use of)
 If the tt(PUSHD_MINUS) option is set, the meanings of `tt(PLUS())' and
 `tt(-)' in this context are swapped.
@@ -1117,7 +1122,7 @@ tt(-c) and tt(-C) options.
 item(tt(-b))(
 Recognize all the escape sequences defined for the tt(bindkey) command,
 see 
-ifzman(zmanref(zshzle))\
+ifzman(the section `Zle Builtins' in zmanref(zshzle))\
 ifnzman(noderef(Zle Builtins))\
 .
 )
@@ -1204,13 +1209,13 @@ item(tt(printf) var(format) [ var(arg) ... ])(
 Print the arguments according to the format specification. Formatting
 rules are the same as used in C. The same escape sequences as for tt(echo)
 are recognised in the format. All C conversion specifications ending in
-one of csdiouxXeEfgGn are handled. In addition to this, `tt(%b)' can be
+one of tt(csdiouxXeEfgGn) are handled. In addition to this, `tt(%b)' can be
 used instead of `tt(%s)' to cause escape sequences in the argument to be
 recognised and `tt(%q)' can be used to quote the argument in such a way
 that allows it to be reused as shell input. With the numeric format
 specifiers, if the corresponding argument starts with a quote character,
 the numeric value of the following character is used as the number to
-print otherwise the argument is evaluated as an arithmetic expression. See
+print; otherwise the argument is evaluated as an arithmetic expression. See
 ifzman(the section `Arithmetic Evaluation' in zmanref(zshmisc))\
 ifnzman(noderef(Arithmetic Evaluation))
 for a description of arithmetic
@@ -1487,7 +1492,7 @@ module(setcap)(zsh/cap)
 findex(setopt)
 cindex(options, setting)
 item(tt(setopt) [ {tt(PLUS())|tt(-)}var(options) | \
-{tt(PLUS())|tt(-)}tt(o) var(option_name) ] [ var(name) ... ])(
+{tt(PLUS())|tt(-)}tt(o) var(option_name) ] [ tt(-m) ] [ var(name) ... ])(
 Set the options for the shell.  All options specified either
 with flags or by name are set.
 
@@ -1653,7 +1658,7 @@ Do nothing and return an exit status of 0.
 )
 findex(ttyctl)
 cindex(tty, freezing)
-item(tt(ttyctl) tt(-fu))(
+item(tt(ttyctl) [ tt(-fu) ])(
 The tt(-f) option freezes the tty (i.e. terminal or terminal emulator), and
 tt(-u) unfreezes it.
 When the tty is frozen, no changes made to the tty settings by
@@ -1682,12 +1687,12 @@ Equivalent to tt(whence -v).
 findex(typeset)
 cindex(parameters, setting)
 cindex(parameters, declaring)
-xitem(tt(typeset) [ {tt(PLUS())|tt(-)}tt(AEFHUafghklprtuxmz) ] [ tt(-LRZi) \
-[ var(n) ]] [ \
-var(name)[tt(=)var(value)] ... ])
-item(tt(typeset) -T [ {tt(PLUS()|tt(-))}tt(Urux) ] \
- [ tt(-LRZ) [ var(n) ]] \
- var(SCALAR)[tt(=)var(value)] var(array) tt([) var(sep) tt(]))(
+xitem(tt(typeset) [ {tt(PLUS())|tt(-)}tt(AHUaghlmprtux) ] \
+[ {tt(PLUS())|tt(-)}tt(EFLRZi) [ var(n) ] ])
+xitem(        [ tt(+) | var(name)[tt(=)var(value)] ... ])
+xitem(tt(typeset) tt(-T) [ {tt(PLUS())|tt(-)}tt(Uglprux) ] [ {tt(PLUS())|tt(-)}tt(LRZ) [ var(n) ] ])
+xitem(           [ tt(+) | var(SCALAR)[tt(=)var(value)] var(array) [ var(sep) ] ])
+item(tt(typeset) tt(-f) [ {tt(PLUS())|tt(-)}tt(TUkmtuz) ] [ tt(+) | var(name) ... ])(
 Set or display attributes and values for shell parameters.
 
 A parameter is created for each var(name) that does not already refer
@@ -1811,7 +1816,7 @@ as before but the separator is changed.
 enditem()
 
 Attribute flags that transform the final value (tt(-L), tt(-R), tt(-Z),
-tt(-l), tt(u)) are only applied to the expanded value at the point
+tt(-l), tt(-u)) are only applied to the expanded value at the point
 of a parameter expansion expression using `tt($)'.  They are not applied
 when a parameter is retrieved internally by the shell for any purpose. 
 
@@ -1824,8 +1829,9 @@ ifzman(`Array Parameters' in zmanref(zshparam))\
 ifnzman(noderef(Array Parameters))\
 .
 )
-item(tt(-L))(
-Left justify and remove leading blanks from var(value).
+item(tt(-L) [ var(n) ])(
+Left justify and remove leading blanks from the value when the parameter
+is expanded.
 If var(n) is nonzero, it defines the width of the field.
 If var(n) is zero, the width is determined by the width of the value of
 the first assignment.  In the case of numeric parameters, the length of the
@@ -1845,7 +1851,7 @@ blanks or truncated if necessary to fit the field.
 Note truncation can lead to unexpected results with numeric parameters.
 Leading zeros are removed if the tt(-Z) flag is also set.
 )
-item(tt(-R))(
+item(tt(-R) [ var(n) ])(
 Similar to tt(-L), except that right justification is used;
 when the parameter is expanded, the field is left filled with
 blanks or truncated from the end.  May not be combined with the tt(-Z)
@@ -1857,7 +1863,7 @@ occurrence of each duplicated value.  This may also be set for
 colon-separated special parameters like tt(PATH) or tt(FIGNORE), etc.
 This flag has a different meaning when used with tt(-f); see below.
 )
-item(tt(-Z))(
+item(tt(-Z) [ var(n) ])(
 Specially handled if set along with the tt(-L) flag.
 Otherwise, similar to tt(-R), except that leading zeros are used for
 padding instead of blanks if the first non-blank character is a digit.
@@ -1884,7 +1890,7 @@ parameter will be searched to find the function definition when the
 function is first referenced; see noderef(Functions). The tt(-k) and
 tt(-z) flags make the function be loaded using ksh-style or zsh-style
 autoloading respectively. If neither is given, the setting of the
-KSH_AUTOLOAD option determines how the function is loaded.
+tt(KSH_AUTOLOAD) option determines how the function is loaded.
 )
 item(tt(-h))(
 Hide: only useful for special parameters (those marked `<S>' in the table in
@@ -1914,18 +1920,18 @@ default for the parameters in the tt(zsh/parameter) and tt(zsh/mapfile)
 modules.  Note, however, that unlike the tt(-h) flag this is also useful
 for non-special parameters.
 )
-item(tt(-i))(
+item(tt(-i) [ var(n) ])(
 Use an internal integer representation.  If var(n) is nonzero it
 defines the output arithmetic base, otherwise it is determined by the
 first assignment.  Bases from 2 to 36 inclusive are allowed.
 )
-item(tt(-E))(
+item(tt(-E) [ var(n) ])(
 Use an internal double-precision floating point representation.  On output
 the variable will be converted to scientific notation.  If var(n) is
 nonzero it defines the number of significant figures to display; the
 default is ten.
 )
-item(tt(-F))(
+item(tt(-F) [ var(n) ])(
 Use an internal double-precision floating point representation.  On output
 the variable will be converted to fixed-point decimal notation.  If var(n)
 is nonzero it defines the number of digits to display after the decimal
@@ -1968,7 +1974,7 @@ enditem()
 findex(ulimit)
 cindex(resource limits)
 cindex(limits, resource)
-item(tt(ulimit) [ [ tt(-SHacdfiklmnpqsTtvwx) | tt(-N) var(resource) [ var(limit) ] ... ])(
+item(tt(ulimit) [ tt(-HSa) ] [ { tt(-bcdfiklmnpqrsTtvwx) | tt(-N) var(resource) } [ var(limit) ] ... ])(
 Set or display resource limits of the shell and the processes started by
 the shell.  The value of var(limit) can be a number in the unit specified
 below or one of the values `tt(unlimited)', which removes the limit on the
@@ -2132,7 +2138,7 @@ to process IDs.
 )
 findex(whence)
 item(tt(whence) [ tt(-vcwfpamsS) ] var(name) ...)(
-For each name, indicate how it would be interpreted if used as a
+For each var(name), indicate how it would be interpreted if used as a
 command name.
 
 tt(whence) is most useful when var(name) is only the last path component
@@ -2334,7 +2340,7 @@ findex(zmodload)
 cindex(modules, loading)
 cindex(loading modules)
 xitem(tt(zmodload) [ tt(-dL) ] [ ... ])
-xitem(tt(zmodload -F) [ tt(-lLme) tt(-P) tt(param) ] var(module) [tt(PLUS()-)]var(feature...))
+xitem(tt(zmodload -F) [ tt(-alLme) tt(-P) var(param) ] var(module) [ [tt(PLUS()-)]var(feature) ... ])
 xitem(tt(zmodload -e) [ tt(-A) ] [ ... ])
 xitem(tt(zmodload) [ tt(-a) [ tt(-bcpf) [ tt(-I) ] ] ] [ tt(-iL) ] ...)
 xitem(tt(zmodload) tt(-u) [ tt(-abcdpf) [ tt(-I) ] ] [ tt(-iL) ] ...)
@@ -2385,7 +2391,7 @@ Each module has a boot and a cleanup function.  The module
 will not be loaded if its boot function fails.  Similarly a module
 can only be unloaded if its cleanup function runs successfully.
 )
-item(tt(zmodload -F) [ tt(-almLe) tt(-P) tt(param) ] var(module) [tt(PLUS()-)]var(feature...))(
+item(tt(zmodload -F) [ tt(-almLe) tt(-P) var(param) ] var(module) [ [tt(PLUS()-)]var(feature) ... ])(
 tt(zmodload -F) allows more selective control over the features provided
 by modules.  With no options apart from tt(-F), the module named
 var(module) is loaded, if it was not already loaded, and the list of
@@ -2416,7 +2422,7 @@ feature per line.  With tt(-L) alone, a tt(zmodload -F) command that would
 cause enabled features of the module to be turned on is shown.  With
 tt(-lL), a tt(zmodload -F) command that would cause all the features to be
 set to their current state is shown.  If one of these combinations is given
-the option tt(-P) var(param) then the parameter tt(param) is set to an
+with the option tt(-P) var(param) then the parameter var(param) is set to an
 array of features, either features together with their state or (if
 tt(-L) alone is given) enabled features.
 
diff --git a/Doc/Zsh/cond.yo b/Doc/Zsh/cond.yo
index d04ceb258..3d369fb83 100644
--- a/Doc/Zsh/cond.yo
+++ b/Doc/Zsh/cond.yo
@@ -123,7 +123,7 @@ tt(MATCH) is set to the substring that matched the pattern and
 the integer parameters tt(MBEGIN) and tt(MEND) to the index of the start
 and end, respectively, of the match in var(string), such that if
 var(string) is contained in variable tt(var) the expression
-`${var[$MBEGIN,$MEND]}' is identical to `$MATCH'.  The setting
+`tt(${var[$MBEGIN,$MEND]})' is identical to `tt($MATCH)'.  The setting
 of the option tt(KSH_ARRAYS) is respected.  Likewise, the array
 tt(match) is set to the substrings that matched parenthesised
 subexpressions and the arrays tt(mbegin) and tt(mend) to the indices of
@@ -132,9 +132,9 @@ var(string).  The arrays are not set if there were no parenthesised
 subexpresssions.  For example, if the string `tt(a short string)' is matched
 against the regular expression `tt(s+LPAR()...RPAR()t)', then (assuming the
 option tt(KSH_ARRAYS) is not set) tt(MATCH), tt(MBEGIN)
-and tt(MEND) are `tt(short)', 3 and 7, respectively, while tt(match),
+and tt(MEND) are `tt(short)', tt(3) and tt(7), respectively, while tt(match),
 tt(mbegin) and tt(mend) are single entry arrays containing
-the strings `tt(hor)', `tt(4)' and `tt(6), respectively.
+the strings `tt(hor)', `tt(4)' and `tt(6)', respectively.
 
 If the option tt(BASH_REMATCH) is set the array
 tt(BASH_REMATCH) is set to the substring that matched the pattern
@@ -216,7 +216,7 @@ test command.
 
 For example,
 
-tt([[ -n file*(#qN) ]])
+example([[ -n file*(#qN) ]])
 
 produces status zero if and only if there is at least one file in the
 current directory beginning with the string `tt(file)'.  The globbing
@@ -243,7 +243,8 @@ even if the underlying system does not support
 the tt(/dev/fd) directory.
 
 In the forms which do numeric comparison, the expressions var(exp)
-undergo arithmetic expansion as if they were enclosed in tt($((...))).
+undergo arithmetic expansion as if they were enclosed in
+tt($LPAR()LPAR())var(...)tt(RPAR()RPAR()).
 
 For example, the following:
 
diff --git a/Doc/Zsh/expn.yo b/Doc/Zsh/expn.yo
index 8728803e0..85191edeb 100644
--- a/Doc/Zsh/expn.yo
+++ b/Doc/Zsh/expn.yo
@@ -943,7 +943,7 @@ item(tt(F))(
 Join the words of arrays together using newline as a separator.
 This is a shorthand for `tt(pj:\n:)'.
 )
-item(tt(g:opts:))(
+item(tt(g:)var(opts)tt(:))(
 Process escape sequences like the echo builtin when no options are given
 (tt(g::)).  With the tt(o) option, octal escapes don't take a leading
 zero.  With the tt(c) option, sequences like `tt(^X)' are also processed.
@@ -1168,11 +1168,11 @@ optional; neither, the first, or both may be given.  Note that the same
 pairs of delimiters must be used for each of the three arguments.  The
 space to the left will be filled with var(string1) (concatenated as
 often as needed) or spaces if var(string1) is not given.  If both
-var(string1) and var(string2) are given, tt(string2) is inserted once
+var(string1) and var(string2) are given, var(string2) is inserted once
 directly to the left of each word, truncated if necessary, before
 var(string1) is used to produce any remaining padding.
 
-If either of var(string1) or tt(string2) is present but empty,
+If either of var(string1) or var(string2) is present but empty,
 i.e. there are two delimiters together at that point, the first
 character of tt($IFS) is used instead.
 
@@ -1230,7 +1230,7 @@ example(line="one::three"
 print -l "${(s.:.)line}")
 
 produces two lines of output for tt(one) and tt(three) and elides the
-empty field.  To override this behaviour, supply the "(@)" flag as well,
+empty field.  To override this behaviour, supply the `tt((@))' flag as well,
 i.e.  tt("${(@s.:.)line}").
 )
 item(tt(Z:)var(opts)tt(:))(
@@ -1314,14 +1314,14 @@ enditem()
 subsect(Rules)
 
 Here is a summary of the rules for substitution; this assumes that braces
-are present around the substitution, i.e. tt(${...}).  Some particular
+are present around the substitution, i.e. tt(${)var(...)tt(}).  Some particular
 examples are given below.  Note that the Zsh Development Group accepts
 em(no responsibility) for any brain damage which may occur during the
 reading of the following rules.
 
 startitem()
 item(tt(1.) em(Nested substitution))(
-If multiple nested tt(${...}) forms are present, substitution is
+If multiple nested tt(${)var(...)tt(}) forms are present, substitution is
 performed from the inside outwards.  At each level, the substitution takes
 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
@@ -2233,7 +2233,7 @@ tt(readme) with up to two errors.
 When using the ksh syntax for grouping both tt(KSH_GLOB) and
 tt(EXTENDED_GLOB) must be set and the left parenthesis should be
 preceded by tt(@).  Note also that the flags do not affect letters
-inside tt([...]) groups, in other words tt(LPAR()#i)tt(RPAR()[a-z])
+inside tt([)...tt(]) groups, in other words tt(LPAR()#i)tt(RPAR()[a-z])
 still matches only lowercase letters.  Finally, note that when
 examining whole paths case-insensitively every directory must be
 searched for all files which match, so that a pattern of the form
@@ -2344,7 +2344,8 @@ the glob pattern by doubling the parentheses, in this case producing
 `tt(((^x)))'.
 
 If the option tt(EXTENDED_GLOB) is set, a different syntax for glob
-qualifiers is available, namely `tt((#qx))' where tt(x) is any of the same
+qualifiers is available, namely `tt(LPAR()#q)var(x)tt(RPAR())'
+where var(x) is any of the same
 glob qualifiers used in the other format.  The qualifiers must still appear
 at the end of the pattern.  However, with this syntax multiple glob
 qualifiers may be chained together.  They are treated as a logical AND of
@@ -2357,7 +2358,7 @@ the pattern, for example `tt(*(#q*)(.))' will recognise executable regular
 files if both options are set; however, mixed syntax should probably be
 avoided for the sake of clarity.  Note that within conditions using the
 `tt([[)' form the presence of a parenthesised expression
-tt(LPAR()#q...+RPAR()) at the end of a string indicates that globbing
+tt(LPAR()#q)var(...)tt(RPAR()) at the end of a string indicates that globbing
 should be performed; the expression may include glob qualifiers, but
 it is also valid if it is simply tt(LPAR()#q+RPAR()).  This does
 not apply to the right hand side of pattern match operators as the
@@ -2694,14 +2695,15 @@ whole list matches if at least one of the sublists matches (they are
 however, affect all matches generated, independent of the sublist in
 which they are given.  These are the qualifiers `tt(M)', `tt(T)',
 `tt(N)', `tt(D)', `tt(n)', `tt(o)', `tt(O)' and the subscripts given
-in brackets (`tt([...])').
+in brackets (`tt([)var(...)tt(])').
 
 If a `tt(:)' appears in a qualifier list, the remainder of the expression in
 parenthesis is interpreted as a modifier (see noderef(Modifiers)
 in noderef(History Expansion)).  Each modifier must be introduced by a
 separate `tt(:)'.  Note also that the result after modification does not
 have to be an existing file.  The name of any existing file can be followed
-by a modifier of the form `tt((:..))' even if no actual filename generation
+by a modifier of the form `tt(LPAR():)var(...)tt(RPAR())'
+even if no actual filename generation
 is performed, although note that the presence of the parentheses
 causes the entire expression to be subjected to any global pattern matching
 options such as tt(NULL_GLOB). Thus:
diff --git a/Doc/Zsh/grammar.yo b/Doc/Zsh/grammar.yo
index 522ad0472..a3f492769 100644
--- a/Doc/Zsh/grammar.yo
+++ b/Doc/Zsh/grammar.yo
@@ -191,7 +191,7 @@ use the positional parameters instead of the var(word)s.
 
 More than one parameter var(name) can appear before the list of
 var(word)s.  If var(N) var(name)s are given, then on each execution of the
-loop the next tt(N) var(word)s are assigned to the corresponding
+loop the next var(N) var(word)s are assigned to the corresponding
 parameters.  If there are more var(name)s than remaining var(word)s, the
 remaining parameters are each set to the empty string.  Execution of the
 loop ends when there is no remaining var(word) to assign to the first
@@ -353,7 +353,7 @@ 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
+whitespace may appear 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.
 
@@ -396,8 +396,9 @@ code is a concern.
 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.  For the tt(if),
 tt(while) and tt(until) commands, in both these cases 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.  For the
+loop must also be suitably delimited, such as by `tt([[) var(...) tt(]])' or
+`tt(LPAR()LPAR()) var(...) tt(RPAR()RPAR())',
+else the end of the test will not be recognized.  For the
 tt(for), tt(repeat), tt(case) and tt(select) commands no such special form
 for the arguments is necessary, but the other condition (the special form
 of var(sublist) or use of the tt(SHORT_LOOPS) option) still applies.
@@ -420,7 +421,7 @@ example(if true {  # Does not work!
 does em(not), since the test is not suitably delimited.
 )
 item(tt(if) var(list) var(sublist))(
-A short form of the alternate `if'.  The same limitations on the form of
+A short form of the alternate tt(if).  The same limitations on the form of
 var(list) apply as for the previous form.
 )
 item(tt(for) var(name) ... tt(LPAR()) var(word) ... tt(RPAR()) var(sublist))(
@@ -451,7 +452,7 @@ This is a short form of tt(repeat).
 item(tt(case) var(word) tt({) [ [tt(LPAR())] var(pattern) [ tt(|) var(pattern) ] ... tt(RPAR()) var(list) (tt(;;)|tt(;&)|tt(;|)) ] ... tt(}))(
 An alternative form of tt(case).
 )
-item(tt(select) var(name) [ tt(in) var(word) var(term) ] var(sublist))(
+item(tt(select) var(name) [ tt(in) var(word) ... var(term) ] var(sublist))(
 where var(term) is at least one newline or tt(;).
 A short form of tt(select).
 )
@@ -617,7 +618,7 @@ code fragment might be re-executed.
 texinode(Quoting)()(Aliasing)(Shell Grammar)
 sect(Quoting)
 cindex(quoting)
-A character may be var(quoted) (that is, made
+A character may be em(quoted) (that is, made
 to stand for itself) by preceding it with a `tt(\)'.
 `tt(\)' followed by a newline is ignored.
 
diff --git a/Doc/Zsh/options.yo b/Doc/Zsh/options.yo
index 20d9fc2a8..fceb141e4 100644
--- a/Doc/Zsh/options.yo
+++ b/Doc/Zsh/options.yo
@@ -792,7 +792,7 @@ 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:
 
-`tt(:) var(<beginning time>)tt(:)var(<elapsed seconds>)tt(;)var(<command>)'.
+`tt(: )var(<beginning time>)tt(:)var(<elapsed seconds>)tt(;)var(<command>)'.
 )
 pindex(HIST_ALLOW_CLOBBER)
 pindex(NO_HIST_ALLOW_CLOBBER)
@@ -932,7 +932,7 @@ pindex(HISTSAVEBYCOPY)
 pindex(NOHISTSAVEBYCOPY)
 item(tt(HIST_SAVE_BY_COPY) <D>)(
 When the history file is re-written, we normally write out a copy of
-the file named $HISTFILE.new and then rename it over the old one.
+the file named tt($HISTFILE.new) and then rename it over the old one.
 However, if this option is unset, we instead truncate the old
 history file and write out the new version in-place.  If one of the
 history-appending options is enabled, this option only has an effect
@@ -974,7 +974,7 @@ are added to the tt($HISTFILE) incrementally (as soon as they are
 entered), rather than waiting until the shell exits.
 The file will still be periodically re-written to trim it when the
 number of lines grows 20% beyond the value specified by
-tt($SAVEHIST) (see also the HIST_SAVE_BY_COPY option).
+tt($SAVEHIST) (see also the tt(HIST_SAVE_BY_COPY) option).
 )
 pindex(INC_APPEND_HISTORY_TIME)
 pindex(NO_INC_APPEND_HISTORY_TIME)
@@ -1483,8 +1483,8 @@ wrap to the next line when a partial line is present (note that this is
 only successful if your terminal has automatic margins, which is typical).
 
 When a partial line is preserved, by default you will see an inverse+bold
-character at the end of the partial line:  a "%" for a normal user or
-a "#" for root.  If set, the shell parameter tt(PROMPT_EOL_MARK) can be
+character at the end of the partial line:  a `tt(%)' for a normal user or
+a `tt(#)' for root.  If set, the shell parameter tt(PROMPT_EOL_MARK) can be
 used to customize how the end of partial lines are shown.
 
 NOTE: if the tt(PROMPT_CR) option is not set, enabling this option will
@@ -1548,7 +1548,7 @@ cindex(operator precedence)
 item(tt(C_PRECEDENCES))(
 This alters the precedence of arithmetic operators to be more
 like C and other programming languages;
-ifnzman(Arithmetic Evaluation)\
+ifnzman(noderef(Arithmetic Evaluation))\
 ifzman(the section ARITHMETIC EVALUATION in zmanref(zshmisc))
 has an explicit list.
 )
@@ -1856,8 +1856,8 @@ pindex(NOCSHJUNKIELOOPS)
 cindex(csh, loop style)
 cindex(loop style, csh)
 item(tt(CSH_JUNKIE_LOOPS) <C>)(
-Allow loop bodies to take the form `var(list); tt(end)' instead of
-`tt(do) var(list); tt(done)'.
+Allow loop bodies to take the form `var(list)tt(; end)' instead of
+`tt(do )var(list)tt(; done)'.
 )
 pindex(CSH_JUNKIE_QUOTES)
 pindex(NO_CSH_JUNKIE_QUOTES)
@@ -2113,7 +2113,7 @@ pindex(NOSHFILEEXPANSION)
 cindex(sh, expansion style)
 cindex(expansion style, sh)
 item(tt(SH_FILE_EXPANSION) <K> <S>)(
-Perform filename expansion (e.g., ~ expansion) em(before)
+Perform filename expansion (e.g., tt(~) expansion) em(before)
 parameter expansion, command substitution, arithmetic expansion
 and brace expansion.
 If this option is unset, it is performed em(after)
diff --git a/Doc/Zsh/params.yo b/Doc/Zsh/params.yo
index 9d06b6af6..e7fad2d76 100644
--- a/Doc/Zsh/params.yo
+++ b/Doc/Zsh/params.yo
@@ -111,7 +111,7 @@ indent(tt(typeset -A) var(name))
 When var(name) refers to an associative array, the list in an assignment
 is interpreted as alternating keys and values:
 ifzman()
-indent(set -A var(name) var(key) var(value) ...)
+indent(tt(set -A) var(name) var(key) var(value) ...)
 indent(var(name)tt(=LPAR())var(key) var(value) ...tt(RPAR()))
 
 Every var(key) must have a var(value) in this case.  Note that this
@@ -282,14 +282,14 @@ pattern and the result is the first matching array element, substring or
 word (if the parameter is an array, if it is a scalar, or if it is a
 scalar and the `tt(w)' flag is given, respectively).  The subscript used
 is the number of the matching element, so that pairs of subscripts such as
-`tt($foo[(r))var(??)tt(,3])' and `tt($foo[(r))var(??)tt(,(r)f*])' are
+`tt($foo[(r)??,3])' and `tt($foo[(r)??,(r)f*])' are
 possible if the parameter is not an associative array.  If the
 parameter is an associative array, only the value part of each pair is
 compared to the pattern, and the result is that value.
 
 If a search through an ordinary array failed, the search sets the
 subscript to one past the end of the array, and hence
-tt(${array[(r)pattern]}) will substitute the empty string.  Thus the
+tt(${array[(r))var(pattern)tt(]}) will substitute the empty string.  Thus the
 success of a search can be tested by using the tt((i)) flag, for
 example (assuming the option tt(KSH_ARRAYS) is not in effect):
 
@@ -1075,8 +1075,8 @@ example, if the value is `tt(fc *)' then commands that invoke the
 interactive history editor are never written to the history file.
 
 Note that tt(HISTORY_IGNORE) defines a single pattern: to
-specify alternatives use the `tt(+LPAR()first|second|...+RPAR())'
-syntax.
+specify alternatives use the
+`tt(LPAR())var(first)tt(|)var(second)tt(|)var(...)tt(RPAR())' syntax.
 
 Compare the tt(HIST_NO_STORE) option or the tt(zshaddhistory) hook,
 either of which would prevent such commands from being added to the
@@ -1450,7 +1450,7 @@ sitem(tt(%W))(Number of times the process was swapped.)
 sitem(tt(%X))(The average amount in (shared) text space used in kilobytes.)
 sitem(tt(%D))(The average amount in (unshared) data/stack space used in
 kilobytes.)
-sitem(tt(%K))(The total space used (%X+%D) in kilobytes.)
+sitem(tt(%K))(The total space used (tt(%X)PLUS()tt(%D)) in kilobytes.)
 sitem(tt(%M))(The  maximum memory the process had in use at any time in
 megabytes.)
 sitem(tt(%F))(The number of major page faults (page needed to be brought
diff --git a/Doc/Zsh/redirect.yo b/Doc/Zsh/redirect.yo
index 8d231f40f..35fa773fd 100644
--- a/Doc/Zsh/redirect.yo
+++ b/Doc/Zsh/redirect.yo
@@ -155,7 +155,7 @@ ifnzman(noderef(Simple Commands & Pipelines))
 is a shorthand for `tt(2>&1 |)'.
 
 The various forms of process substitution, `tt(<LPAR())var(list)tt(RPAR())',
-and `tt(=LPAR())var(list)(RPAR())' for input and
+and `tt(=LPAR())var(list)tt(RPAR())' for input and
 `tt(>LPAR())var(list)tt(RPAR())' for output, are often used together with
 redirection.  For example, if var(word) in an output redirection is of the
 form `tt(>LPAR())var(list)tt(RPAR())' then the output is piped to the
@@ -176,7 +176,7 @@ is guaranteed to be at least 10 and set the parameter named by the
 identifier to the file descriptor opened.  No whitespace is allowed
 between the closing brace and the redirection character.  For example:
 
-indent(... {myfd}>&1)
+indent(... tt({myfd}>&1))
 
 This opens a new file descriptor that is a duplicate of file descriptor
 1 and sets the parameter tt(myfd) to the number of the file descriptor,
@@ -275,9 +275,10 @@ 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
 
-example(echo foo > bar > baz)
+example(echo Hello > bar > baz)
 
-when tt(MULTIOS) is unset will truncate bar, and write `tt(foo)' into baz.
+when tt(MULTIOS) is unset will truncate `tt(bar)', and write `tt(Hello)'
+into `tt(baz)'.
 
 There is a problem when an output multio is attached to an external
 program.  A simple example shows this:
diff --git a/Doc/Zsh/zle.yo b/Doc/Zsh/zle.yo
index 653678eba..e6f087fc7 100644
--- a/Doc/Zsh/zle.yo
+++ b/Doc/Zsh/zle.yo
@@ -25,12 +25,12 @@ vindex(BAUD, use of)
 vindex(COLUMNS, use of)
 vindex(LINES, use of)
 The parameters tt(BAUD), tt(COLUMNS), and tt(LINES) are also used by the
-line editor.
-ifzman(See em(Parameters Used By The Shell) in zmanref(zshparam))\
+line editor. See
+ifzman(em(Parameters Used By The Shell) in zmanref(zshparam))\
 ifnzman(noderef(Parameters Used By The Shell)).
 
-The parameter tt(zle_highlight) is also used by the line editor;
-ifzman(see em(Character Highlighting) below)\
+The parameter tt(zle_highlight) is also used by the line editor; see
+ifzman(em(Character Highlighting) below)\
 ifnzman(noderef(Character Highlighting)).  Highlighting
 of special characters and the region between the cursor and the
 mark (as set with tt(set-mark-command) in Emacs mode) is enabled
@@ -131,9 +131,9 @@ detect loops the process will be stopped if there are twenty such replacements
 without a real command being read.
 
 A key sequence typed by the user can be turned into a command name for use
-in user-defined widgets with the tt(read-command) widget, described
-ifzman(below)\
-ifnzman(in noderef(Miscellaneous) below)\
+in user-defined widgets with the tt(read-command) widget, described in
+ifzman(the subsection `Miscellaneous' of the section `Standard Widgets' below)\
+ifnzman(noderef(Miscellaneous) below)\
 .
 subsect(Local Keymaps)
 cindex(local keymaps)
@@ -409,7 +409,7 @@ xitem(tt(zle) tt(-K) var(keymap))
 xitem(tt(zle) tt(-F) [ tt(-L) | tt(-w) ] [ var(fd) [ var(handler) ] ])
 xitem(tt(zle) tt(-I))
 xitem(tt(zle) tt(-T) [ tt(tc) var(function) | tt(-r) tt(tc) | tt(-L) ] )
-item(tt(zle) var(widget) tt([ -n) var(num) tt(]) tt([ -Nw ] [ -K) var(keymap) tt(]) var(args) ...)(
+item(tt(zle) var(widget) [ tt(-n) var(num) ] [ tt(-Nw) ] [ tt(-K) var(keymap) ] var(args) ...)(
 The tt(zle) builtin performs a number of different actions concerning
 ZLE.
 
@@ -423,7 +423,7 @@ widgets.
 Otherwise, which operation it performs depends on its options:
 
 startitem()
-item(tt(-l) [ tt(-L) | tt(-a) ])(
+item(tt(-l) [ tt(-L) | tt(-a) ] [ var(string) ])(
 List all existing user-defined widgets.  If the tt(-L)
 option is used, list in the form of tt(zle)
 commands to create the widgets.
@@ -456,10 +456,9 @@ Create a user-defined widget.  If there is already a widget with the
 specified name, it is overwritten.  When the new
 widget is invoked from within the editor, the specified shell var(function)
 is called.  If no function name is specified, it defaults to
-the same name as the widget.  For further information, see the section
-em(Widgets) in
-ifzman(zmanref(zshzle))\
-ifnzman(noderef(Zsh Line Editor))\
+the same name as the widget.  For further information, see
+ifzman(the section `Widgets' below)\
+ifnzman(noderef(Zle Widgets))\
 .
 )
 cindex(completion widgets, creating)
@@ -607,9 +606,9 @@ restoring, hence the following will print output in such a way as not to
 disturb the line being edited:
 
 example(TRAPUSR1() {
-    # Invalidate zle display
+  # Invalidate zle display
   [[ -o zle ]] && zle -I
-    # Show output
+  # Show output
   print Hello
 })
 
@@ -656,12 +655,12 @@ optional argument for debugging or testing.  Note that this
 transformation is not applied to other non-printing characters such as
 carriage returns and newlines.
 )
-item(var(widget) tt([ -n) var(num) tt(]) tt([ -Nw ] [ -K) var(keymap) tt(]) var(args) ...)(
-Invoke the specified widget.  This can only be done when ZLE is
+item(var(widget) [ tt(-n) var(num) ] [ tt(-Nw) ] [ tt(-K) var(keymap) ] var(args) ...)(
+Invoke the specified var(widget).  This can only be done when ZLE is
 active; normally this will be within a user-defined widget.
 
 With the options tt(-n) and tt(-N), the current numeric argument will be
-saved and then restored after the call to tt(widget); `tt(-n) var(num)'
+saved and then restored after the call to var(widget); `tt(-n) var(num)'
 sets the numeric argument temporarily to var(num), while `tt(-N)' sets it
 to the default, i.e. as if there were none.
 
@@ -913,8 +912,8 @@ item(tt(REGION_ACTIVE) (integer))(
 Indicates if the region is currently active.  It can be assigned 0 or 1
 to deactivate and activate the region respectively. A value of 2
 activates the region in line-wise mode with the highlighted text
-extending for whole lines only;
-ifzman(see em(Character Highlighting) below)\
+extending for whole lines only; see
+ifzman(em(Character Highlighting) below)\
 ifnzman(noderef(Character Highlighting)).
 )
 vindex(region_highlight)
@@ -938,9 +937,9 @@ whitespace.)
 itemiz(An end offset in the same units as tt(CURSOR), terminated by
 whitespace.)
 itemiz(A highlight specification in the same format as
-used for contexts in the parameter tt(zle_highlight),
+used for contexts in the parameter tt(zle_highlight), see
 ifnzman(noderef(Character Highlighting))\
-ifzman(see Character Highlighting below);
+ifzman(the section `Character Highlighting' below);
 for example, tt(standout) or tt(fg=red,bold)).
 enditemize()
 
@@ -1096,25 +1095,25 @@ texinode(Movement)(History Control)()(Zle Widgets)
 subsect(Movement)
 startitem()
 tindex(vi-backward-blank-word)
-item(tt(vi-backward-blank-word) (unbound) (B) (unbound))(
+item(tt(vi-backward-blank-word) (unbound) (tt(B)) (unbound))(
 Move backward one word, where a word is defined as a series of
 non-blank characters.
 )
 tindex(vi-backward-blank-word-end)
-item(tt(vi-backward-blank-word-end) (unbound) (gE) (unbound))(
+item(tt(vi-backward-blank-word-end) (unbound) (tt(gE)) (unbound))(
 Move to the end of the previous word, where a word is defined as a
 series of non-blank characters.
 )
 tindex(backward-char)
-item(tt(backward-char) (^B ESC-[D) (unbound) (unbound))(
+item(tt(backward-char) (tt(^B ESC-[D)) (unbound) (unbound))(
 Move backward one character.
 )
 tindex(vi-backward-char)
-item(tt(vi-backward-char) (unbound) (^H h ^?) (ESC-[D))(
+item(tt(vi-backward-char) (unbound) (tt(^H h ^?)) (tt(ESC-[D)))(
 Move backward one character, without changing lines.
 )
 tindex(backward-word)
-item(tt(backward-word) (ESC-B ESC-b) (unbound) (unbound))(
+item(tt(backward-word) (tt(ESC-B ESC-b)) (unbound) (unbound))(
 Move to the beginning of the previous word.
 )
 tindex(emacs-backward-word)
@@ -1122,15 +1121,15 @@ item(tt(emacs-backward-word))(
 Move to the beginning of the previous word.
 )
 tindex(vi-backward-word)
-item(tt(vi-backward-word) (unbound) (b) (unbound))(
+item(tt(vi-backward-word) (unbound) (tt(b)) (unbound))(
 Move to the beginning of the previous word, vi-style.
 )
 tindex(vi-backward-word-end)
-item(tt(vi-backward-word-end) (unbound) (ge) (unbound))(
+item(tt(vi-backward-word-end) (unbound) (tt(ge)) (unbound))(
 Move to the end of the previous word, vi-style.
 )
 tindex(beginning-of-line)
-item(tt(beginning-of-line) (^A) (unbound) (unbound))(
+item(tt(beginning-of-line) (tt(^A)) (unbound) (unbound))(
 Move to the beginning of the line.  If already at the beginning
 of the line, move to the beginning of the previous line, if any.
 )
@@ -1143,65 +1142,65 @@ item(tt(down-line) (unbound) (unbound) (unbound))(
 Move down a line in the buffer.
 )
 tindex(end-of-line)
-item(tt(end-of-line) (^E) (unbound) (unbound))(
+item(tt(end-of-line) (tt(^E)) (unbound) (unbound))(
 Move to the end of the line.  If already at the end
 of the line, move to the end of the next line, if any.
 )
 tindex(vi-end-of-line)
-item(tt(vi-end-of-line) (unbound) ($) (unbound))(
+item(tt(vi-end-of-line) (unbound) (tt($)) (unbound))(
 Move to the end of the line.
 If an argument is given to this command, the cursor will be moved to
 the end of the line (argument - 1) lines down.
 )
 tindex(vi-forward-blank-word)
-item(tt(vi-forward-blank-word) (unbound) (W) (unbound))(
+item(tt(vi-forward-blank-word) (unbound) (tt(W)) (unbound))(
 Move forward one word, where a word is defined as a series of
 non-blank characters.
 )
 tindex(vi-forward-blank-word-end)
-item(tt(vi-forward-blank-word-end) (unbound) (E) (unbound))(
+item(tt(vi-forward-blank-word-end) (unbound) (tt(E)) (unbound))(
 Move to the end of the current word, or, if at the end of the current word,
 to the end of the next word,
 where a word is defined as a series of non-blank characters.
 )
 tindex(forward-char)
-item(tt(forward-char) (^F ESC-[C) (unbound) (unbound))(
+item(tt(forward-char) (tt(^F ESC-[C)) (unbound) (unbound))(
 Move forward one character.
 )
 tindex(vi-forward-char)
-item(tt(vi-forward-char) (unbound) (space l) (ESC-[C))(
+item(tt(vi-forward-char) (unbound) (tt(space l)) (tt(ESC-[C)))(
 Move forward one character.
 )
 tindex(vi-find-next-char)
-item(tt(vi-find-next-char) (^X^F) (f) (unbound))(
+item(tt(vi-find-next-char) (tt(^X^F)) (tt(f)) (unbound))(
 Read a character from the keyboard, and move to
 the next occurrence of it in the line.
 )
 tindex(vi-find-next-char-skip)
-item(tt(vi-find-next-char-skip) (unbound) (t) (unbound))(
+item(tt(vi-find-next-char-skip) (unbound) (tt(t)) (unbound))(
 Read a character from the keyboard, and move to
 the position just before the next occurrence of it in the line.
 )
 tindex(vi-find-prev-char)
-item(tt(vi-find-prev-char) (unbound) (F) (unbound))(
+item(tt(vi-find-prev-char) (unbound) (tt(F)) (unbound))(
 Read a character from the keyboard, and move to
 the previous occurrence of it in the line.
 )
 tindex(vi-find-prev-char-skip)
-item(tt(vi-find-prev-char-skip) (unbound) (T) (unbound))(
+item(tt(vi-find-prev-char-skip) (unbound) (tt(T)) (unbound))(
 Read a character from the keyboard, and move to
 the position just after the previous occurrence of it in the line.
 )
 tindex(vi-first-non-blank)
-item(tt(vi-first-non-blank) (unbound) (^) (unbound))(
+item(tt(vi-first-non-blank) (unbound) (tt(^)) (unbound))(
 Move to the first non-blank character in the line.
 )
 tindex(vi-forward-word)
-item(tt(vi-forward-word) (unbound) (w) (unbound))(
+item(tt(vi-forward-word) (unbound) (tt(w)) (unbound))(
 Move forward one word, vi-style.
 )
 tindex(forward-word)
-item(tt(forward-word) (ESC-F ESC-f) (unbound) (unbound))(
+item(tt(forward-word) (tt(ESC-F ESC-f)) (unbound) (unbound))(
 Move to the beginning of the next word.
 The editor's idea of a word is specified with the tt(WORDCHARS)
 parameter.
@@ -1211,27 +1210,27 @@ item(tt(emacs-forward-word))(
 Move to the end of the next word.
 )
 tindex(vi-forward-word-end)
-item(tt(vi-forward-word-end) (unbound) (e) (unbound))(
+item(tt(vi-forward-word-end) (unbound) (tt(e)) (unbound))(
 Move to the end of the next word.
 )
 tindex(vi-goto-column)
-item(tt(vi-goto-column) (ESC-|) (|) (unbound))(
+item(tt(vi-goto-column) (tt(ESC-|)) (tt(|)) (unbound))(
 Move to the column specified by the numeric argument.
 )
 tindex(vi-goto-mark)
-item(tt(vi-goto-mark) (unbound) (`) (unbound))(
+item(tt(vi-goto-mark) (unbound) (tt(`)) (unbound))(
 Move to the specified mark.
 )
 tindex(vi-goto-mark-line)
-item(tt(vi-goto-mark-line) (unbound) (') (unbound))(
+item(tt(vi-goto-mark-line) (unbound) (tt(')) (unbound))(
 Move to beginning of the line containing the specified mark.
 )
 tindex(vi-repeat-find)
-item(tt(vi-repeat-find) (unbound) (;) (unbound))(
+item(tt(vi-repeat-find) (unbound) (tt(;)) (unbound))(
 Repeat the last tt(vi-find) command.
 )
 tindex(vi-rev-repeat-find)
-item(tt(vi-rev-repeat-find) (unbound) (,) (unbound))(
+item(tt(vi-rev-repeat-find) (unbound) (tt(,)) (unbound))(
 Repeat the last tt(vi-find) command in the opposite direction.
 )
 tindex(up-line)
@@ -1243,7 +1242,7 @@ texinode(History Control)(Modifying Text)(Movement)(Zle Widgets)
 subsect(History Control)
 startitem()
 tindex(beginning-of-buffer-or-history)
-item(tt(beginning-of-buffer-or-history) (ESC-<) (gg) (unbound))(
+item(tt(beginning-of-buffer-or-history) (tt(ESC-<)) (tt(gg)) (unbound))(
 Move to the beginning of the buffer, or if already there,
 move to the first event in the history list.
 )
@@ -1257,12 +1256,12 @@ item(tt(beginning-of-history))(
 Move to the first event in the history list.
 )
 tindex(down-line-or-history)
-item(tt(down-line-or-history) (^N ESC-[B) (j) (ESC-[B))(
+item(tt(down-line-or-history) (tt(^N ESC-[B)) (tt(j)) (tt(ESC-[B)))(
 Move down a line in the buffer, or if already at the bottom line,
 move to the next event in the history list.
 )
 tindex(vi-down-line-or-history)
-item(tt(vi-down-line-or-history) (unbound) (PLUS()) (unbound))(
+item(tt(vi-down-line-or-history) (unbound) (tt(PLUS())) (unbound))(
 Move down a line in the buffer, or if already at the bottom line,
 move to the next event in the history list.
 Then move to the first non-blank character on the line.
@@ -1278,7 +1277,7 @@ argument is taken as the string for which to search, rather than the
 first word in the buffer.
 )
 tindex(down-history)
-item(tt(down-history) (unbound) (^N) (unbound))(
+item(tt(down-history) (unbound) (tt(^N)) (unbound))(
 Move to the next event in the history list.
 )
 tindex(history-beginning-search-backward)
@@ -1288,7 +1287,7 @@ line up to the cursor.
 This leaves the cursor in its original position.
 )
 tindex(end-of-buffer-or-history)
-item(tt(end-of-buffer-or-history) (ESC->) (unbound) (unbound))(
+item(tt(end-of-buffer-or-history) (tt(ESC->)) (unbound) (unbound))(
 Move to the end of the buffer, or if already there,
 move to the last event in the history list.
 )
@@ -1302,13 +1301,13 @@ item(tt(end-of-history))(
 Move to the last event in the history list.
 )
 tindex(vi-fetch-history)
-item(tt(vi-fetch-history) (unbound) (G) (unbound))(
+item(tt(vi-fetch-history) (unbound) (tt(G)) (unbound))(
 Fetch the history line specified by the numeric argument.
 This defaults to the current history line
 (i.e. the one that isn't history yet).
 )
 tindex(history-incremental-search-backward)
-item(tt(history-incremental-search-backward) (^R ^Xr) (unbound) (unbound))(
+item(tt(history-incremental-search-backward) (tt(^R ^Xr)) (unbound) (unbound))(
 Search backward incrementally for a specified string.  The search is
 case-insensitive if the search string does not have uppercase letters and no
 numeric argument was given.  The string may begin with `tt(^)' to anchor the
@@ -1406,7 +1405,7 @@ will search backwards for tt(forceps), leaving the minibuffer containing
 the string `tt(forceps)'.
 )
 tindex(history-incremental-search-forward)
-item(tt(history-incremental-search-forward) (^S ^Xs) (unbound) (unbound))(
+item(tt(history-incremental-search-forward) (tt(^S ^Xs)) (unbound) (unbound))(
 Search forward incrementally for a specified string.  The search is
 case-insensitive if the search string does not have uppercase letters and no
 numeric argument was given.  The string may begin with `tt(^)' to anchor the
@@ -1435,7 +1434,7 @@ with wildcards may return fewer matches on a line than are visible
 by inspection.
 )
 tindex(history-search-backward)
-item(tt(history-search-backward) (ESC-P ESC-p) (unbound) (unbound))(
+item(tt(history-search-backward) (tt(ESC-P ESC-p)) (unbound) (unbound))(
 Search backward in the history for a line beginning with the first
 word in the buffer.
 
@@ -1444,7 +1443,7 @@ argument is taken as the string for which to search, rather than the
 first word in the buffer.
 )
 tindex(vi-history-search-backward)
-item(tt(vi-history-search-backward) (unbound) (/) (unbound))(
+item(tt(vi-history-search-backward) (unbound) (tt(/)) (unbound))(
 Search backward in the history for a specified string.
 The string may begin with `tt(^)' to anchor the search to the
 beginning of the line.
@@ -1475,7 +1474,7 @@ argument is taken as the string for which to search, rather than the
 first word in the buffer.
 )
 tindex(history-search-forward)
-item(tt(history-search-forward) (ESC-N ESC-n) (unbound) (unbound))(
+item(tt(history-search-forward) (tt(ESC-N ESC-n)) (unbound) (unbound))(
 Search forward in the history for a line beginning with the first
 word in the buffer.
 
@@ -1484,7 +1483,7 @@ argument is taken as the string for which to search, rather than the
 first word in the buffer.
 )
 tindex(vi-history-search-forward)
-item(tt(vi-history-search-forward) (unbound) (?) (unbound))(
+item(tt(vi-history-search-forward) (unbound) (tt(?)) (unbound))(
 Search forward in the history for a specified string.
 The string may begin with `tt(^)' to anchor the search to the
 beginning of the line. The functions available in the mini-buffer are the same
@@ -1492,12 +1491,12 @@ as for tt(vi-history-search-backward).  Argument handling is also the same
 as for that command.
 )
 tindex(infer-next-history)
-item(tt(infer-next-history) (^X^N) (unbound) (unbound))(
+item(tt(infer-next-history) (tt(^X^N)) (unbound) (unbound))(
 Search in the history list for a line matching the current one and
 fetch the event following it.
 )
 tindex(insert-last-word)
-item(tt(insert-last-word) (ESC-_ ESC-.) (unbound) (unbound))(
+item(tt(insert-last-word) (tt(ESC-_ ESC-.)) (unbound) (unbound))(
 Insert the last word from the previous history event at the
 cursor position.  If a positive numeric argument is given,
 insert that word from the end of the previous history event.
@@ -1539,20 +1538,20 @@ the line being edited.  This has the side effect that later invocations of
 the widget will be relative to that line.
 )
 tindex(vi-repeat-search)
-item(tt(vi-repeat-search) (unbound) (n) (unbound))(
+item(tt(vi-repeat-search) (unbound) (tt(n)) (unbound))(
 Repeat the last vi history search.
 )
 tindex(vi-rev-repeat-search)
-item(tt(vi-rev-repeat-search) (unbound) (N) (unbound))(
+item(tt(vi-rev-repeat-search) (unbound) (tt(N)) (unbound))(
 Repeat the last vi history search, but in reverse.
 )
 tindex(up-line-or-history)
-item(tt(up-line-or-history) (^P ESC-[A) (k) (ESC-[A))(
+item(tt(up-line-or-history) (tt(^P ESC-[A)) (tt(k)) (tt(ESC-[A)))(
 Move up a line in the buffer, or if already at the top line,
 move to the previous event in the history list.
 )
 tindex(vi-up-line-or-history)
-item(tt(vi-up-line-or-history) (unbound) (-) (unbound))(
+item(tt(vi-up-line-or-history) (unbound) (tt(-)) (unbound))(
 Move up a line in the buffer, or if already at the top line,
 move to the previous event in the history list.
 Then move to the first non-blank character on the line.
@@ -1568,7 +1567,7 @@ argument is taken as the string for which to search, rather than the
 first word in the buffer.
 )
 tindex(up-history)
-item(tt(up-history) (unbound) (^P) (unbound))(
+item(tt(up-history) (unbound) (tt(^P)) (unbound))(
 Move to the previous event in the history list.
 )
 tindex(history-beginning-search-forward)
@@ -1589,19 +1588,19 @@ texinode(Modifying Text)(Arguments)(History Control)(Zle Widgets)
 subsect(Modifying Text)
 startitem()
 tindex(vi-add-eol)
-item(tt(vi-add-eol) (unbound) (A) (unbound))(
+item(tt(vi-add-eol) (unbound) (tt(A)) (unbound))(
 Move to the end of the line and enter insert mode.
 )
 tindex(vi-add-next)
-item(tt(vi-add-next) (unbound) (a) (unbound))(
+item(tt(vi-add-next) (unbound) (tt(a)) (unbound))(
 Enter insert mode after the current cursor position, without changing lines.
 )
 tindex(backward-delete-char)
-item(tt(backward-delete-char) (^H ^?) (unbound) (unbound))(
+item(tt(backward-delete-char) (tt(^H ^?)) (unbound) (unbound))(
 Delete the character behind the cursor.
 )
 tindex(vi-backward-delete-char)
-item(tt(vi-backward-delete-char) (unbound) (X) (^H))(
+item(tt(vi-backward-delete-char) (unbound) (tt(X)) (tt(^H)))(
 Delete the character behind the cursor, without changing lines.
 If in insert mode, this won't delete past the point where insert mode was
 last entered.
@@ -1615,20 +1614,20 @@ item(tt(backward-kill-line))(
 Kill from the beginning of the line to the cursor position.
 )
 tindex(backward-kill-word)
-item(tt(backward-kill-word) (^W ESC-^H ESC-^?) (unbound) (unbound))(
+item(tt(backward-kill-word) (tt(^W ESC-^H ESC-^?)) (unbound) (unbound))(
 Kill the word behind the cursor.
 )
 tindex(vi-backward-kill-word)
-item(tt(vi-backward-kill-word) (unbound) (unbound) (^W))(
+item(tt(vi-backward-kill-word) (unbound) (unbound) (tt(^W)))(
 Kill the word behind the cursor, without going past the point where insert
 mode was last entered.
 )
 tindex(capitalize-word)
-item(tt(capitalize-word) (ESC-C ESC-c) (unbound) (unbound))(
+item(tt(capitalize-word) (tt(ESC-C ESC-c)) (unbound) (unbound))(
 Capitalize the current word and move past it.
 )
 tindex(vi-change)
-item(tt(vi-change) (unbound) (c) (unbound))(
+item(tt(vi-change) (unbound) (tt(c)) (unbound))(
 Read a movement command from the keyboard, and kill
 from the cursor position to the endpoint of the movement.
 Then enter insert mode.
@@ -1642,15 +1641,15 @@ whitespace included use the following key binding:
 example(bindkey -a -s cw dwi)
 )
 tindex(vi-change-eol)
-item(tt(vi-change-eol) (unbound) (C) (unbound))(
+item(tt(vi-change-eol) (unbound) (tt(C)) (unbound))(
 Kill to the end of the line and enter insert mode.
 )
 tindex(vi-change-whole-line)
-item(tt(vi-change-whole-line) (unbound) (S) (unbound))(
+item(tt(vi-change-whole-line) (unbound) (tt(S)) (unbound))(
 Kill the current line and enter insert mode.
 )
 tindex(copy-region-as-kill)
-item(tt(copy-region-as-kill) (ESC-W ESC-w) (unbound) (unbound))(
+item(tt(copy-region-as-kill) (tt(ESC-W ESC-w)) (unbound) (unbound))(
 Copy the area from the cursor to the mark to the kill buffer.
 
 If called from a ZLE widget function in the form `tt(zle
@@ -1659,7 +1658,7 @@ text to copy to the kill buffer.  The cursor, the mark and the text on the
 command line are not used in this case.
 )
 tindex(copy-prev-word)
-item(tt(copy-prev-word) (ESC-^_) (unbound) (unbound))(
+item(tt(copy-prev-word) (tt(ESC-^_)) (unbound) (unbound))(
 Duplicate the word to the left of the cursor.
 )
 tindex(copy-prev-shell-word)
@@ -1669,7 +1668,7 @@ whereas tt(copy-prev-word) looks for blanks. This makes a difference
 when the word is quoted and contains spaces.
 )
 tindex(vi-delete)
-item(tt(vi-delete) (unbound) (d) (unbound))(
+item(tt(vi-delete) (unbound) (tt(d)) (unbound))(
 Read a movement command from the keyboard, and kill
 from the cursor position to the endpoint of the movement.
 If the command is tt(vi-delete), kill the current line.
@@ -1679,7 +1678,7 @@ item(tt(delete-char))(
 Delete the character under the cursor.
 )
 tindex(vi-delete-char)
-item(tt(vi-delete-char) (unbound) (x) (unbound))(
+item(tt(vi-delete-char) (unbound) (tt(x)) (unbound))(
 Delete the character under the cursor,
 without going past the end of the line.
 )
@@ -1688,11 +1687,11 @@ item(tt(delete-word))(
 Delete the current word.
 )
 tindex(down-case-word)
-item(tt(down-case-word) (ESC-L ESC-l) (unbound) (unbound))(
+item(tt(down-case-word) (tt(ESC-L ESC-l)) (unbound) (unbound))(
 Convert the current word to all lowercase and move past it.
 )
 tindex(kill-word)
-item(tt(kill-word) (ESC-D ESC-d) (unbound) (unbound))(
+item(tt(kill-word) (tt(ESC-D ESC-d)) (unbound) (unbound))(
 Kill the current word.
 )
 tindex(gosmacs-transpose-chars)
@@ -1700,32 +1699,32 @@ item(tt(gosmacs-transpose-chars))(
 Exchange the two characters behind the cursor.
 )
 tindex(vi-indent)
-item(tt(vi-indent) (unbound) (>) (unbound))(
+item(tt(vi-indent) (unbound) (tt(>)) (unbound))(
 Indent a number of lines.
 )
 tindex(vi-insert)
-item(tt(vi-insert) (unbound) (i) (unbound))(
+item(tt(vi-insert) (unbound) (tt(i)) (unbound))(
 Enter insert mode.
 )
 tindex(vi-insert-bol)
-item(tt(vi-insert-bol) (unbound) (I) (unbound))(
+item(tt(vi-insert-bol) (unbound) (tt(I)) (unbound))(
 Move to the first non-blank character on the line and enter insert mode.
 )
 tindex(vi-join)
-item(tt(vi-join) (^X^J) (J) (unbound))(
+item(tt(vi-join) (tt(^X^J)) (tt(J)) (unbound))(
 Join the current line with the next one.
 )
 tindex(kill-line)
-item(tt(kill-line) (^K) (unbound) (unbound))(
+item(tt(kill-line) (tt(^K)) (unbound) (unbound))(
 Kill from the cursor to the end of the line.
 If already on the end of the line, kill the newline character.
 )
 tindex(vi-kill-line)
-item(tt(vi-kill-line) (unbound) (unbound) (^U))(
+item(tt(vi-kill-line) (unbound) (unbound) (tt(^U)))(
 Kill from the cursor back to wherever insert mode was last entered.
 )
 tindex(vi-kill-eol)
-item(tt(vi-kill-eol) (unbound) (D) (unbound))(
+item(tt(vi-kill-eol) (unbound) (tt(D)) (unbound))(
 Kill from the cursor to the end of the line.
 )
 tindex(kill-region)
@@ -1733,30 +1732,30 @@ item(tt(kill-region))(
 Kill from the cursor to the mark.
 )
 tindex(kill-buffer)
-item(tt(kill-buffer) (^X^K) (unbound) (unbound))(
+item(tt(kill-buffer) (tt(^X^K)) (unbound) (unbound))(
 Kill the entire buffer.
 )
 tindex(kill-whole-line)
-item(tt(kill-whole-line) (^U) (unbound) (unbound))(
+item(tt(kill-whole-line) (tt(^U)) (unbound) (unbound))(
 Kill the current line.
 )
 tindex(vi-match-bracket)
-item(tt(vi-match-bracket) (^X^B) (%) (unbound))(
+item(tt(vi-match-bracket) (tt(^X^B)) (tt(%)) (unbound))(
 Move to the bracket character (one of tt({}), tt(()) or tt([])) that
 matches the one under the cursor.
 If the cursor is not on a bracket character, move forward without going
 past the end of the line to find one, and then go to the matching bracket.
 )
 tindex(vi-open-line-above)
-item(tt(vi-open-line-above) (unbound) (O) (unbound))(
+item(tt(vi-open-line-above) (unbound) (tt(O)) (unbound))(
 Open a line above the cursor and enter insert mode.
 )
 tindex(vi-open-line-below)
-item(tt(vi-open-line-below) (unbound) (o) (unbound))(
+item(tt(vi-open-line-below) (unbound) (tt(o)) (unbound))(
 Open a line below the cursor and enter insert mode.
 )
 tindex(vi-oper-swap-case)
-item(tt(vi-oper-swap-case) (unbound) (g~) (unbound))(
+item(tt(vi-oper-swap-case) (unbound) (tt(g~)) (unbound))(
 Read a movement command from the keyboard, and swap
 the case of all characters
 from the cursor position to the endpoint of the movement.
@@ -1764,17 +1763,17 @@ If the movement command is tt(vi-oper-swap-case),
 swap the case of all characters on the current line.
 )
 tindex(overwrite-mode)
-item(tt(overwrite-mode) (^X^O) (unbound) (unbound))(
+item(tt(overwrite-mode) (tt(^X^O)) (unbound) (unbound))(
 Toggle between overwrite mode and insert mode.
 )
 tindex(vi-put-before)
-item(tt(vi-put-before) (unbound) (P) (unbound))(
+item(tt(vi-put-before) (unbound) (tt(P)) (unbound))(
 Insert the contents of the kill buffer before the cursor.
 If the kill buffer contains a sequence of lines (as opposed to characters),
 paste it above the current line.
 )
 tindex(vi-put-after)
-item(tt(vi-put-after) (unbound) (p) (unbound))(
+item(tt(vi-put-after) (unbound) (tt(p)) (unbound))(
 Insert the contents of the kill buffer after the cursor.
 If the kill buffer contains a sequence of lines (as opposed to characters),
 paste it below the current line.
@@ -1787,32 +1786,32 @@ lines (as opposed to characters), the current line will be split by the
 pasted lines.
 )
 tindex(quoted-insert)
-item(tt(quoted-insert) (^V) (unbound) (unbound))(
+item(tt(quoted-insert) (tt(^V)) (unbound) (unbound))(
 Insert the next character typed into the buffer literally.
 An interrupt character will not be inserted.
 )
 tindex(vi-quoted-insert)
-item(tt(vi-quoted-insert) (unbound) (unbound) (^Q ^V))(
+item(tt(vi-quoted-insert) (unbound) (unbound) (tt(^Q ^V)))(
 Display a `tt(^)' at the cursor position, and
 insert the next character typed into the buffer literally.
 An interrupt character will not be inserted.
 )
 tindex(quote-line)
-item(tt(quote-line) (ESC-') (unbound) (unbound))(
+item(tt(quote-line) (tt(ESC-')) (unbound) (unbound))(
 Quote the current line; that is, put a `tt(')' character at the
 beginning and the end, and convert all `tt(')' characters
 to `tt('\'')'.
 )
 tindex(quote-region)
-item(tt(quote-region) (ESC-") (unbound) (unbound))(
+item(tt(quote-region) (tt(ESC-")) (unbound) (unbound))(
 Quote the region from the cursor to the mark.
 )
 tindex(vi-replace)
-item(tt(vi-replace) (unbound) (R) (unbound))(
+item(tt(vi-replace) (unbound) (tt(R)) (unbound))(
 Enter overwrite mode.
 )
 tindex(vi-repeat-change)
-item(tt(vi-repeat-change) (unbound) (.) (unbound))(
+item(tt(vi-repeat-change) (unbound) (tt(.)) (unbound))(
 Repeat the last vi mode text modification.
 If a count was used with the modification, it is remembered.
 If a count is given to this command, it overrides the remembered count,
@@ -1820,7 +1819,7 @@ and is remembered for future uses of this command.
 The cut buffer specification is similarly remembered.
 )
 tindex(vi-replace-chars)
-item(tt(vi-replace-chars) (unbound) (r) (unbound))(
+item(tt(vi-replace-chars) (unbound) (tt(r)) (unbound))(
 Replace the character under the cursor with a character
 read from the keyboard.
 )
@@ -1829,56 +1828,56 @@ item(tt(self-insert) (printable characters) (unbound) (printable characters and
 Insert a character into the buffer at the cursor position.
 )
 tindex(self-insert-unmeta)
-item(tt(self-insert-unmeta) (ESC-^I ESC-^J ESC-^M) (unbound) (unbound))(
+item(tt(self-insert-unmeta) (tt(ESC-^I ESC-^J ESC-^M)) (unbound) (unbound))(
 Insert a character into the buffer after stripping the meta bit
 and converting ^M to ^J.
 )
 tindex(vi-substitute)
-item(tt(vi-substitute) (unbound) (s) (unbound))(
+item(tt(vi-substitute) (unbound) (tt(s)) (unbound))(
 Substitute the next characte+CHAR(r)(s).
 )
 tindex(vi-swap-case)
-item(tt(vi-swap-case) (unbound) (~) (unbound))(
+item(tt(vi-swap-case) (unbound) (tt(~)) (unbound))(
 Swap the case of the character under the cursor and move past it.
 )
 tindex(transpose-chars)
-item(tt(transpose-chars) (^T) (unbound) (unbound))(
+item(tt(transpose-chars) (tt(^T)) (unbound) (unbound))(
 Exchange the two characters to the left of the
 cursor if at end of line, else exchange the
 character under the cursor with the character
 to the left.
 )
 tindex(transpose-words)
-item(tt(transpose-words) (ESC-T ESC-t) (unbound) (unbound))(
+item(tt(transpose-words) (tt(ESC-T ESC-t)) (unbound) (unbound))(
 Exchange the current word with the one before it.
 )
 tindex(vi-unindent)
-item(tt(vi-unindent) (unbound) (<) (unbound))(
+item(tt(vi-unindent) (unbound) (tt(<)) (unbound))(
 Unindent a number of lines.
 )
 tindex(up-case-word)
-item(tt(up-case-word) (ESC-U ESC-u) (unbound) (unbound))(
+item(tt(up-case-word) (tt(ESC-U ESC-u)) (unbound) (unbound))(
 Convert the current word to all caps and move past it.
 )
 tindex(yank)
-item(tt(yank) (^Y) (unbound) (unbound))(
+item(tt(yank) (tt(^Y)) (unbound) (unbound))(
 Insert the contents of the kill buffer at the cursor position.
 )
 tindex(yank-pop)
-item(tt(yank-pop) (ESC-y) (unbound) (unbound))(
+item(tt(yank-pop) (tt(ESC-y)) (unbound) (unbound))(
 Remove the text just yanked, rotate the kill-ring (the history of
 previously killed text) and yank the new top.  Only works following
 tt(yank), tt(vi-put-before), tt(vi-put-after) or tt(yank-pop).
 )
 tindex(vi-yank)
-item(tt(vi-yank) (unbound) (y) (unbound))(
+item(tt(vi-yank) (unbound) (tt(y)) (unbound))(
 Read a movement command from the keyboard, and copy the region
 from the cursor position to the endpoint of the movement
 into the kill buffer.
 If the command is tt(vi-yank), copy the current line.
 )
 tindex(vi-yank-whole-line)
-item(tt(vi-yank-whole-line) (unbound) (Y) (unbound))(
+item(tt(vi-yank-whole-line) (unbound) (tt(Y)) (unbound))(
 Copy the current line into the kill buffer.
 )
 tindex(vi-yank-eol)
@@ -1892,7 +1891,7 @@ texinode(Arguments)(Completion)(Modifying Text)(Zle Widgets)
 subsect(Arguments)
 startitem()
 tindex(digit-argument)
-item(tt(digit-argument) (ESC-0..ESC-9) (1-9) (unbound))(
+item(tt(digit-argument) (tt(ESC-0)..tt(ESC-9)) (tt(1)-tt(9)) (unbound))(
 Start a new numeric argument, or add to the current one.
 See also tt(vi-digit-or-beginning-of-line).  This only works if bound to a
 key sequence ending in a decimal digit.
@@ -1901,7 +1900,7 @@ Inside a widget function, a call to this function treats the last key of
 the key sequence which called the widget as the digit.
 )
 tindex(neg-argument)
-item(tt(neg-argument) (ESC-DASH()) (unbound) (unbound))(
+item(tt(neg-argument) (tt(ESC-)tt(-)) (unbound) (unbound))(
 Changes the sign of the following argument.
 )
 tindex(universal-argument)
@@ -1949,7 +1948,7 @@ item(tt(complete-word))(
 Attempt completion on the current word.
 )
 tindex(delete-char-or-list)
-item(tt(delete-char-or-list) (^D) (unbound) (unbound))(
+item(tt(delete-char-or-list) (tt(^D)) (unbound) (unbound))(
 Delete the character under the cursor.  If the cursor
 is at the end of the line, list possible completions for the
 current word.
@@ -1959,7 +1958,7 @@ item(tt(expand-cmd-path))(
 Expand the current command to its full pathname.
 )
 tindex(expand-or-complete)
-item(tt(expand-or-complete) (TAB) (unbound) (TAB))(
+item(tt(expand-or-complete) (tt(TAB)) (unbound) (tt(TAB)))(
 Attempt shell expansion on the current word.
 If that fails,
 attempt completion.
@@ -1969,19 +1968,19 @@ item(tt(expand-or-complete-prefix))(
 Attempt shell expansion on the current word up to cursor.
 )
 tindex(expand-history)
-item(tt(expand-history) (ESC-space ESC-!) (unbound) (unbound))(
+item(tt(expand-history) (tt(ESC-space ESC-!)) (unbound) (unbound))(
 Perform history expansion on the edit buffer.
 )
 tindex(expand-word)
-item(tt(expand-word) (^X*) (unbound) (unbound))(
+item(tt(expand-word) (tt(^X*)) (unbound) (unbound))(
 Attempt shell expansion on the current word.
 )
 tindex(list-choices)
-item(tt(list-choices) (ESC-^D) (^D =) (^D))(
+item(tt(list-choices) (tt(ESC-^D)) (tt(^D =)) (tt(^D)))(
 List possible completions for the current word.
 )
 tindex(list-expand)
-item(tt(list-expand) (^Xg ^XG) (^G) (^G))(
+item(tt(list-expand) (tt(^Xg ^XG)) (tt(^G)) (tt(^G)))(
 List the expansion of the current word.
 )
 tindex(magic-space)
@@ -2015,7 +2014,7 @@ texinode(Miscellaneous)(Text Objects)(Completion)(Zle Widgets)
 subsect(Miscellaneous)
 startitem()
 tindex(accept-and-hold)
-item(tt(accept-and-hold) (ESC-A ESC-a) (unbound) (unbound))(
+item(tt(accept-and-hold) (tt(ESC-A ESC-a)) (unbound) (unbound))(
 Push the contents of the buffer on the buffer stack
 and execute it.
 )
@@ -2026,12 +2025,12 @@ Then search the history list for a line matching the current one
 and push the event following onto the buffer stack.
 )
 tindex(accept-line)
-item(tt(accept-line) (^J ^M) (^J ^M) (^J ^M))(
+item(tt(accept-line) (tt(^J ^M)) (tt(^J ^M)) (tt(^J ^M)))(
 Finish editing the buffer.  Normally this causes the buffer to be
 executed as a shell command.
 )
 tindex(accept-line-and-down-history)
-item(tt(accept-line-and-down-history) (^O) (unbound) (unbound))(
+item(tt(accept-line-and-down-history) (tt(^O)) (unbound) (unbound))(
 Execute the current line, and push the next history
 event on the buffer stack.
 )
@@ -2058,7 +2057,7 @@ item(tt(beep))(
 Beep, unless the tt(BEEP) option is unset.
 )
 tindex(vi-cmd-mode)
-item(tt(vi-cmd-mode) (^X^V) (unbound) (^[))(
+item(tt(vi-cmd-mode) (tt(^X^V)) (unbound) (tt(^[)))(
 Enter command mode; that is, select the `tt(vicmd)' keymap.
 Yes, this is bound by default in emacs mode.
 )
@@ -2069,7 +2068,7 @@ This is for vi users without the mental capacity to keep
 track of their caps lock key (like the author).
 )
 tindex(clear-screen)
-item(tt(clear-screen) (^L ESC-^L) (^L) (^L))(
+item(tt(clear-screen) (tt(^L ESC-^L)) (tt(^L)) (tt(^L)))(
 Clear the screen and redraw the prompt.
 )
 tindex(describe-key-briefly)
@@ -2077,7 +2076,7 @@ item(tt(describe-key-briefly))(
 Reads a key sequence, then prints the function bound to that sequence.
 )
 tindex(exchange-point-and-mark)
-item(tt(exchange-point-and-mark) (^X^X) (unbound) (unbound))(
+item(tt(exchange-point-and-mark) (tt(^X^X)) (unbound) (unbound))(
 Exchange the cursor position (point) with the position of the mark.
 Unless a negative numeric argument is given, the region between
 point and mark is activated so that it can be highlighted.
@@ -2085,7 +2084,7 @@ If a zero numeric argument is given, the region is activated but
 point and mark are not swapped.
 )
 tindex(execute-named-cmd)
-item(tt(execute-named-cmd) (ESC-x) (:) (unbound))(
+item(tt(execute-named-cmd) (tt(ESC-x)) (tt(:)) (unbound))(
 Read the name of an editor command and
 execute it.  A restricted set of editing functions is available in the
 mini-buffer.  Keys are looked up in the special
@@ -2125,18 +2124,18 @@ The bindings of the current insert mode will be used.
 Currently this command may not be redefined or called by name.
 )
 tindex(execute-last-named-cmd)
-item(tt(execute-last-named-cmd) (ESC-z) (unbound) (unbound))(
+item(tt(execute-last-named-cmd) (tt(ESC-z)) (unbound) (unbound))(
 Redo the last function executed with tt(execute-named-cmd).
 
 Currently this command may not be redefined or called by name.
 )
 tindex(get-line)
-item(tt(get-line) (ESC-G ESC-g) (unbound) (unbound))(
+item(tt(get-line) (tt(ESC-G ESC-g)) (unbound) (unbound))(
 Pop the top line off the buffer stack and insert it at the
 cursor position.
 )
 tindex(pound-insert)
-item(tt(pound-insert) (unbound) (#) (unbound))(
+item(tt(pound-insert) (unbound) (tt(#)) (unbound))(
 If there is no # character at the beginning of the buffer,
 add one to the beginning of each line.
 If there is one, remove a # from each line that has one.
@@ -2162,7 +2161,7 @@ construct will be popped off the top of the buffer stack and loaded
 into the editing buffer.
 )
 tindex(push-line)
-item(tt(push-line) (^Q ESC-Q ESC-q) (unbound) (unbound))(
+item(tt(push-line) (tt(^Q ESC-Q ESC-q)) (unbound) (unbound))(
 Push the current buffer onto the buffer stack and clear
 the buffer.
 Next time the editor starts up, the buffer will be popped
@@ -2229,7 +2228,7 @@ recursive edit is detected as a non-zero return status and propagated by
 using the tt(send-break) widget.
 )
 tindex(redisplay)
-item(tt(redisplay) (unbound) (^R) (^R))(
+item(tt(redisplay) (unbound) (tt(^R)) (tt(^R)))(
 Redisplays the edit buffer.
 )
 tindex(reset-prompt)
@@ -2247,7 +2246,7 @@ shell (such as a job notification) which causes the command line to be
 reprinted.
 )
 tindex(send-break)
-item(tt(send-break) (^G ESC-^G) (unbound) (unbound))(
+item(tt(send-break) (tt(^G ESC-^G)) (unbound) (unbound))(
 Abort the current editor function, e.g. tt(execute-named-command), or the
 editor itself, e.g. if you are in tt(vared). Otherwise abort the parsing of
 the current line; in this case the aborted line is available in the shell
@@ -2255,13 +2254,13 @@ variable tt(ZLE_LINE_ABORTED).  If the editor is aborted from within
 tt(vared), the variable tt(ZLE_VARED_ABORTED) is set.
 )
 tindex(run-help)
-item(tt(run-help) (ESC-H ESC-h) (unbound) (unbound))(
+item(tt(run-help) (tt(ESC-H ESC-h)) (unbound) (unbound))(
 Push the buffer onto the buffer stack, and execute the
 command `tt(run-help) var(cmd)', where var(cmd) is the current
 command.  tt(run-help) is normally aliased to tt(man).
 )
 tindex(vi-set-buffer)
-item(tt(vi-set-buffer) (unbound) (") (unbound))(
+item(tt(vi-set-buffer) (unbound) (tt(")) (unbound))(
 Specify a buffer to be used in the following command.
 There are 37 buffers that can be specified:
 the 26 `named' buffers tt("a) to tt("z), the `yank' buffer tt("0),
@@ -2278,7 +2277,7 @@ affecting the normal registers.
 If no buffer is specified for a cut or change command, tt("1) is used, and
 the contents of tt("1) to tt("8) are each shifted along one buffer;
 the contents of tt("9) is lost. If no buffer is specified for a yank
-command, tt("0") is used. Finally, a paste command without a specified
+command, tt("0) is used. Finally, a paste command without a specified
 buffer will paste the text from the most recent command regardless of any
 buffer that might have been used with that command.
 
@@ -2288,18 +2287,18 @@ can optionally be specified with an argument. For example,
 example(zle vi-set-buffer A)
 )
 tindex(vi-set-mark)
-item(tt(vi-set-mark) (unbound) (m) (unbound))(
+item(tt(vi-set-mark) (unbound) (tt(m)) (unbound))(
 Set the specified mark at the cursor position.
 )
 tindex(set-mark-command)
-item(tt(set-mark-command) (^@) (unbound) (unbound))(
+item(tt(set-mark-command) (tt(^@)) (unbound) (unbound))(
 Set the mark at the cursor position.  If called with a negative
 numeric argument, do not set the mark but deactivate the region so that
 it is no longer highlighted (it is still usable for other purposes).
 Otherwise the region is marked as active.
 )
 tindex(spell-word)
-item(tt(spell-word) (ESC-$ ESC-S ESC-s) (unbound) (unbound))(
+item(tt(spell-word) (tt(ESC-$ ESC-S ESC-s)) (unbound) (unbound))(
 Attempt spelling correction on the current word.
 )
 tindex(split-undo)
@@ -2315,7 +2314,7 @@ This command is executed when a key sequence that is not bound to any
 command is typed.  By default it beeps.
 )
 tindex(undo)
-item(tt(undo) (^_ ^Xu ^X^U) (u) (unbound))(
+item(tt(undo) (tt(^_ ^Xu ^X^U)) (tt(u)) (unbound))(
 Incrementally undo the last text modification.  When called from a
 user-defined widget, takes an optional argument indicating a previous state
 of the undo history as returned by the tt(UNDO_CHANGE_NO) variable;
@@ -2326,7 +2325,7 @@ insert mode is reverted, the changes having been merged when command mode was
 selected.
 )
 tindex(redo)
-item(tt(redo) (unbound) (^R) (unbound))(
+item(tt(redo) (unbound) (tt(^R)) (unbound))(
 Incrementally redo undone text modifications.
 )
 tindex(vi-undo-change)
@@ -2335,21 +2334,21 @@ Undo the last text modification.
 If repeated, redo the modification.
 )
 tindex(visual-mode)
-item(tt(visual-mode) (unbound) (v) (unbound))(
+item(tt(visual-mode) (unbound) (tt(v)) (unbound))(
 Toggle vim-style visual selection mode. If line-wise visual mode is
 currently enabled then it is changed to being character-wise. If used
 following an operator, it forces the subsequent movement command to be
 treated as a character-wise movement.
 )
 tindex(visual-line-mode)
-item(tt(visual-line-mode) (unbound) (V) (unbound))(
+item(tt(visual-line-mode) (unbound) (tt(V)) (unbound))(
 Toggle vim-style line-wise visual selection mode. If character-wise
 visual mode is currently enabled then it is changed to being line-wise. If used
 following an operator, it forces the subsequent movement command to be
 treated as a line-wise movement.
 )
 tindex(what-cursor-position)
-item(tt(what-cursor-position) (^X=) (ga) (unbound))(
+item(tt(what-cursor-position) (tt(^X=)) (tt(ga)) (unbound))(
 Print the character under the cursor, its code as an octal, decimal and
 hexadecimal number, the current cursor position within the buffer and the
 column of the cursor in the current line.
@@ -2363,13 +2362,13 @@ mini-buffer.  Keys are looked up in the special
 tt(command) keymap, and if not found there in the main keymap.
 )
 tindex(which-command)
-item(tt(which-command) (ESC-?) (unbound) (unbound))(
+item(tt(which-command) (tt(ESC-?)) (unbound) (unbound))(
 Push the buffer onto the buffer stack, and execute the
 command `tt(which-command) var(cmd)'. where var(cmd) is the current
-command.  tt(which-command) is normally aliased to var(whence).
+command.  tt(which-command) is normally aliased to tt(whence).
 )
 tindex(vi-digit-or-beginning-of-line)
-item(tt(vi-digit-or-beginning-of-line) (unbound) (0) (unbound))(
+item(tt(vi-digit-or-beginning-of-line) (unbound) (tt(0)) (unbound))(
 If the last command executed was a digit as part of an argument,
 continue the argument.  Otherwise, execute vi-beginning-of-line.
 )
@@ -2386,34 +2385,34 @@ keymaps.
 
 startitem()
 tindex(select-a-blank-word)
-item(tt(select-a-blank-word) (aW))(
+item(tt(select-a-blank-word) (tt(aW)))(
 Select a word including adjacent blanks, where a word is defined as a
 series of non-blank characters. With a numeric argument, multiple words
 will be selected.
 )
 tindex(select-a-shell-word)
-item(tt(select-a-shell-word) (aa))(
+item(tt(select-a-shell-word) (tt(aa)))(
 Select the current command argument applying the normal rules for
 quoting.
 )
 tindex(select-a-word)
-item(tt(select-a-word) (aw))(
+item(tt(select-a-word) (tt(aw)))(
 Select a word including adjacent blanks, using the normal vi-style word
 definition. With a numeric argument, multiple words will be selected.
 )
 tindex(select-in-blank-word)
-item(tt(select-in-blank-word) (iW))(
+item(tt(select-in-blank-word) (tt(iW)))(
 Select a word, where a word is defined as a series of non-blank
 characters. With a numeric argument, multiple words will be selected.
 )
 tindex(select-in-shell-word)
-item(tt(select-in-shell-word) (ia))(
+item(tt(select-in-shell-word) (tt(ia)))(
 Select the current command argument applying the normal rules for
 quoting. If the argument begins and ends with matching quote characters,
 these are not included in the selection.
 )
 tindex(select-in-word)
-item(tt(select-in-word) (iw))(
+item(tt(select-in-word) (tt(iw)))(
 Select a word, using the normal vi-style word definition. With a numeric
 argument, multiple words will be selected.
 )