From ed8b82b9b1bf74392caf4f4683f367bc4cbbd193 Mon Sep 17 00:00:00 2001 From: Oliver Kiddle Date: Thu, 11 May 2000 00:01:03 +0000 Subject: Spelling corrections in the docs (11315) --- ChangeLog | 9 +++- Doc/Zsh/builtins.yo | 2 +- Doc/Zsh/compsys.yo | 12 ++--- Doc/Zsh/compwid.yo | 2 +- Doc/Zsh/expn.yo | 2 +- Doc/Zsh/grammar.yo | 84 +++++++++++++++++++++++++++------ Doc/Zsh/mod_complist.yo | 4 +- Doc/Zsh/mod_computil.yo | 34 +++++++++----- Doc/Zsh/mod_deltochar.yo | 13 +++-- Doc/Zsh/mod_mathfunc.yo | 12 +++-- Doc/Zsh/mod_parameter.yo | 120 +++++++++++++++++++++++++++++++++++++++++++---- Doc/Zsh/mod_zle.yo | 6 +-- Doc/Zsh/mod_zutil.yo | 2 +- Doc/Zsh/options.yo | 2 +- Doc/Zsh/params.yo | 6 +-- Doc/Zsh/zftpsys.yo | 2 +- 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 - * 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 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 -- cgit 1.4.1