diff options
Diffstat (limited to 'Doc')
55 files changed, 12002 insertions, 0 deletions
diff --git a/Doc/.cvsignore b/Doc/.cvsignore new file mode 100644 index 000000000..11b508947 --- /dev/null +++ b/Doc/.cvsignore @@ -0,0 +1,15 @@ +Makefile +version.yo +zsh*.1 +zsh.texi +zsh.info* +zsh_*.html +zsh.aux zsh.toc +zsh.cp zsh.cps +zsh.fn zsh.fns +zsh.ky zsh.kys +zsh.pg zsh.pgs +zsh.vr zsh.vrs +zsh.log zsh.dvi +zsh.tp zsh.tps +zsh_*.ps diff --git a/Doc/.distfiles b/Doc/.distfiles new file mode 100644 index 000000000..7fd1cdcc1 --- /dev/null +++ b/Doc/.distfiles @@ -0,0 +1,16 @@ +DISTFILES_SRC=' + .cvsignore .distfiles Makefile.in + META-FAQ.yo intro.ms + version.yo zmacros.yo zman.yo ztexi.yo + zsh.yo zshbuiltins.yo zshcompctl.yo zshexpn.yo zshmisc.yo + zshmodules.yo zshoptions.yo zshparam.yo zshzle.yo + zsh.texi + zsh.1 zshbuiltins.1 zshcompctl.1 zshexpn.1 zshmisc.1 zshmodules.1 + zshoptions.1 zshparam.1 zshzle.1 zshall.1 +' + +DISTFILES_DOC=' + zsh.info zsh.info-[0-9]* + zsh_toc.html zsh_[0-9]*.html + zsh.dvi zsh_us.ps zsh_a4.ps +' diff --git a/Doc/META-FAQ.yo b/Doc/META-FAQ.yo new file mode 100644 index 000000000..019264601 --- /dev/null +++ b/Doc/META-FAQ.yo @@ -0,0 +1,44 @@ +STARTDEF() +INCLUDEFILE(zmacros.yo) + +def(startmenu)(0)(DELLINE) +def(endmenu)(0)(DELLINE) +def(menu)(1)(DELLINE) +def(texinode)(4)(DELLINE) +def(cindex)(1)(DELLINE) + +def(sect)(1)( +SECTHEAD +ARG1 +) + +def(em)(1)(ARG1) +def(bf)(1)(ARG1) +def(tt)(1)(ARG1) +def(var)(1)(ARG1) +def(nofill)(1)(ARG1) + +def(startitem)(0)(NEXTLINE DELLINE) +def(enditem)(0)(DELLINE) +def(item)(2)( + ARG1+USECHARTABLE(indent2)ARG2 DELLINE USECHARTABLE(standard)) + +def(startlist)(0)(DELLINE) +def(endlist)(0)(DELLINE) +def(list)(1)( ARG1) + +DEFINECHARTABLE(standard)( + '\n' = "\n" +) +DEFINECHARTABLE(indent2)( + '\n' = "\n " +) + +ENDDEF()\ +------------------------ +META-FAQ for the Z Shell +------------------------ + +The latest version of this META-FAQ can be found at any of the FTP sites +listed below. +INCLUDEFILE(Zsh/metafaq.yo)\ diff --git a/Doc/Makefile.in b/Doc/Makefile.in new file mode 100644 index 000000000..1883abfd1 --- /dev/null +++ b/Doc/Makefile.in @@ -0,0 +1,172 @@ +# +# Makefile for Doc subdirectory +# +# Copyright (c) 1995-1997 Richard Coleman +# All rights reserved. +# +# Permission is hereby granted, without written agreement and without +# license or royalty fees, to use, copy, modify, and distribute this +# software and to distribute modified versions of this software for any +# purpose, provided that the above copyright notice and the following +# two paragraphs appear in all copies of this software. +# +# In no event shall Richard Coleman or the Zsh Development Group be liable +# to any party for direct, indirect, special, incidental, or consequential +# damages arising out of the use of this software and its documentation, +# even if Richard Coleman and the Zsh Development Group have been advised of +# the possibility of such damage. +# +# Richard Coleman and the Zsh Development Group specifically disclaim any +# warranties, including, but not limited to, the implied warranties of +# merchantability and fitness for a particular purpose. The software +# provided hereunder is on an "as is" basis, and Richard Coleman and the +# Zsh Development Group have no obligation to provide maintenance, +# support, updates, enhancements, or modifications. +# + +subdir = Doc +dir_top = .. + +@@version.mk@@ +@@defs.mk@@ + +MAKEINFO = makeinfo +TEXI2DVI = texi2dvi +DVIPS = dvips -D 300 +TEXI2HTML = texi2html -expandinfo -split_chapter + +.SUFFIXES: .yo .1 + +# man pages to install +MAN = zsh.1 zshbuiltins.1 zshcompctl.1 \ +zshexpn.1 zshmisc.1 zshmodules.1 \ +zshoptions.1 zshparam.1 zshzle.1 zshall.1 + +# yodl documentation +YODLDOC = $(MAN) zsh.texi +YODLSRC = zmacros.yo zman.yo ztexi.yo Zsh/arith.yo Zsh/builtins.yo \ +Zsh/compat.yo Zsh/compctl.yo Zsh/cond.yo Zsh/exec.yo Zsh/expn.yo \ +Zsh/filelist.yo Zsh/files.yo Zsh/func.yo Zsh/grammar.yo Zsh/guide.yo \ +Zsh/index.yo Zsh/intro.yo Zsh/invoke.yo Zsh/jobs.yo Zsh/metafaq.yo \ +Zsh/modules.yo Zsh/mod_cap.yo \ +Zsh/mod_clone.yo Zsh/mod_comp1.yo Zsh/mod_compctl.yo Zsh/mod_deltochar.yo \ +Zsh/mod_example.yo Zsh/mod_files.yo Zsh/mod_stat.yo \ +Zsh/mod_zle.yo Zsh/options.yo \ +Zsh/params.yo Zsh/prompt.yo Zsh/redirect.yo Zsh/restricted.yo \ +Zsh/seealso.yo Zsh/zle.yo + +# ========== DEPENDENCIES FOR BUILDING ========== + +all: $(MAN) zsh.texi zsh.info ../META-FAQ + +everything: all zsh.dvi zsh_us.ps zsh_a4.ps zsh_toc.html + +zsh.dvi: zsh.texi + $(TEXI2DVI) $(sdir)/zsh.texi + +zsh.info: zsh.texi + $(MAKEINFO) $(sdir)/zsh.texi; exit 0 + +zsh.texi: zsh.yo + $(YODL) -o $(sdir)/zsh.texi -I$(sdir) -w ztexi.yo version.yo zsh.yo + test -f $(sdir)/zsh.texi + +.yo.1: + case $@ in \ + */*) target=$@ ;; \ + *) target=$(sdir)/$@ ;; \ + esac; \ + $(YODL) -o $$target -I$(sdir) -w zman.yo version.yo $< || exit 1; \ + test -f $$target + +zsh_us.ps: zsh.dvi + $(DVIPS) -t letter -o $@ zsh.dvi + +zsh_a4.ps: zsh.dvi + $(DVIPS) -t a4 -o $@ zsh.dvi + +zsh_toc.html: zsh.texi + $(TEXI2HTML) $(sdir)/zsh.texi + +zshall.1: zsh.yo + case $@ in \ + */*) target=$@ ;; \ + *) target=$(sdir)/$@ ;; \ + esac; \ + $(YODL) -o $$target -I$(sdir) -DZSHALL -w zman.yo version.yo zsh.yo || exit 1; \ + test -f $$target + +../META-FAQ: META-FAQ.yo Zsh/metafaq.yo + $(YODL) -I$(sdir) META-FAQ.yo | sed -e '/NEXTLINE/N' -e '/DELLINE/d' -e '/^SECTHEAD$$/{N;s/^SECTHEAD.//;h;s/./-/g;H;g;}' -e 's/ *$$//' > $(sdir_top)/META-FAQ + test -f $(sdir_top)/META-FAQ + +$(YODLDOC): $(YODLSRC) version.yo + +version.yo: $(sdir_top)/Config/version.mk + ( \ + echo 'STARTDEF()'; \ + echo 'def(version)(0)('$(VERSION)')'; \ + echo 'def(date)(0)('$(VERSION_DATE)')'; \ + echo 'ENDDEF()#' | tr '#' '\\'; \ + ) > $(sdir)/version.yo + +# ========== DEPENDENCIES FOR INSTALLING ========== + +# install all the documentation +install: install.man install.info + +# uninstall all the documentation +uninstall: uninstall.man uninstall.info + +# install man pages, creating install directory if necessary +install.man: $(MAN) + $(sdir_top)/mkinstalldirs $(mandir)/man1 + for file in $(MAN); do \ + if test -f $$file; then \ + $(INSTALL_DATA) $$file $(mandir)/man1; \ + elif test -f $(sdir)/$$file; then \ + $(INSTALL_DATA) $(sdir)/$$file $(mandir)/man1; \ + else :; \ + fi || exit 1; \ + done + +# install info pages, creating install directory if necessary +install.info: zsh.info + $(sdir_top)/mkinstalldirs $(infodir) + for file in zsh.info zsh.info-[1-9]; do \ + if test -f $$file; then \ + $(INSTALL_DATA) $$file $(infodir); \ + elif test -f $(sdir)/$$file; then \ + $(INSTALL_DATA) $(sdir)/$$file $(infodir); \ + else :; \ + fi || exit 1; \ + done + +# uninstall man pages +uninstall.man: + for file in $(MAN); do \ + rm -f $(mandir)/man1/$$file; \ + done + +# uninstall info pages +uninstall.info: + rm -f $(infodir)/zsh.info $(infodir)/zsh.info-[1-9] + +# ========== DEPENDENCIES FOR CLEANUP ========== + +@@clean.mk@@ + +clean-here: + rm -f *.html *.info* *.dvi *.ps + rm -f *.aux *.cp *.cps *.fn *.fns *.ky *.log + rm -f *.pg *.pgs *.toc *.tp *.tps *.vr *.vrs + +distclean-here: + rm -f Makefile + +realclean-here: + cd $(sdir) && rm -f version.yo *.1 *.texi ../META-FAQ + +# ========== DEPENDENCIES FOR MAINTENANCE ========== + +@@config.mk@@ diff --git a/Doc/Zsh/.distfiles b/Doc/Zsh/.distfiles new file mode 100644 index 000000000..42517f507 --- /dev/null +++ b/Doc/Zsh/.distfiles @@ -0,0 +1,9 @@ +DISTFILES_SRC=' + .distfiles + arith.yo builtins.yo compat.yo compctl.yo cond.yo exec.yo expn.yo + filelist.yo files.yo func.yo grammar.yo guide.yo index.yo intro.yo + invoke.yo jobs.yo metafaq.yo mod_cap.yo mod_clone.yo mod_comp1.yo + mod_compctl.yo mod_deltochar.yo mod_example.yo mod_files.yo mod_sched.yo + mod_stat.yo mod_zle.yo modules.yo options.yo params.yo prompt.yo + redirect.yo restricted.yo seealso.yo zle.yo +' diff --git a/Doc/Zsh/.lastloc b/Doc/Zsh/.lastloc new file mode 100644 index 000000000..8b1a784a8 --- /dev/null +++ b/Doc/Zsh/.lastloc @@ -0,0 +1 @@ +(("/home/user2/pws/src/zsh-3.1.5/Doc/Zsh/expn.yo" . 33735)) diff --git a/Doc/Zsh/arith.yo b/Doc/Zsh/arith.yo new file mode 100644 index 000000000..1560c81d3 --- /dev/null +++ b/Doc/Zsh/arith.yo @@ -0,0 +1,73 @@ +texinode(Arithmetic Evaluation)(Conditional Expressions)(Jobs & Signals)(Top) +chapter(Arithmetic Evaluation) +ifzman(\ +sect(Arithmetic Evaluation) +)\ +cindex(arithmetic evaluation) +cindex(evaluation, arithmetic) +An ability to perform integer arithmetic is provided with the builtin tt(let). +findex(let, use of) +Evaluations are performed using em(long) arithmetic. +A leading `tt(0x)' or `tt(0X)' denotes hexadecimal. +Otherwise, numbers are of the form `[var(base)tt(#)]var(n)', +where var(base) is a decimal number between two and thirty-six +representing the arithmetic base and var(n) +is a number in that base (for example, `tt(16#ff)' is 255 in hexadecimal). +If var(base) is omitted +then base 10 is used. For backwards compatibility the form +`tt([)var(base)tt(])var(n)' is also accepted. + +cindex(arithmetic operators) +cindex(operators, arithmetic) +An arithmetic expression uses nearly the same syntax, precedence, and +associativity of expressions in C. +The following operators are supported (listed in decreasing order +of precedence): + +startsitem() +sitem(tt(PLUS() - ! ~ PLUS()PLUS() --))(unary plus/minus, logical NOT, complement, {pre,post}{in,de}crement) +sitem(tt(<< >>))(bitwise shift left, right) +sitem(tt(&))(bitwise AND) +sitem(tt(^))(bitwise XOR) +sitem(tt(|))(bitwise OR) +sitem(tt(**))(exponentiation) +sitem(tt(* / %))(multiplication, division, modulus (remainder)) +sitem(tt(PLUS() -))(addition, subtraction) +sitem(tt(< > <= >=))(comparison) +sitem(tt(== !=))(equality and inequality) +sitem(tt(&&))(logical AND) +sitem(tt(|| ^^))(logical OR, XOR) +sitem(tt(? :))(ternary operator) +sitem(tt(= PLUS()= -= *= /= %= &= ^= |= <<= >>= &&= ||= ^^= **=))(assignment) +sitem(tt(,))(comma operator) +endsitem() + +The operators `tt(&&)', `tt(||)', `tt(&&=)', and `tt(||=)' are short-circuiting, +and only one of the latter two expressions in a ternary operator +is evaluated. Note the precedence of the bitwise AND, OR, +and XOR operators. + +An expression of the form `tt(#\)var(x)' where var(x) is any character +gives the ascii value of this character and an expression of the form +`tt(#)var(foo)' gives the ascii value of the first character of the value +of the parameter var(foo). + +Named parameters and subscripted arrays can be referenced by name within an +arithmetic expression without using the parameter substitution syntax. + +An internal integer representation of a named parameter +can be specified with the tt(integer) builtin. +cindex(parameters, integer) +cindex(integer parameters) +findex(integer, use of) +Arithmetic evaluation is performed on the value of each +assignment to a named parameter declared integer +in this manner. + +Since many of the arithmetic operators require +quoting, an alternative form of the tt(let) command is provided. +For any command which begins with a tt(LPAR()LPAR()), +all the characters until a matching tt(RPAR()RPAR()) +are treated as a quoted expression. +More precisely, `tt(LPAR()LPAR()) ... tt(RPAR()RPAR())' +is equivalent to `tt(let ")...tt(")'. diff --git a/Doc/Zsh/builtins.yo b/Doc/Zsh/builtins.yo new file mode 100644 index 000000000..8959543c5 --- /dev/null +++ b/Doc/Zsh/builtins.yo @@ -0,0 +1,1184 @@ +texinode(Shell Builtin Commands)(Zsh Line Editor)(Options)(Top) +chapter(Shell Builtin Commands) +ifzman(\ +sect(Shell Builtin Commands) +)\ +cindex(builtin commands) +cindex(commands, builtin) +def(prefix)(1)(\ +findex(ARG1) +item(tt(ARG1) var(simple command))( +See noderef(Precommand Modifiers). +)\ +)\ +def(alias)(2)(\ +findex(ARG1) +item(tt(ARG1))( +Same as tt(ARG2). +)\ +)\ +startitem() +prefix(-) +findex(.) +item(tt(.) var(file) [ var(arg) ... ])( +Read commands from var(file) and execute them in the current shell +environment. +If var(file) does not contain a slash, or if tt(PATH_DIRS) +is set, the shell looks in the components of tt($path) to find the +directory containing var(file). +Files in the current directory are not read unless `tt(.)' appears +somewhere in tt($path). + +If any arguments var(arg) are given, +they become the positional parameters; the old positional +parameters are restored when the var(file) is done executing. +The exit status is the exit status of the last command executed. +) +findex(NOTRANS(:)) +cindex(expanding parameters) +cindex(parameters, expanding) +cindex(doing nothing) +item(tt(:) [ var(arg) ... ])( +This command only expands parameters. A zero exit code is returned. +) +findex(alias) +cindex(aliases, defining) +cindex(aliases, listing) +item(tt(alias) [ tt(-gmrL) ] [ 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 substitution. If the tt(-g) flag is present, +define a global alias; global aliases are expanded even if they do not +occur in command position. + +For each var(name) with no var(value), +print the value of var(name), if any. With no arguments, print all +currently defined aliases. If the tt(-m) flag is given the arguments +are taken as patterns (they should be quoted to preserve them from being +interpreted as glob patterns), and the aliases matching these patterns +are printed. When printing aliases and the tt(-g) or tt(-r) flags +are present, then restrict the printing to global or regular +aliases, respectively. + +If the tt(-L) flag is present, then print each +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. +) +findex(autoload) +cindex(functions, autoloading) +cindex(autoloading functions) +alias(autoload)(functions -u) +findex(bg) +cindex(jobs, backgrounding) +xitem(tt(bg) [ var(job) ... ]) +item(var(job) ... tt(&))( +Put each specified var(job) in the background, +or the current job if none is specified. +) +findex(break) +cindex(exiting loops) +cindex(loops, exiting) +item(tt(break) [ var(n) ])( +Exit from an enclosing tt(for), tt(while), +tt(until), tt(select) or tt(repeat) loop. If var(n) +is specified, then break var(n) levels instead of just one. +) +findex(builtin) +item(tt(builtin) var(name) [ var(args) ... ])( +Executes the builtin var(name), with the given var(args). +) +alias(bye)(exit) +findex(cd) +cindex(directories, changing) +xitem(tt(cd) [ tt(-sLP) ] [ var(arg) ]) +xitem(tt(cd) [ tt(-sLP) ] var(old) var(new)) +item(tt(cd) [ tt(-sLP) ] {tt(PLUS())|tt(-)}var(n))( +Change the current directory. In the first form, change the +current directory to var(arg), or to the value of tt($HOME) if +var(arg) is not specified. If var(arg) is `tt(-)', change to the +value of tt($OLDPWD), the previous directory. +If a directory named var(arg) is not found in the current directory +and var(arg) does not begin with a slash, +search each component of the shell parameter tt(cdpath). +If the option tt(CDABLE_VARS) is set, and a parameter named var(arg) +exists whose value begins with a slash, treat its value as +the directory. + +The second form of tt(cd) substitutes the string var(new) +for the string var(old) in the name of the current directory, +and tries to change to this new directory. + +The third form of tt(cd) extracts an entry from the directory +stack, and changes to that directory. 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(-)var(n)' counts from the right. +If the tt(PUSHD_MINUS) option is set, the meanings of `tt(PLUS())' +and `tt(-)' in this context are swapped. + +If the tt(-s) option is specified, tt(cd) refuses to change the current +directory if the given pathname contains symlinks. If the tt(-P) option +is given or the tt(CHASE_LINKS) option is set, symbolic links are resolved +to their true values. If the tt(-L) option is given symbolic links are +followed regardless of the state of the tt(CHASE_LINKS) option. +) +alias(chdir)(cd) +prefix(command) +findex(continue) +cindex(loops, continuing) +cindex(continuing loops) +item(tt(continue) [ var(n) ])( +Resume the next iteration of the enclosing +tt(for), tt(while), tt(until), tt(select) or +tt(repeat) loop. If var(n) is specified, break out of +var(n)-1 loops and resume at the var(n)th enclosing loop. +) +alias(declare)(typeset) +findex(dirs) +cindex(directory stack, printing) +item(tt(dirs) [ tt(-v) ] [ var(arg) ... ])( +With no arguments, print the contents of the directory stack. +If the tt(-v) option is given, number the directories +in the stack when printing. +Directories are added to this stack with the tt(pushd) command, +and removed with the tt(cd) or tt(popd) commands. +If arguments are specified, load them onto the directory stack, +replacing anything that was there, and push the current directory +onto the stack. +) +findex(disable) +cindex(disabling commands) +cindex(commands, disabling) +item(tt(disable) [ tt(-afmr) ] var(name) ...)( +Temporarily disable the var(name)d hash table elements. The default +is to disable builtin commands. This allows you to use an external +command with the same name as a builtin command. The tt(-a) option +causes tt(disable) to act on aliases. The tt(-f) option causes +tt(disable) to act on shell functions. The tt(-r) options causes +tt(disable) to act on reserved words. Without arguments all disabled +hash table elements from the corresponding hash table are printed. +With the tt(-m) flag the arguments are taken as patterns (should be +quoted to preserve them from being taken as glob patterns), and all hash +table elements from the corresponding hash table matching these patterns +are disabled. Disabled objects can be enabled with the tt(enable) +command. +) +findex(disown) +cindex(jobs, disowning) +xitem(tt(disown) [ var(job) ... ]) +xitem(var(job) ... tt(&|)) +item(var(job) ... tt(&!))( +Remove the specified var(job)s from the job table; the shell will +no longer report their status, and will not complain if you +try to exit an interactive shell with them running or stopped. +If no var(job) is specified, disown the current job. +) +findex(echo) +item(tt(echo) [ tt(-neE) ] [ var(arg) ... ])( +Write each var(arg) on the standard output, with a space separating +each one. +If the tt(-n) flag is not present, print a newline at the end. +tt(echo) recognizes the following escape sequences: + +startsitem() +sitem(tt(\a))(bell character) +sitem(tt(\b))(backspace) +sitem(tt(\c))(suppress final newline) +sitem(tt(\e))(escape) +sitem(tt(\f))(form feed) +sitem(tt(\n))(linefeed (newline)) +sitem(tt(\r))(carriage return) +sitem(tt(\t))(horizontal tab) +sitem(tt(\v))(vertical tab) +sitem(tt(\\))(backslash) +sitem(tt(\0)var(NNN))(character code in octal) +sitem(tt(\x)var(NN))(character code in hexadecimal) +endsitem() + +pindex(BSD_ECHO, use of) +The tt(-E) flag, or the tt(BSD_ECHO) option, can be used to disable +these escape sequences. In the latter case, tt(-e) flag can be used to +enable them. +) +findex(echotc) +cindex(termcap string, printing) +item(tt(echotc) var(cap) [ var(arg) ... ])( +Output the termcap string corresponding to the capability +var(cap), with optional arguments. +) +findex(emulate) +cindex(compatibility, sh) +cindex(compatibility, ksh) +cindex(compatibility, csh) +cindex(sh, compatibility) +cindex(ksh, compatibility) +cindex(csh, compatibility) +item(tt(emulate) [ tt(-R) ] {tt(zsh)|tt(sh)|tt(ksh)|tt(csh)})( +Set up zsh options to emulate the specified shell as much as possible. +bf(csh) will never be fully emulated. +If the argument is not one of the shells listed above, tt(zsh) +will be used as a default. If the tt(-R) option is given, all options +are reset to their default value corresponding to the specified emulation +mode. +) +findex(enable) +cindex(enabling commands) +cindex(commands, enabling) +item(tt(enable) [ tt(-afmr) ] var(name) ...)( +Enable the var(name)d hash table elements, presumably disabled +earlier with tt(disable). The default is to enable builtin commands. +The tt(-a) option causes tt(enable) to act on aliases. The tt(-f) +option causes tt(enable) to act on shell functions. The tt(-r) +option causes tt(enable) to act on reserved words. Without arguments +all enabled hash table elements from the corresponding hash table are +printed. With the tt(-m) flag the arguments are taken as patterns +(should be quoted) and all hash table elements from the corresponding +hash table matching these patterns are enabled. Enabled objects can be +disabled with the tt(disable) builtin command. +) +findex(eval) +cindex(evaluating arguments as commands) +item(tt(eval) [ var(arg) ... ])( +Read the arguments as input to the shell and execute the resulting +command in the current shell process. +) +prefix(exec) +findex(exit) +item(tt(exit) [ var(n) ])( +Exit the shell with the exit code specified by var(n); if none +is specified, use the exit code from the last command executed. +pindex(IGNORE_EOF, use of) +An EOF condition will also cause the shell to exit, unless +the tt(IGNORE_EOF) option is set. +) +findex(export) +item(tt(export) [ var(name)[tt(=)var(value)] ... ])( +The specified var(name)s are marked for automatic export +to the environment of subsequently executed commands. +Equivalent to tt(typeset -x), except that no parameter will be created +to hide an existing one in an outer scope. +If a parameter specified does not +already exist, it is created in the global scope. +) +findex(false) +cindex(doing nothing, unsuccessfully) +item(tt(false) [ var(arg) ... ])( +Do nothing and return an exit code of 1. +) +findex(fc) +cindex(history, editing) +cindex(editing history) +xitem(tt(fc) [ tt(-e) var(ename) ] [ tt(-nlrdDfEim) ] [ var(old)tt(=)var(new) ... ] [ var(first) [ var(last) ] ]) +item(tt(fc) tt(-ARWI) [ var(filename) ])( +Select a range of commands from var(first) to var(last) from the +history list. +The arguments var(first) and var(last) may be specified as a +number or as a string. A negative number is used as an offset +to the current history event number. +A string specifies the most recent event beginning with the given string. +All substitutions var(old)tt(=)var(new), if any, are then performed +on the commands. + +If the tt(-l) flag is given, the resulting commands are listed on +standard output. +If the tt(-m) flag is also given the first argument is taken as a +pattern (should be quoted) and only the history events matching this +pattern will be shown. +Otherwise the editor program var(ename) is invoked on a file containing +these history events. If var(ename) is not given, the value +of the parameter tt(FCEDIT) is used. If var(ename) is `tt(-)', +no editor is invoked. When editing is complete, the edited +command is executed. + +If var(first) is not specified, it will be set to -1 (the most recent +event), or to -16 if the tt(-l) flag is given. +If var(last) is not specified, it will be set to var(first), +or to -1 if the tt(-l) flag is given. + +The flag tt(-r) reverses the order of the commands and the +flag tt(-n) suppresses command numbers when listing. +Also when listing, tt(-d) prints timestamps for each command, and +tt(-f) prints full time-date stamps. Adding the tt(-E) flag +causes the dates to be printed as `var(dd)tt(.)var(mm)tt(.)var(yyyy)', +instead of the default `var(mm)tt(/)var(dd)tt(/)var(yyyy)'. +Adding the tt(-i) flag causes the dates to be printed in ISO8601 +`var(yyyy)tt(-)var(mm)tt(-)var(dd)' format. +With the tt(-D) flag, tt(fc) prints elapsed times. + +cindex(history, file) +cindex(file, history) +tt(fc -R) reads the history from the given file, +tt(fc -W) writes the history out to the given file, +and tt(fc -A) appends the history out to the given file. +If the tt(-I) option is added, only those +events that are new since last incremental append (write) to +the history file are appended (written). +In any case the file will have no more than tt($SAVEHIST) +entries. +) +findex(fg) +cindex(jobs, foregrounding) +cindex(jobs, resuming) +xitem(tt(fg) [ var(job) ... ]) +item(var(job) ...)( +Bring each specified var(job) in turn to the foreground. +If no var(job) is specified, resume the current job. +) +findex(functions) +item(tt(functions) [ {tt(PLUS())|tt(-)}tt(tum) ] [ var(name) ... ])( +Equivalent to tt(typeset -f). +) +findex(getln) +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 +tt(read -zr). +) +findex(getopts) +cindex(options, processing) +item(tt(getopts) var(optstring) var(name) [ var(arg) ... ])( +Checks the var(arg)s for legal options. If the var(arg)s are omitted, +use the positional parameters. A valid option argument +begins with a `tt(PLUS())' or a `tt(-)'. An argument not beginning with +a `tt(PLUS())' or a `tt(-)', or the argument `tt(--)', ends the options. +var(optstring) contains the letters that tt(getopts) +recognizes. If a letter is followed by a `tt(:)', that option +is expected to have an argument. The options can be +separated from the argument by blanks. + +Each time it is invoked, tt(getopts) places the option letter it finds +in the shell parameter var(name), prepended with a `tt(PLUS())' when +var(arg) begins with a `tt(PLUS())'. The index of the next var(arg) +is stored in tt(OPTIND). The option argument, if any, +is stored in tt(OPTARG). +vindex(OPTIND, use of) +vindex(OPTARG, use of) + +A leading `tt(:)' in var(optstring) causes tt(getopts) to store the +letter of the invalid option in tt(OPTARG), and to set var(name) +to `tt(?)' for an unknown option and to `tt(:)' when a required option +is missing. Otherwise, tt(getopts) prints an error +message. The exit status is nonzero when there are no more options. +) +findex(hash) +item(tt(hash) [ tt(-dfmrv) ] [ var(name)[tt(=)var(value)] ] ...)( +tt(hash) can be used to directly modify the contents of the command +hash table, and the named directory hash table. Normally one would +modify these tables by modifying one's tt(PATH) +(for the command hash table) or by creating appropriate shell parameters +(for the named directory hash table). +The choice of hash table to work on is determined by the tt(-d) option; +without the option the command hash table is used, and with the option the +named directory hash table is used. + +Given no arguments, and neither the tt(-r) or tt(-f) options, +the selected hash table will be listed in full. + +The tt(-r) option causes the selected hash table to be emptied. +It will be subsequently rebuilt in the normal fashion. +The tt(-f) option causes the selected hash table to be fully +rebuilt immediately. For the command hash table this hashes +all the absolute directories in the tt(PATH), +and for the named directory hash table this adds all users' home directories. +These two options cannot be used with any arguments. + +The tt(-m) option causes the arguments to be taken as patterns +(they should be quoted) and the elements of the hash table +matching those patterns are printed. This is the only way to display +a limited selection of hash table elements. + +For each var(name) with a corresponding var(value), put `var(name)' in +the selected hash table, associating it with the pathname `var(value)'. +In the command hash table, this means that +whenever `var(name)' is used as a command argument, the shell will try +to execute the file given by `var(value)'. +In the named directory hash table, this means +that `var(value)' may be referred to as `tt(~)var(name)'. + +For each var(name) with no +corresponding var(value), attempt to add var(name) to the hash table, +checking what the appropriate tt(value) is in the normal manner for +that hash table. If an appropriate tt(value) can't be found, then +the hash table will be unchanged. + +The tt(-v) option causes hash table entries to be listed as they are +added by explicit specification. If has no effect if used with tt(-f). +) +alias(history)(fc -l) +findex(integer) +item(tt(integer) [ {tt(PLUS())|tt(-)}tt(lrtux) ] [ var(name)[tt(=)var(value)] ... ])( +Equivalent to tt(typeset -i), except that options irrelevant to +integers are not permitted. +) +findex(jobs) +xitem(tt(jobs) [ tt(-dlprs) ] [ var(job) ... ]) +item(tt(jobs -Z) var(string))( +Lists information about each given job, or all jobs +if var(job) is omitted. The tt(-l) flag lists process +IDs, and the tt(-p) flag lists process groups. +If the tt(-r) flag is specified only running jobs will be listed +and if the tt(-s) flag is given only stopped jobs are shown. +If the tt(-d) flag is given, the directory from which the job was +started (which may not be the current directory of the job) will also +be shown. + +The tt(-Z) option replaces the shell's argument and environment space with +the given string, truncated if necessary to fit. This will normally be +visible in tt(ps) (manref(ps)(1)) listings. This feature is typically +used by daemons, to indicate their state. +) +findex(kill) +cindex(killing jobs) +cindex(jobs, killing) +xitem(tt(kill) [ tt(-s) var(signal_name) ] var(job) ...) +xitem(tt(kill) [ tt(-)var(sig) ] var(job) ...) +item(tt(kill) tt(-l) [ var(sig) ... ])( +Sends either tt(SIGTERM) or the specified signal to the given +jobs or processes. +Signals are given by number or by names, without the `tt(SIG)' prefix. +If the signal being sent is not `tt(KILL)' or `tt(CONT)', then the job +will be sent a `tt(CONT)' signal if it is stopped. +The argument var(job) can be the process ID of a job +not in the job list. +In the third form, tt(kill -l), if var(sig) is not +specified the signal names are listed. Otherwise, for each +var(sig) that is a name, the corresponding signal number is +listed. For each var(sig) that is a signal number or a number +representing the exit status of a process which was terminated or +stopped by a signal the name of the signal is printed. +) +findex(let) +item(tt(let) var(arg) ...)( +Evaluate each var(arg) as an arithmetic expression. +See noderef(Arithmetic Evaluation) for a description +of arithmetic expressions. The exit status is 0 if the +value of the last expression is nonzero, and 1 otherwise. +) +findex(limit) +cindex(resource limits) +cindex(limits, resource) +item(tt(limit) [ tt(-hs) ] [ var(resource) [ var(limit) ] ] ...)( +Set or display resource limits. Unless the tt(-s) flag is given, +the limit applies only the children of the shell. If tt(-s) is +given without other arguments, the resource limits of the current +shell is set to the previously set resource limits of the children. + +If var(limit) is not specified, print the current limit placed +on var(resource), otherwise +set the limit to the specified value. If the tt(-h) flag +is given, use hard limits instead of soft limits. +If no var(resource) is given, print all limits. + +var(resource) can be one of: + +startsitem() +sitem(tt(memorylocked))(Maximum amount of memory locked in RAM.) +sitem(tt(resident))(Maximum resident set size.) +sitem(tt(vmemorysize))(Maximum amount of virtual memory.) +sitem(tt(descriptors))(Maximum value for a file descriptor.) +sitem(tt(coredumpsize))(Maximum size of a core dump.) +sitem(tt(stacksize))(Maximum stack size for each process.) +sitem(tt(datasize))(Maximum data size (including stack) for each process.) +sitem(tt(filesize))(Largest single file allowed.) +sitem(tt(cputime))(Maximum CPU seconds per process.) +sitem(tt(maxproc))(Maximum number of processes.) +sitem(tt(addressspace))(Maximum amount of address space used.) +sitem(tt(cachedthreads))(Maximum number of cached threads.) +endsitem() + +Which of these resource limits are available depends on the system. +var(resource) can be abbreviated to any unambiguous prefix. + +var(limit) is a number, with an optional scaling factor, as follows: + +startsitem() +sitem(var(n)tt(h))(hours) +sitem(var(n)tt(k))(kilobytes (default)) +sitem(var(n)tt(m))(megabytes or minutes) +sitem([var(mm)tt(:)]var(ss))(minutes and seconds) +endsitem() +) +findex(local) +item(tt(local) [ {tt(PLUS())|tt(-)}tt(LRZilrtu) [var(n)]] [ var(name)[tt(=)var(value)] ] ...)( +Same as tt(typeset), except that the options tt(-x) and +tt(-f) are not permitted. +) +findex(log) +vindex(watch, use of) +cindex(watching users) +cindex(users, watching) +item(tt(log))( +List all users currently logged in who are affected by +the current setting of the tt(watch) parameter. +) +findex(logout) +item(tt(logout) [ var(n) ])( +Same as tt(exit), except that it only works in a login shell. +) +prefix(noglob) +findex(popd) +item(tt(popd) [ {tt(PLUS())|tt(-)}var(n) ])( +Removes a 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. +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. +) +findex(print) +item(tt(print) [ tt(-nrslzpNDPoOicm) ] [ tt(-u)var(n) ] [ tt(-R) [ tt(-en) ]] [ var(arg) ... ])( +With no flags or with flag `tt(-)', the arguments are printed on +the standard output as described by tt(echo), with the following differences: +the escape sequence `tt(\M-)var(x)' metafies the character +var(x) (sets the highest bit), +`tt(\C-)var(x)' produces a control character (`tt(\C-@)' and `tt(\C-?)' give the +characters NUL and delete), and `tt(\E)' is a synonym for `tt(\e)'. +Finally, if not in an escape +sequence, `tt(\)' escapes the following character and is not printed. + +startitem() +item(tt(-r))( +Ignore the escape conventions of tt(echo). +) +item(tt(-R))( +Emulate the BSD tt(echo) command, which does not process escape sequences +unless the tt(-e) flag is given. The tt(-n) flag suppresses the trailing +newline. Only the tt(-e) and tt(-n) flags are recognized after +tt(-R); all other arguments and options are printed. +) +item(tt(-m))( +Take the first argument as a pattern (should be quoted), and remove +it from the argument list together with subsequent arguments that +do not match this pattern. +) +item(tt(-s))( +Place the results in the history list instead of on the standard output. +) +item(tt(-n))( +Do not add a newline to the output. +) +item(tt(-l))( +Print the arguments separated by newlines instead of spaces. +) +item(tt(-N))( +Print the arguments separated and terminated by nulls. +) +item(tt(-o))( +Print the arguments sorted in ascending order. +) +item(tt(-O))( +Print the arguments sorted in descending order. +) +item(tt(-i))( +If given together with tt(-o) or tt(-O), makes them work case +independently. +) +item(tt(-c))( +Print the arguments in columns. +) +item(tt(-u)var(n))( +Print the arguments to file descriptor var(n). +) +item(tt(-p))( +Print the arguments to the input of the coprocess. +) +item(tt(-z))( +Push the arguments onto the editing buffer stack, separated by spaces; +no escape sequences are recognized. +) +item(tt(-D))( +Treat the arguments as directory names, replacing prefixes with tt(~) +expressions, as appropriate. +) +item(tt(-P))( +Perform prompt expansion (see noderef(Prompt Expansion)). +) +enditem() +) +findex(pushd) +pindex(PUSHD_TO_HOME, use of) +pindex(PUSHD_MINUS, use of) +pindex(CDABLE_VARS, use of) +pindex(PUSHD_SILENT, use of) +xitem(tt(pushd) [ var(arg) ]) +xitem(tt(pushd) var(old) var(new)) +item(tt(pushd) {tt(PLUS())|tt(-)}var(n))( +Change the current directory, and push the old current directory +onto the directory stack. In the first form, change the +current directory to var(arg). +If var(arg) is not specified, change to the second directory +on the stack (that is, exchange the top two entries), or +change to tt($HOME) if the tt(PUSHD_TO_HOME) +option is set or if there is only one entry on the stack. + +If var(arg) is `tt(-)', change to tt($OLDPWD), the previous directory. +If a directory named var(arg) is not found in the current directory +and var(arg) does not contain a slash, +search each component of the shell parameter tt(cdpath). +If the option tt(CDABLE_VARS) is set, and a parameter named var(arg) +exists whose value begins with a slash, treat its value as +the directory. + +If the option tt(PUSHD_SILENT) is not set, the directory +stack will be printed after a tt(pushd) is performed. + +The second form of tt(pushd) substitutes the string var(new) +for the string var(old) in the name of the current directory, +and tries to change to this new directory. + +The third form of tt(pushd) changes directory by rotating the +directory list. 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(-)var(n)' counts +from the right. If the tt(PUSHD_MINUS) option is set, the meanings +of `tt(PLUS())' and `tt(-)' in this context are swapped. +) +findex(pushln) +item(tt(pushln) [ var(arg) ... ])( +Equivalent to tt(print -nz). +) +findex(pwd) +pindex(CHASE_LINKS, use of) +item(tt(pwd) [ tt(-rLP) ])( +Print the absolute pathname of the current working directory. +If the tt(-r) or the tt(-P) flag is specified, or the tt(CHASE_LINKS) +option is set and the tt(-L) flag is not given, the printed path will not +contain symbolic links. +) +alias(r)(fc -e -) +findex(read) +vindex(IFS, use of) +item(tt(read) [ tt(-rzpqAclneE) ] [ tt(-k) [ var(num) ] ] \ +[ tt(-u)var(n) ] [ var(name)[tt(?)var(prompt)] ] [ var(name) ... ])( +Read one line and break it into fields using the characters +in tt($IFS) as separators, except as noted below. +The first field is assigned to the first var(name), the second field +to the second var(name), etc., with leftover +fields assigned to the last var(name). + +startitem() +item(tt(-r))( +Raw mode: a `tt(\)' at the end of a line does not signify line +continuation. +) +item(tt(-q))( +Read only one character from the terminal and set var(name) to +`tt(y)' if this character was `tt(y)' or `tt(Y)' and to `tt(n)' otherwise. +With this flag set the return value is zero only if the character was +`tt(y)' or `tt(Y)'. Note that this always reads from the terminal, even +if used with the tt(-p) or tt(-u) or tt(-z) flags or with redirected input. +) +item(tt(-k) [ var(num) ])( +Read only one (or var(num)) characters. All are assigned to the first +var(name), without word splitting. This flag is ignored when tt(-q) is +present. Input is read from the terminal unless one of tt(-u) or tt(-p) +is present. +) +item(tt(-z))( +Read one entry from the editor buffer stack and assign it to the first +var(name), without word splitting. Text is pushed onto the stack with +`tt(print -z)' or with tt(push-line) from the line editor (see +ifzman(zmanref(zshzle))\ +ifnzman(noderef(Zsh Line Editor))\ +). This flag is ignored when the tt(-k) or tt(-q) flags are present. +) +xitem(tt(-e)) +item(tt(-E))( +The input read is printed (echoed) to the standard output. If the tt(-e) +flag is used, no input is assigned to the parameters. +) +item(tt(-A))( +The first var(name) is taken as the name of an array and all words are +assigned to it. +) +xitem(tt(-c)) +item(tt(-l))( +These flags are allowed only if called inside a +function used for completion (specified with the tt(-K) flag to +tt(compctl)). If the tt(-c) flag is given, the words of the +current command are read. If the tt(-l) flag is given, the whole +line is assigned as a scalar. If both flags are present, tt(-l) +is used and tt(-c) is ignored. If var(name) is omitted then +tt(REPLY) is used for scalars and tt(reply) for arrays. +) +item(tt(-n))( +Together with tt(-c), the number of the word the cursor is on is +read. With tt(-l), the index of the character the cursor is on is +read. Note that the command name is word number 1, not word 0, +and that when the cursor is at the end of the line, its character +index is the length of the line plus one. +) +item(tt(-u)var(n))( +Input is read from file descriptor var(n). +) +item(tt(-p))( +Input is read from the coprocess. +) +enditem() + +If the first argument contains a `tt(?)', the remainder of this +word is used as a var(prompt) on standard error when the shell +is interactive. + +The value (exit status) of tt(read) is 1 when an end-of-file is +encountered, or when tt(-c) or tt(-l) is present and the command is +not called from a tt(compctl) function. Otherwise the value is 0. + +The behavior of some combinations of the tt(-k), tt(-p), tt(-q), tt(-u) +and tt(-z) flags is undefined. Presently tt(-q) cancels all the others, +tt(-p) cancels tt(-u), tt(-k) cancels tt(-z), and otherwise tt(-z) +cancels both tt(-p) and tt(-u). + +The tt(-c) or tt(-l) flags cancel any and all of tt(-kpquz). +) +cindex(parameters, marking readonly) +alias(readonly)(typeset -r) +alias(rehash)(hash -r) +findex(return) +cindex(functions, returning from) +item(tt(return) [ var(n) ])( +Causes a shell function or tt(.) script to return to +the invoking script with the return status specified by var(n). If var(n) +is omitted, the return status is that of the last command +executed. + +If tt(return) was executed from a trap in a tt(TRAP)var(NAL) function, +the effect is different for zero and non-zero return status. With zero +status (or after an implicit return at the end of the trap), the shell +will return to whatever it was previously processing; with a non-zero +status, the shell will behave as interrupted except that the return +status of the trap is retained. Note that the signal which caused the +trap is passed as the first argument, so the statement `tt(return +$((128PLUS()$1)))' will return the same status as if the signal had not +been trapped. +) +findex(set) +cindex(parameters, listing) +cindex(parameters, positional) +cindex(parameters, setting array) +cindex(array parameters, setting) +item(tt(set) [ {tt(PLUS())|tt(-)}var(options) | {tt(PLUS())|tt(-)}tt(o) var(option_name) ] ... [ {tt(PLUS())|tt(-)}tt(A) [ var(name) ] ] [ var(arg) ... ])( +Set the options for the shell and/or set the positional parameters, or +declare and set an array. If the tt(-s) option is given, it causes the +specified arguments to be sorted before assigning them to the positional +parameters (or to the array var(name) if tt(-A) is used). With tt(PLUS()s) +sort arguments in descending order. For the meaning of the other flags, see +ifzman(zmanref(zshoptions))\ +ifnzman(noderef(Options))\ +. Flags may be specified by name using the tt(-o) option. + +If the tt(-A) flag is specified, var(name) is +set to an array containing the given var(arg)s. if tt(PLUS()A) is used and +var(name) is an array, the given arguments will replace the initial +elements of that array; if no var(name) is specified, all arrays are +printed. Otherwise the positional parameters are set. If no arguments are +given, then the names and values of all parameters are printed on the +standard output. If the only argument is `tt(PLUS())', +the names of all parameters are printed. +) +findex(setopt) +cindex(options, setting) +item(tt(setopt) [ {tt(PLUS())|tt(-)}var(options) | \ +{tt(PLUS())|tt(-)}tt(o) var(option_name) ] [ var(name) ... ])( +Set the options for the shell. All options specified either +with flags or by name are set. If no arguments are supplied, +the names of all options currently set are printed. +If the tt(-m) flag is given the arguments are taken as patterns +(which should be quoted to preserve them from being interpreted as glob +patterns), and all options with names matching these patterns are set. +) +findex(shift) +cindex(parameters, positional) +item(tt(shift) [ var(n) ] [ var(name) ... ])( +The positional parameters tt(${)var(n)PLUS()1tt(}) ... are renamed +to tt($1) ..., where var(n) is an arithmetic expression that +defaults to 1. +If any var(name)s are given then the arrays with these names are +shifted instead of the positional parameters. +) +findex(source) +item(tt(source) var(file) [ var(arg) ... ])( +Same as tt(.), except that the current directory is always searched and +is always searched first, before directories in tt($path). +) +findex(suspend) +cindex(shell, suspending) +cindex(suspending the shell) +item(tt(suspend) [ tt(-f) ])( +Suspend the execution of the shell (send it a tt(SIGTSTP)) +until it receives a tt(SIGCONT). +Unless the tt(-f) option is given, this will refuse to suspend a login shell. +) +findex(test) +xitem(tt(test) [ var(arg) ... ]) +item(tt([) [ var(arg) ... ] tt(]))( +Like the system version of tt(test). Added for compatibility; +use conditional expressions instead (see noderef(Conditional Expressions)). +) +findex(times) +cindex(shell, timing) +cindex(timing the shell) +item(tt(times))( +Print the accumulated user and system times for the shell +and for processes run from the shell. +) +findex(trap) +cindex(signals, trapping) +cindex(trapping signals) +item(tt(trap) [ var(arg) [ var(sig) ... ] ])( +var(arg) is a command to be read and executed when the shell +receives var(sig). Each var(sig) can be given as a number +or as the name of a signal. +If var(arg) is `tt(-)', then all traps var(sig) are reset to their +default values. If var(arg) is the null string, then this signal +is ignored by the shell and by the commands it invokes. + +If var(sig) is tt(ZERR) then var(arg) will be executed +after each command with a nonzero exit status. +If var(sig) is tt(DEBUG) then var(arg) will be executed +after each command. +If var(sig) is tt(0) or tt(EXIT) +and the tt(trap) statement is executed inside the body of a function, +then the command var(arg) is executed after the function completes. +If var(sig) is tt(0) or tt(EXIT) +and the tt(trap) statement is not executed inside the body of a function, +then the command var(arg) is executed when the shell terminates. + +The tt(trap) command with no arguments prints a list of commands +associated with each signal. +) +findex(true) +cindex(doing nothing, successfully) +item(tt(true) [ var(arg) ... ])( +Do nothing and return an exit code of 0. +) +findex(ttyctl) +cindex(tty, freezing) +item(tt(ttyctl) tt(-fu))( +The tt(-f) option freezes the tty, and tt(-u) unfreezes it. +When the tty is frozen, no changes made to the tty settings by +external programs will be honored by the shell, except for changes in the +size of the screen; the shell will +simply reset the settings to their previous values as soon as each +command exits or is suspended. Thus, tt(stty) and similar programs have +no effect when the tty is frozen. Without options it reports whether the +terminal is frozen or not. +) +findex(type) +item(tt(type) [ tt(-wfpams) ] var(name) ...)( +Equivalent to tt(whence -v). +) +findex(typeset) +cindex(parameters, setting) +cindex(parameters, declaring) +item(tt(typeset) [ {tt(PLUS())|tt(-)}tt(LRUZfilrtuxm) [var(n)]] [ var(name)[tt(=)var(value)] ... ])( +Set attributes and values for shell parameters. +When invoked inside a function a new parameter is created which will be +unset when the function completes. The new parameter will not be +exported unless tt(ALL_EXPORT) is set, in which case the parameter will be +exported provided no parameter of that name already exists. +The following attributes are valid: + +startitem() +item(tt(-L))( +Left justify and remove leading blanks from var(value). +If var(n) is nonzero, it defines the width of the field; +otherwise it is determined by the width of the value of the first +assignment. +When the parameter is printed, it is filled on the right with +blanks or truncated if necessary to fit the field. +Leading zeros are removed if the tt(-Z) flag is also set. +) +item(tt(-R))( +Right justify and fill with leading blanks. If var(n) is nonzero +if defines the width of the field; +otherwise it is determined by the width of the value of the first +assignment. +When the parameter is printed, the field is left filled with +blanks or truncated from the end. +) +item(tt(-U))( +For arrays keep only the first element of each duplications. It can also be +set for colon separated special parameters like tt(PATH) or tt(FIGNORE), +etc. +) +item(tt(-Z))( +Right justify and fill with leading zeros if the first non-blank +character is a digit and the tt(-L) flag has not been set. +If var(n) is nonzero it defines the width of the field; +otherwise it is determined by the width of the value of the +first assignment. +) +item(tt(-f))( +The names refer to functions rather than parameters. No assignments +can be made, and the only other valid flags are tt(-t) +and tt(-u). The flag tt(-t) turns on execution tracing for this +function. The flag tt(-u) causes this function to be marked +for autoloading. The tt(fpath) parameter will be searched to find the +function definition when the function is first referenced; see +noderef(Functions). +) +item(tt(-i))( +Use an internal integer representation. If var(n) is nonzero +it defines the output arithmetic base, otherwise it is determined by the first +assignment. +) +item(tt(-l))( +Convert to lower case. +) +item(tt(-r))( +The given var(name)s are marked readonly. +) +item(tt(-t))( +Tags the named parameters. Tags have no special meaning to the shell. +) +item(tt(-u))( +Convert to upper case. +) +item(tt(-x))( +Mark for automatic export to the environment of subsequently +executed commands. +) +enditem() + +Using `tt(PLUS())' rather than `tt(-)' causes these flags to be turned off. +If no arguments are given but flags are specified, +a list of named parameters which have these flags set is printed. +Using `tt(PLUS())' instead of `tt(-)' keeps their values from being printed. +If no arguments or options are given, the names and attributes +of all parameters are printed. If only the tt(-m) flag is given the +arguments are taken as patterns (should be quoted) and all parameters +or functions (with the tt(-f) flag) with matching names are printed. +) +findex(ulimit) +cindex(resource limits) +cindex(limits, resource) +item(tt(ulimit) [ tt(-SHacdflmnpstv) [ tt(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 the value `tt(unlimited)'. If the tt(-H) flag is given use +hard limits instead of soft limits. If the tt(-S) flag is given +together with the tt(-H) flag set both hard and soft limits. If no +options are used, the file size limit (tt(-f)) is assumed. If +var(limit) is omitted the current value of the specified resources are +printed. When more than one resource values are printed the limit name and +unit is printed before each value. + +startsitem() +sitem(tt(-a))(Lists all of the current resource limits.) +sitem(tt(-c))(512-byte blocks on the size of core dumps.) +sitem(tt(-d))(K-bytes on the size of the data segment.) +sitem(tt(-f))(512-byte blocks on the size of files written.) +sitem(tt(-l))(K-bytes on the size of locked-in memory.) +sitem(tt(-m))(K-bytes on the size of physical memory.) +sitem(tt(-n))(open file descriptors.) +sitem(tt(-s))(K-bytes on the size of the stack.) +sitem(tt(-t))(CPU seconds to be used.) +sitem(tt(-u))(processes available to the user.) +sitem(tt(-v))(K-bytes on the size of virtual memory.) +endsitem() +) +findex(umask) +cindex(umask) +item(tt(umask) [ tt(-S) ] [ var(mask) ])( +The umask is set to var(mask). var(mask) can be either +an octal number or a symbolic value as described in manref(chmod)(1). +If var(mask) is omitted, the current value is printed. The tt(-S) +option causes the mask to be printed as a symbolic value. Otherwise, +the mask is printed as an octal number. Note that in +the symbolic form the permissions you specify are those which are to be +allowed (not denied) to the users specified. +) +cindex(aliases, removing) +alias(unalias)(unhash -a) +cindex(functions, removing) +alias(unfunction)(unhash -f) +findex(unhash) +item(tt(unhash) [ tt(-adfm) ] var(name) ...)( +Remove the element named var(name) from an internal hash table. The +default is remove elements from the command hash table. The tt(-a) +option causes tt(unhash) to remove aliases. The tt(-f) option causes +tt(unhash) to remove shell functions. The tt(-d) options causes +tt(unhash) to remove named directories. If the tt(-m) flag is given +the arguments are taken as patterns (should be quoted) and all elements +of the corresponding hash table with matching names will be removed. +) +findex(unlimit) +cindex(resource limits) +cindex(limits, resource) +item(tt(unlimit) [ tt(-hs) ] var(resource) ...)( +The resource limit for each var(resource) is set to the hard limit. +If the tt(-h) flag is given and the shell has appropriate privileges, +the hard resource limit for each var(resource) is removed. +The resources of the shell process are only changed if the tt(-s) +flag is given. +) +findex(unset) +cindex(parameters, unsetting) +item(tt(unset) [ tt(-fm) ] var(name) ...)( +Each named parameter is unset. +Local parameters remain local even if unset; they appear unset within scope, +but the previous value will still reappear when the scope ends. + +If the tt(-m) flag is specified the +arguments are taken as patterns (should be quoted) and all parameters +with matching names are unset. tt(unset -f) is equivalent to +tt(unfunction). +) +findex(unsetopt) +cindex(options, unsetting) +item(tt(unsetopt) [ {tt(PLUS())|tt(-)}var(options) | \ +{tt(PLUS())|tt(-)}tt(o) var(option_name) ] [ var(name) ... ])( +Unset the options for the shell. All options specified either +with flags or by name are unset. If no arguments are supplied, +the names of all options currently unset are printed. +If the tt(-m) flag is given the arguments are taken as patterns +(which should be quoted to preserve them from being interpreted as glob +patterns), and all options with names matching these patterns are unset. +) +findex(wait) +cindex(waiting for jobs) +cindex(jobs, waiting for) +item(tt(wait) [ var(job) ... ])( +Wait for the specified jobs or processes. If var(job) is not given +then all currently active child processes are waited for. +Each var(job) can be either a job specification or the process ID +of a job in the job table. +The exit status from this command is that of the job waited for. +) +findex(whence) +item(tt(whence) [ tt(-vcwfpams) ] var(name) ...)( +For each name, indicate how it would be interpreted if used as a +command name. + +startitem() +item(tt(-v))( +Produce a more verbose report. +) +item(tt(-c))( +Print the results in a bf(csh)-like format. +This takes precedence over tt(-v). +) +item(tt(-w))( +For each var(name), print `var(name)tt(:) var(word)' where var(word) +is one of tt(alias), tt(builtin), tt(command), tt(function), +tt(hashed), tt(reserved) or tt(none), according as var(name) +corresponds to an alias, a built-in command, an external command, a +shell function, a command defined with the tt(hash) builtin, a +reserved word, or is not recognised. This takes precedence over +tt(-v) and tt(-c). +) +item(tt(-f))( +Causes the contents of a shell function to be +displayed, which would otherwise not happen unless the tt(-c) +flag were used. +) +item(tt(-p))( +Do a path search for var(name) +even if it is an alias, reserved word, shell function or builtin. +) +item(tt(-a))( +Do a search for all occurrences of var(name) +throughout the command path. +Normally only the first occurrence is printed. +) +item(tt(-m))( +The arguments are taken as patterns (should be +quoted), and the information is displayed for each command matching one +of these patterns. +) +item(tt(-s))( +If a pathname contains symlinks, print the symlink-free pathname as well. +) +enditem() +) +findex(where) +item(tt(where) [ tt(-wpms) ] var(name) ...)( +Equivalent to tt(whence -ca). +) +findex(which) +item(tt(which) [ tt(-wpams) ] var(name) ...)( +Equivalent to tt(whence -c). +) +findex(zmodload) +cindex(modules, loading) +cindex(loading modules) +xitem(tt(zmodload) [ tt(-iL) ] [ var(name) ... ]) +xitem(tt(zmodload) tt(-u) [ tt(-i) ] var(name) ...) +xitem(tt(zmodload) tt(-d) [ tt(-L) ] [ var(name) [ var(dep) ... ] ]) +xitem(tt(zmodload) tt(-du) var(name) [ var(dep) ... ]) +xitem(tt(zmodload) tt(-a) [ tt(-iL) ] [ var(name) [ var(builtin) ... ] ]) +item(tt(zmodload) tt(-au) [ tt(-i) ] var(builtin) ...)( +tt(zmodload) performs operations relating to zsh's loadable modules. +This feature is not available on all operating systems, +or on all installations on a particular operating system. + +In the simplest case, +tt(zmodload) loads a binary module. The module must be in a file with a +name consisting of the specified var(name) followed by a standard suffix, +usually `tt(.so)'. If this can't be found, the var(name) is tried without +the suffix. +If the module to be loaded is already loaded and the tt(-i) +option is given, the duplicate module is ignored. Otherwise +tt(zmodload) prints an error message. + +The var(name)d module is searched for in the same way a command is, using +tt($module_path) instead of tt($path). If var(name) contains a `tt(/)', +it will be used as-is, and a path search will be performed otherwise. +This behaviour can be modified by the tt(PATH_DIRS) option. +cindex(PATH_DIRS, use of) + +With tt(-u), tt(zmodload) unloads modules. The same var(name) +must be given that was given when the module was loaded, but it is not +necessary for the module to exist in the filesystem. +The tt(-i) option suppresses the error if the module is already +unloaded (or was never loaded). + +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. + +Without arguments all currently loaded binary modules are printed. +The tt(-L) option causes this list to be in the form of a series of +tt(zmodload) commands. + +The tt(-d) option can be used to specify module dependencies. +This operation is idempotent regardless of the tt(-i) option. +The modules named in the second and subsequent arguments will be +loaded before the module named in the first argument. + +With tt(-d) and one +argument, all dependencies for that module are listed. With tt(-d) and no +arguments, all module dependencies are listed. +This listing is by default in a Makefile-like format. +The tt(-L) option changes this format to a list of +tt(zmodload -d) commands. + +If tt(-d) and tt(-u) are both used, dependencies are removed. +This operation is idempotent regardless of the tt(-i) option. +If only one argument is given, all dependencies for that module are removed. + +The tt(-a) option defines autoloaded builtins. It defines the +specified var(builtin)s. When any of those builtins is called, the module +specified in the first argument is loaded. If only one argument is given, +one builtin is defined, with the same name as the module. +tt(-i) suppresses the error if the builtin is already defined or +autoloaded, regardless of which module it came from. + +With tt(-a) and no arguments, all +autoloaded builtins are listed, with the module name (if different) +shown in parentheses after the builtin name. The tt(-L) option changes +this format to a list of tt(zmodload -a) commands. + +If tt(-a) is used +together with the tt(-u) option it removes builtins defined with +tt(zmodload -a). This is only possible if the builtin is not yet +loaded. tt(-i) suppresses the error if the builtin is already +removed (or never existed). +) +enditem() diff --git a/Doc/Zsh/compat.yo b/Doc/Zsh/compat.yo new file mode 100644 index 000000000..529bd4557 --- /dev/null +++ b/Doc/Zsh/compat.yo @@ -0,0 +1,69 @@ +texinode(Compatibility)(Prompt Expansion)(Conditional Expressions)(Top) +chapter(Compatibility) +ifzman(\ +sect(Compatibility) +)\ +cindex(compatibility) +cindex(sh, compatibility) +cindex(ksh, compatibility) +Zsh tries to emulate bf(sh) or bf(ksh) when it is invoked as +tt(sh) or tt(ksh) respectively. In this mode the following +parameters are not special and not initialized by the shell: +tt(ARGC), +tt(argv), +tt(cdpath), +tt(fignore), +tt(fpath), +tt(HISTCHARS), +tt(mailpath), +tt(MANPATH), +tt(manpath), +tt(path), +tt(prompt), +tt(PROMPT), +tt(PROMPT2), +tt(PROMPT3), +tt(PROMPT4), +tt(psvar), +tt(status), +tt(watch). + +The usual zsh startup/shutdown scripts are not executed. Login shells +source tt(/etc/profile) followed by tt($HOME/.profile). If the +tt(ENV) environment variable is set on invocation, tt($ENV) is sourced +after the profile scripts. The value of tt(ENV) is subjected to +parameter expansion, command substitution, and arithmetic expansion before +being interpreted as a pathname. Note that the tt(PRIVILEGED) option +also affects the execution of startup files. + +The following options are set if the shell is invoked as tt(sh) or +tt(ksh): +tt(NO_BAD_PATTERN), +tt(NO_BANG_HIST), +tt(NO_BG_NICE), +tt(NO_EQUALS), +tt(NO_FUNCTION_ARGZERO), +tt(GLOB_SUBST), +tt(NO_HUP), +tt(INTERACTIVE_COMMENTS), +tt(KSH_ARRAYS), +tt(NO_MULTIOS), +tt(NO_NOMATCH), +tt(NO_NOTIFY), +tt(POSIX_BUILTINS), +tt(NO_PROMPT_PERCENT), +tt(RM_STAR_SILENT), +tt(SH_FILE_EXPANSION), +tt(SH_GLOB), +tt(SH_OPTION_LETTERS), +tt(SH_WORD_SPLIT). +Additionally the tt(BSD_ECHO) and tt(IGNORE_BRACES) +options are set if zsh is invoked as tt(sh). +Also, the +tt(KSH_OPTION_PRINT), +tt(LOCAL_OPTIONS), +tt(PROMPT_BANG), +tt(PROMPT_SUBST) +and +tt(SINGLE_LINE_ZLE) +options are set if zsh is invoked as tt(ksh). diff --git a/Doc/Zsh/compctl.yo b/Doc/Zsh/compctl.yo new file mode 100644 index 000000000..a78a18fa9 --- /dev/null +++ b/Doc/Zsh/compctl.yo @@ -0,0 +1,526 @@ +texinode(Programmable Completion)(Zsh Modules)(Zsh Line Editor)(Top) +chapter(Programmable Completion) +cindex(completion, programmable) +cindex(completion, controlling) +findex(compctl) +sect(Description) +startlist() +list(tt(compctl) [ tt(-CDT) ] var(options) [ var(command) ... ]) +list(tt(compctl) [ tt(-CDT) ] var(options) \ + [ tt(-x) var(pattern) var(options) tt(-) ... tt(--) ] \ + [ tt(PLUS()) var(options) [ tt(-x) ... tt(--) ] ... [tt(PLUS())] ] \ + [ var(command) ... ]) +list(tt(compctl) tt(-L) [ tt(-CDT) ] [ var(command) ... ]) +list(tt(compctl) tt(PLUS()) var(command) ...) +endlist() + +Control the editor's completion behavior according to the supplied set +of var(options). Various editing commands, notably +tt(expand-or-complete-word), usually bound to tab, will +attempt to complete a word typed by the user, while others, notably +tt(delete-char-or-list), usually bound to ^D in EMACS editing +mode, list the possibilities; tt(compctl) controls what those +possibilities are. They may for example be filenames (the most common +case, and hence the default), shell variables, or words from a +user-specified list. +startmenu() +menu(Command Flags) +menu(Option Flags) +menu(Alternative Completion) +menu(Extended Completion) +menu(Example) +endmenu() +texinode(Command Flags)(Option Flags)()(Programmable Completion) +sect(Command Flags) +Completion of the arguments of a command may be different for each +command or may use the default. The behavior when completing the +command word itself may also be separately specified. These +correspond to the following flags and arguments, all of which (except +for tt(-L)) may be combined with any combination of the +var(options) described subsequently in noderef(Option Flags): + +startitem() +item(var(command) ...)( +controls completion for the named commands, which must be listed last +on the command line. If completion is attempted for a command with a +pathname containing slashes and no completion definition is found, the +search is retried with the last pathname component. Note that aliases +are expanded before the command name is determined unless the +tt(COMPLETE_ALIASES) option is set. Commands should not be combined +with the tt(-C), tt(-D) or tt(-T) flags. +) +item(tt(-C))( +controls completion when the command word itself is being completed. +If no tt(compctl -C) command has been issued, the names of any +executable command (whether in the path or specific to the shell, such +as aliases or functions) are completed. +) +item(tt(-D))( +controls default completion behavior for the arguments of commands not +assigned any special behavior. If no tt(compctl -D) command has +been issued, filenames are completed. +) +item(tt(-T))( +supplies completion flags to be used before any other processing is +done, even those given to specific commands with other compctl +definitions. This is only useful when combined with extended +completion (the tt(-x) flag, see noderef(Extended Completion) below). +Using this flag you can define default behavior +which will apply to all commands without exception, or you can alter +the standard behavior for all commands. For example, if your access +to the user database is too slow and/or it contains too many users (so +that completion after `tt(~)' is too slow to be usable), you can use + +nofill(tt(compctl -Tx 'C[0,*/*]' -f - 's[~]' -k friends -S/)) + +to complete the strings in the array tt(friends) after a `tt(~)'. +The first argument is necessary so that this form of ~-completion is +not tried after the directory name is finished. +) +item(tt(-L))( +lists the existing completion behavior in a manner suitable for +putting into a start-up script; the existing behavior is not changed. +Any combination of the above forms may be specified, otherwise all +defined completions are listed. Any other flags supplied +are ignored. +) +item(em(no argument))( +If no argument is given, tt(compctl) lists all defined completions +in an abbreviated form; with a list of var(options), all completions +with those flags set (not counting extended completion) are listed. +) +endlist() + +If the tt(PLUS()) flag is alone and followed immediately by the var(command) +list, the completion behavior for all the commands in the list is reset to +the default. In other words, completion will subsequently use the +options specified by the tt(-D) flag. +texinode(Option Flags)(Alternative Completion)(Command Flags)(Programmable Completion) +sect(Option Flags) +startlist() +list([ tt(-fcFBdeaRGovNAIOPZEnbjrzu/) ]) +list([ tt(-k) var(array) ] [ tt(-g) var(globstring) ] \ + [ tt(-s) var(subststring) ]) +list([ tt(-K) var(function) ] [ tt(-H) var(num pattern) ]) +list([ tt(-Q) ] [ tt(-P) var(prefix) ] [ tt(-S) var(suffix) ]) +list([ tt(-W) var(file-prefix) ]) +list([ tt(-q) ] [ tt(-X) var(explanation) ] [ tt(-Y) var(explanation) ]) +list([ tt(-y) var(func-or-var) ] [ tt(-l) var(cmd) ] [ tt(-U) ]) +endlist() + +The remaining var(options) specify the type of command arguments +to look for during completion. Any combination of these flags may be +specified; the result is a sorted list of all the possibilities. The +options are as follows. +startmenu() +menu(Simple Flags) +menu(Flags with Arguments) +menu(Control Flags) +endmenu() +texinode(Simple Flags)(Flags with Arguments)()(Option Flags) +subsect(Simple Flags) +These produce completion lists made up by the shell itself: + +startitem() +item(tt(-f))( +Filenames and filesystem paths. +) +item(tt(-/))( +Just filesystem paths. +) +item(tt(-c))( +Command names, including aliases, shell functions, builtins +and reserved words. +) +item(tt(-F))( +Function names. +) +item(tt(-B))( +Names of builtin commands. +) +item(tt(-m))( +Names of external commands. +) +item(tt(-w))( +Reserved words. +) +item(tt(-a))( +Alias names. +) +item(tt(-R))( +Names of regular (non-global) aliases. +) +item(tt(-G))( +Names of global aliases. +) +item(tt(-d))( +This can be combined with tt(-F), tt(-B), tt(-w), +tt(-a), tt(-R) and tt(-G) to get names of disabled +functions, builtins, reserved words or aliases. +) +item(tt(-e))( +This option (to show enabled commands) is in effect by default, but +may be combined with tt(-d); tt(-de) in combination with +tt(-F), tt(-B), tt(-w), tt(-a), tt(-R) and tt(-G) +will complete names of functions, builtins, reserved words or aliases +whether or not they are disabled. +) +item(tt(-o))( +Names of shell options (see +ifzman(zmanref(zshoptions))\ +ifnzman(noderef(Options))\ +). +) +item(tt(-v))( +Names of any variable defined in the shell. +) +item(tt(-N))( +Names of scalar (non-array) parameters. +) +item(tt(-A))( +Array names. +) +item(tt(-I))( +Names of integer variables. +) +item(tt(-O))( +Names of read-only variables. +) +item(tt(-p))( +Names of parameters used by the shell (including special parameters). +) +item(tt(-Z))( +Names of shell special parameters. +) +item(tt(-E))( +Names of environment variables. +) +item(tt(-n))( +Named directories. +) +item(tt(-b))( +Key binding names. +) +item(tt(-j))( +Job names: the first word of the job leader's command line. This is useful +with the tt(kill) builtin. +) +item(tt(-r))( +Names of running jobs. +) +item(tt(-z))( +Names of suspended jobs. +) +item(tt(-u))( +User names. +) +enditem() +texinode(Flags with Arguments)(Control Flags)(Simple Flags)(Option Flags) +subsect(Flags with Arguments) +These have user supplied arguments to determine how the list of +completions is to be made up: + +startitem() +item(tt(-k) var(array))( +Names taken from the elements of tt($)var(array) (note that the `tt($)' +does not appear on the command line). +Alternatively, the argument var(array) itself may be a set +of space- or comma-separated values in parentheses, in which any +delimiter may be escaped with a backslash; in this case the argument +should be quoted. For example, + +nofill(tt(compctl -k "(cputime filesize datasize stacksize + coredumpsize resident descriptors)" limit)) +) +item(tt(-g) var(globstring))( +The var(globstring) is expanded using filename globbing; it should be +quoted to protect it from immediate expansion. The resulting +filenames are taken as the possible completions. Use `tt(*(/))' instead of +`tt(*/)' for directories. The tt(fignore) special parameter is not +applied to the resulting files. More than one pattern may be given +separated by blanks. (Note that brace expansion is em(not) part of +globbing. Use the syntax `tt((either|or))' to match alternatives.) +) +item(tt(-s) var(subststring))( +The var(subststring) is split into words and these words are than +expanded using all shell expansion mechanisms (see +ifzman(zmanref(zshexpn))\ +ifnzman(noderef(Expansion))\ +). The resulting words are taken as possible +completions. The tt(fignore) special parameter is not applied to the +resulting files. Note that tt(-g) is faster for filenames. +) +item(tt(-K) var(function))( +Call the given function to get the completions. The function is +passed two arguments: the prefix and the suffix of the word on which +completion is to be attempted, in other words those characters before +the cursor position, and those from the cursor position onwards. The +whole command line can be accessed with the tt(-c) and tt(-l) flags +of the tt(read) builtin. The +function should set the variable tt(reply) to an array containing +the completions (one completion per element); note that tt(reply) +should not be made local to the function. From such a function the +command line can be accessed with the tt(-c) and tt(-l) flags to +the tt(read) builtin. For example, + +nofill(tt(function whoson { reply=(`users`); } +compctl -K whoson talk)) + +completes only logged-on users after `tt(talk)'. Note that `tt(whoson)' must +return an array, so `tt(reply=`users`)' would be incorrect. +) +item(tt(-H) var(num pattern))( +The possible completions are taken from the last var(num) history +lines. Only words matching var(pattern) are taken. If var(num) is +zero or negative the whole history is searched and if var(pattern) is +the empty string all words are taken (as with `tt(*)'). A typical +use is + +nofill(tt(compctl -D -f PLUS() -H 0 '')) + +which forces completion to look back in the history list for a word if +no filename matches. +) +enditem() +texinode(Control Flags)()(Flags with Arguments)(Option Flags) +subsect(Control Flags) +These do not directly specify types of name to be completed, but +manipulate the options that do: + +startitem() +item(tt(-Q))( +This instructs the shell not to quote any metacharacters in the possible +completions. Normally the results of a completion are inserted into +the command line with any metacharacters quoted so that they are +interpreted as normal characters. This is appropriate for filenames +and ordinary strings. However, for special effects, such as inserting +a backquoted expression from a completion array (tt(-k)) so that +the expression will not be evaluated until the complete line is +executed, this option must be used. +) +item(tt(-P) var(prefix))( +The var(prefix) is inserted just before the completed string; any +initial part already typed will be completed and the whole var(prefix) +ignored for completion purposes. For example, + +nofill(tt(compctl -j -P "%" kill)) + +inserts a `%' after the kill command and then completes job names. +) +item(tt(-S) var(suffix))( +When a completion is found the var(suffix) is inserted after +the completed string. In the case of menu completion the suffix is +inserted immediately, but it is still possible to cycle through the +list of completions by repeatedly hitting the same key. +) +item(tt(-W) var(file-prefix))( +With directory var(file-prefix): for command, file, directory and +globbing completion (options tt(-c), tt(-f), tt(-/), tt(-g)), the file +prefix is implicitly added in front of the completion. For example, + +nofill(tt(compctl -/ -W ~/Mail maildirs)) + +completes any subdirectories to any depth beneath the directory +tt(~/Mail), although that prefix does not appear on the command line. +) +item(tt(-q))( +If used with a suffix as specified by the tt(-S) option, this +causes the suffix to be removed if the next character typed is a blank +or does not insert anything (the same rule as used for the +tt(AUTO_REMOVE_SLASH) option). The option is most useful for list +separators (comma, colon, etc.). +) +item(tt(-l) var(cmd))( +This option cannot be combined with any other. It restricts the range +of command line words that are considered to be arguments. If +combined with one of the extended completion patterns `tt(p[)...tt(])', +`tt(r[)...tt(])', or `tt(R[)...tt(])' (see noderef(Extended Completion) +below) the range is restricted to the range of arguments +specified in the brackets. Completion is then performed as if these +had been given as arguments to the var(cmd) supplied with the +option. If the var(cmd) string is empty the first word in the range +is instead taken as the command name, and command name completion +performed on the first word in the range. For example, + +nofill(tt(compctl -x 'r[-exec,;]' -l '' -- find)) + +completes arguments between `tt(-exec)' and the following `tt(;)' (or the end +of the command line if there is no such string) as if they were +a separate command line. +) +item(tt(-U))( +Use the whole list of possible completions, whether or not they +actually match the word on the command line. The word typed so far +will be deleted. This is most useful with a function (given by the +tt(-K) option) which can examine the word components passed to it +(or via the tt(read) builtin's tt(-c) and tt(-l) flags) and +use its own criteria to decide what matches. If there is no +completion, the original word is retained. +) +item(tt(-y) var(func-or-var))( +The list provided by var(func-or-var) is displayed instead of the list +of completions whenever a listing is required; the actual completions +to be inserted are not affected. It can be provided in two +ways. Firstly, if var(func-or-var) begins with a tt($) it defines a +variable, or if it begins with a left parenthesis a literal +array, which contains the list. A variable may have been set by a +call to a function using the tt(-K) option. Otherwise it contains the +name of a function which will be executed to create the list. The +function will be passed as an argument list all matching completions, +including prefixes and suffixes expanded in full, and should set the +array var(reply) to the result. In both cases, the display list will +only be retrieved after a complete list of matches has been created. + +Note that the returned list does not have to correspond, even in +length, to the original set of matches, and may be passed as a scalar +instead of an array. No special formatting of characters is +performed on the output in this case; in particular, newlines are +printed literally and if they appear output in columns is suppressed. +) +item(tt(-X) var(explanation))( +Print var(explanation) when trying completion on the current set of +options. A `tt(%n)' in this string is replaced by the number of matches. +The explanation only appears if completion was tried and there was +no unique match, or when listing completions. +) +item(tt(-Y) var(explanation))( +Identical to tt(-X), except that the var(explanation) first undergoes +expansion following the usual rules for strings in double quotes. +The expansion will be carried out after any functions are called for +the tt(-K) or tt(-y) options, allowing them to set variables. +) +enditem() +texinode(Alternative Completion)(Extended Completion)(Option Flags)(Programmable Completion) +sect(Alternative Completion) +startlist() +list(tt(compctl) [ tt(-CDT) ] var(options) tt(PLUS()) var(options) [ tt(PLUS()) ... ] \ +[ tt(PLUS()) ] var(command) ...) +endlist() + +The form with `tt(PLUS())' specifies alternative options. Completion is +tried with the options before the first `tt(PLUS())'. If this produces no +matches completion is tried with the flags after the `tt(PLUS())' and so on. If +there are no flags after the last `tt(PLUS())' and a match has not been found +up to that point, default completion is tried. +texinode(Extended Completion)(Example)(Alternative Completion)(Programmable Completion) +sect(Extended Completion) +startlist() +list(tt(compctl) [ tt(-CDT) ] var(options) \ +tt(-x) var(pattern) var(options) tt(-) ... tt(--) \ +[ var(command) ... ]) +list(tt(compctl) [ tt(-CDT) ] var(options) \ +[ tt(-x) var(pattern) var(options) tt(-) ... tt(--) ] \ +[ tt(PLUS()) var(options) [ tt(-x) ... tt(--) ] ... [tt(PLUS())] ] \ +[ var(command) ... ]) +endlist() + +The form with `tt(-x)' specifies extended completion for the +commands given; as shown, it may be combined with alternative +completion using `tt(PLUS())'. Each var(pattern) is examined in turn; when a +match is found, the corresponding var(options), as described in +noderef(Option Flags) above, are used to generate possible +completions. If no var(pattern) matches, the var(options) given +before the tt(-x) are used. + +Note that each pattern should be supplied as a single argument and +should be quoted to prevent expansion of metacharacters by the +shell. + +A var(pattern) is built of sub-patterns separated by commas; it +matches if at least one of these sub-patterns matches (they are +`or'ed). These sub-patterns are in turn composed of other +sub-patterns separated by white spaces which match if all of the +sub-patterns match (they are `and'ed). An element of the +sub-patterns is of the form `var(c)tt([)...tt(][)...tt(])', where the pairs of +brackets may be repeated as often as necessary, and matches if any of +the sets of brackets match (an `or'). The example below makes this +clearer. + +The elements may be any of the following: + +startitem() +item(tt(s[)var(string)tt(])...)( +Matches if the current word on the command line starts with +one of the strings given in brackets. The var(string) is not removed +and is not part of the completion. +) +item(tt(S[)var(string)tt(])...)( +Like tt(s[)var(string)tt(]) except that the var(string) is part of the +completion. +) +item(tt(p[)var(from)tt(,)var(to)tt(])...)( +Matches if the number of the current word is between one of +the var(from) and var(to) pairs inclusive. The comma and var(to) +are optional; var(to) defaults to the same value as var(from). The +numbers may be negative: tt(-)var(n) refers to the var(n)'th last word +on the line. +) +item(tt(c[)var(offset)tt(,)var(string)tt(])...)( +Matches if the var(string) matches the word offset by +var(offset) from the current word position. Usually var(offset) +will be negative. +) +item(tt(C[)var(offset)tt(,)var(pattern)tt(])...)( +Like tt(c) but using pattern matching instead. +) +item(tt(w[)var(index)tt(,)var(string)tt(])...)( +Matches if the word in position var(index) is equal +to the corresponding var(string). Note that the word count is made +after any alias expansion. +) +item(tt(W[)var(index)tt(,)var(pattern)tt(])...)( +Like tt(w) but using pattern matching instead. +) +item(tt(n[)var(index)tt(,)var(string)tt(])...)( +Matches if the current word contains var(string). Anything up to and +including the var(index)th occurrence of this string will not be +considered part of the completion, but the rest will. var(index) may +be negative to count from the end: in most cases, var(index) will be +1 or -1. For example, + +nofill(tt(compctl -s '`users`' -x 'n[1,@]' -k hosts -- talk)) + +will usually complete usernames, but if you insert an tt(@) after the +name, names from the array var(hosts) (assumed to contain hostnames, +though you must make the array yourself) will be completed. Other +commands such as tt(rcp) can be handled similarly. +) +item(tt(N[)var(index)tt(,)var(string)tt(])...)( +Like tt(n) except that the string will be +taken as a character class. Anything up to and including the +var(index)th occurrence of any of the characters in var(string) +will not be considered part of the completion. +) +item(tt(m[)var(min)tt(,)var(max)tt(])...)( +Matches if the total number of words lies between var(min) and +var(max) inclusive. +) +item(tt(r[)var(str1)tt(,)var(str2)tt(])...)( +Matches if the cursor is after a word with prefix var(str1). If there +is also a word with prefix var(str2) on the command line it matches +only if the cursor is before this word. +) +item(tt(R[)var(str1)tt(,)var(str2)tt(])...)( +Like tt(r) but using pattern matching instead. +) +enditem() +texinode(Example)()(Extended Completion)(Programmable Completion) +sect(Example) +nofill(tt(compctl -u -x 's[tt(PLUS())] c[-1,-f],s[-f+PLUS()]' -g '~/Mail/*(:t)' \ + - 's[-f],c[-1,-f]' -f -- mail)) + +This is to be interpreted as follows: + +If the current command is tt(mail), then + +indent( +if ((the current word begins with tt(PLUS()) and the previous word is tt(-f)) +or (the current word begins with tt(-f+PLUS()))), then complete the +non-directory part (the `tt(:t)' glob modifier) of files in the directory +tt(~/Mail); else + +if the current word begins with tt(-f) or the previous word was tt(-f), then +complete any file; else + +complete user names. +) diff --git a/Doc/Zsh/cond.yo b/Doc/Zsh/cond.yo new file mode 100644 index 000000000..0ff49b187 --- /dev/null +++ b/Doc/Zsh/cond.yo @@ -0,0 +1,158 @@ +texinode(Conditional Expressions)(Compatibility)(Arithmetic Evaluation)(Top) +chapter(Conditional Expressions) +ifzman(\ +sect(Conditional Expressions) +)\ +cindex(conditional expressions) +cindex(expressions, conditional) +A em(conditional expression) is used with the tt([[) +compound command to test attributes of files and to compare strings. +Each expression can be constructed from one or more +of the following unary or binary expressions: + +startitem() +item(tt(-a) var(file))( +true if var(file) exists. +) +item(tt(-b) var(file))( +true if var(file) exists and is a block special file. +) +item(tt(-c) var(file))( +true if var(file) exists and is a character special file. +) +item(tt(-d) var(file))( +true if var(file) exists and is a directory. +) +item(tt(-e) var(file))( +true if var(file) exists. +) +item(tt(-f) var(file))( +true if var(file) exists and is a regular file. +) +item(tt(-g) var(file))( +true if var(file) exists and has its setgid bit set. +) +item(tt(-h) var(file))( +true if var(file) exists and is a symbolic link. +) +item(tt(-k) var(file))( +true if var(file) exists and has its sticky bit set. +) +item(tt(-n) var(string))( +true if length of var(string) is non-zero. +) +item(tt(-o) var(option))( +true if option named var(option) is on. var(option) +may be a single character, in which case it is a single letter option name. +(See noderef(Specifying Options).) +) +item(tt(-p) var(file))( +true if var(file) exists and is a FIFO special file (named pipe). +) +item(tt(-r) var(file))( +true if var(file) exists and is readable by current process. +) +item(tt(-s) var(file))( +true if var(file) exists and has size greater than zero. +) +item(tt(-t) var(fd))( +true if file descriptor number var(fd) +is open and associated with a terminal device. +(note: var(fd) is not optional) +) +item(tt(-u) var(file))( +true if var(file) exists and has its setuid bit set. +) +item(tt(-w) var(file))( +true if var(file) exists and is writable by current process. +) +item(tt(-x) var(file))( +true if var(file) exists and is executable by current process. +If var(file) exists and is a directory, then the current process +has permission to search in the directory. +) +item(tt(-z) var(string))( +true if length of var(string) is zero. +) +item(tt(-L) var(file))( +true if var(file) exists and is a symbolic link. +) +item(tt(-O) var(file))( +true if var(file) exists and is owned by the effective user ID of this process. +) +item(tt(-G) var(file))( +true if var(file) exists and its group matches +the effective group ID of this process. +) +item(tt(-S) var(file))( +true if var(file) exists and is a socket. +) +item(tt(-N) var(file))( +true if var(file) exists and its access time is +not newer than its modification time. +) +item(var(file1) tt(-nt) var(file2))( +true if var(file1) exists and is newer than var(file2). +) +item(var(file1) tt(-ot) var(file2))( +true if var(file1) exists and is older than var(file2). +) +item(var(file1) tt(-ef) var(file2))( +true if var(file1) and var(file2) exist and refer to the same file. +) +xitem(var(string) tt(=) var(pattern)) +item(var(string) tt(==) var(pattern))( +true if var(string) matches var(pattern). +The `tt(==)' form is the preferred one. The `tt(=)' form is for +backward compatibility and should be considered obsolete. +) +item(var(string) tt(!=) var(pattern))( +true if var(string) does not match var(pattern). +) +item(var(string1) tt(<) var(string2))( +true if var(string1) comes before var(string2) +based on ASCII value of their characters. +) +item(var(string1) tt(>) var(string2))( +true if var(string1) comes after var(string2) +based on ASCII value of their characters. +) +item(var(exp1) tt(-eq) var(exp2))( +true if var(exp1) is numerically equal to var(exp2). +) +item(var(exp1) tt(-ne) var(exp2))( +true if var(exp1) is numerically not equal to var(exp2). +) +item(var(exp1) tt(-lt) var(exp2))( +true if var(exp1) is numerically less than var(exp2). +) +item(var(exp1) tt(-gt) var(exp2))( +true if var(exp1) is numerically greater than var(exp2). +) +item(var(exp1) tt(-le) var(exp2))( +true if var(exp1) is numerically less than or equal to var(exp2). +) +item(var(exp1) tt(-ge) var(exp2))( +true if var(exp1) is numerically greater than or equal to var(exp2). +) +item(tt(LPAR()) var(exp) tt(RPAR()))( +true if var(exp) is true. +) +item(tt(!) var(exp))( +true if var(exp) is false. +) +item(var(exp1) tt(&&) var(exp2))( +true if var(exp1) and var(exp2) are both true. +) +item(var(exp1) tt(||) var(exp2))( +true if either var(exp1) or var(exp2) is true. +) +enditem() + +In each of the above expressions, if +var(file) is of the form `tt(/dev/fd/)var(n)', +where var(n) is an integer, +then the test applied to the open file whose +descriptor number is var(n), +even if the underlying system does not support +the tt(/dev/fd) directory. diff --git a/Doc/Zsh/exec.yo b/Doc/Zsh/exec.yo new file mode 100644 index 000000000..0d53b14b8 --- /dev/null +++ b/Doc/Zsh/exec.yo @@ -0,0 +1,25 @@ +texinode(Command Execution)(Functions)(Redirection)(Top) +chapter(Command Execution) +ifzman(\ +sect(Command Execution) +)\ +cindex(command execution) +cindex(execution, of commands) +If a command name contains no slashes, the shell attempts to locate +it. If there exists a shell function by that name, the function +is invoked as described in noderef(Functions). If there exists +a shell builtin by that name, the builtin is invoked. + +vindex(path, use of) +Otherwise, the shell searches each element of tt($path) for a +directory containing an executable file by that name. If the +search is unsuccessful, the shell prints an error message and returns +a nonzero exit status. + +If execution fails because the file is not in executable format, +and the file is not a directory, it is assumed to be a shell +script. tt(/bin/sh) is spawned to execute it. If the program +is a file beginning with `tt(#!)', the remainder of the first line +specifies an interpreter for the program. The shell will +execute the specified interpreter on operating systems that do +not handle this executable format in the kernel. diff --git a/Doc/Zsh/expn.yo b/Doc/Zsh/expn.yo new file mode 100644 index 000000000..99844b42a --- /dev/null +++ b/Doc/Zsh/expn.yo @@ -0,0 +1,1052 @@ +texinode(Expansion)(Parameters)(Restricted Shell)(Top) +chapter(Expansion) +cindex(expansion) +sect(Description) +The types of expansions performed are + +startlist() +list(em(history expansion)) +list(em(alias expansion)) +list(em(process substitution)) +list(em(parameter expansion)) +list(em(command substitution)) +list(em(arithmetic expansion)) +list(em(brace expansion)) +list(em(filename expansion)) +list(em(filename generation)) +endlist() + +Expansion is done in the above specified order in five steps. The +first is em(history expansion), which is only performed in +interactive shells. The next step is em(alias expansion), which is +done right before the command line is parsed. They are followed by +em(process substitution), em(parameter expansion), em(command +substitution), em(arithmetic expansion) and em(brace expansion) +which are performed in one step in left-to-right fashion. After +these expansions, all unquoted occurrences of the characters `tt(\)', +`tt(')' and `tt(")' are removed, and the result is subjected to +em(filename expansion) followed by em(filename generation). + +If the tt(SH_FILE_EXPANSION) option is set, the order of expansion is modified +for compatibility with bf(sh) and bf(ksh). em(Filename expansion) +is performed immediately after em(alias substitution), +preceding the set of five substitutions mentioned above. +startmenu() +menu(History Expansion) +menu(Process Substitution) +menu(Parameter Expansion) +menu(Command Substitution) +menu(Arithmetic Expansion) +menu(Brace Expansion) +menu(Filename Expansion) +menu(Filename Generation) +endmenu() +texinode(History Expansion)(Process Substitution)()(Expansion) +sect(History Expansion) +cindex(history) +cindex(history expansion) +cindex(expansion, history) +History expansion allows you to use words from previous command +lines in the command line you are typing. This simplifies spelling +corrections and the repetition of complicated commands or arguments. +Command lines are saved in the history list, the size of which +is controlled by the tt(HISTSIZE) +vindex(HISTSIZE, use of) +variable. The most recent command is retained in any case. +A history expansion begins with the first character of the +tt(histchars) parameter which is `tt(!)' +by default and may occur anywhere on the command line; history +expansions do not nest. The `tt(!)' can be escaped with `tt(\)' +or can be enclosed between a pair of single quotes (tt('')) to suppress +its special meaning. Double quotes will em(not) work for this. + +Input lines containing history expansions are echoed on the +terminal after being expanded, but before any other +expansions take place or the command gets executed. +startmenu() +menu(Event Designators) +menu(Word Designators) +menu(Modifiers) +endmenu() +texinode(Event Designators)(Word Designators)()(History Expansion) +subsect(Event Designators) +cindex(history event designators) +cindex(event designators, history) +An event designator is a reference to a command-line entry in +the history list. + +startitem() +item(tt(!))( +Start a history expansion, except when followed by a blank, newline, +`tt(=)' or `tt(LPAR())'. +) +item(tt(!!))( +Refer to the previous command. +By itself, this expansion +repeats the previous command. +) +item(tt(!)var(n))( +Refer to command-line var(n). +) +item(tt(!-)var(n))( +Refer to the current command-line minus var(n). +) +item(tt(!)var(str))( +Refer to the most recent command starting with var(str). +) +item(tt(!?)var(str)[tt(?)])( +Refer to the most recent command containing var(str). +) +item(tt(!#))( +Refer to the current command line typed in so far. The line is +treated as if it were complete up to and including the word before the +one with the `tt(!#)' reference. +) +item(tt(!{)...tt(}))( +Insulate a history reference from adjacent characters (if necessary). +) +enditem() +texinode(Word Designators)(Modifiers)(Event Designators)(History Expansion) +subsect(Word Designators) +cindex(history word designators) +cindex(word designators, history) +A word designator indicates which word or words of a given command line will +be included in a history reference. A `tt(:)' +separates the event specification from the word designator. +It can be omitted if the word designator begins with a +`tt(^)', `tt($)', `tt(*)', `tt(-)' or `tt(%)'. +Word designators include: + +startsitem() +sitem(tt(0))(The first input word (command).) +sitem(var(n))(The var(n)th argument.) +sitem(tt(^))(The first argument. That is, tt(1).) +sitem(tt($))(The last argument.) +sitem(tt(%))(The word matched by (the most recent) tt(?)var(str) search.) +sitem(var(x)tt(-)var(y))(A range of words; var(x) defaults to tt(0).) +sitem(tt(*))(All the arguments, or a null value if there are none.) +sitem(var(x)tt(*))(Abbreviates `var(x)tt(-$)'.) +sitem(var(x)tt(-))(Like `var(x)tt(*)' but omitting word tt($).) +endsitem() + +Note that a `tt(%)' word designator will only work when used as +`tt(!%)', `tt(!:%)' or `tt(!?)var(str)tt(?:%)', +and only when used after a tt(!?) expansion. Anything else will result +in an error, although the error may not be the most obvious one. +texinode(Modifiers)()(Word Designators)(History Expansion) +subsect(Modifiers) +cindex(modifiers, history) +cindex(history modifiers) +After the optional word designator, you can add +a sequence of one or more of the following modifiers, +each preceded by a `tt(:)'. These modifiers also work on the result +of em(filename generation) and em(parameter expansion), except where +noted. + +startitem() +item(tt(h))( +Remove a trailing pathname component, leaving the head. +) +item(tt(r))( +Remove a trailing suffix of the form `tt(.)var(xxx)', leaving the basename. +) +item(tt(e))( +Remove all but the suffix. +) +item(tt(t))( +Remove all leading pathname components, leaving the tail. +) +item(tt(p))( +Print the new command but do not execute it. Only works with history +expansion. +) +item(tt(q))( +Quote the substituted words, escaping further substitutions. Only +works with history expansion. +) +item(tt(x))( +Like tt(q), but break into words at each blank. +) +item(tt(l))( +Convert the words to all lowercase. +) +item(tt(u))( +Convert the words to all uppercase. +) +item(tt(f))( +(This and the following +tt(F), tt(w) and tt(W) modifier only work with parameter and +filename expansion.) +Repeats the immediately (without a colon) following modifier until the +resulting word doesn't change any more. +) +item(tt(F:)var(expr)tt(:))( +Like tt(f), but repeats only var(n) times if the expression +var(expr) evaluates to var(n). Any character can be used instead of +the `tt(:)', if any of `tt(LPAR())', `tt([)', or `tt({)' +is used as the opening delimiter +the second one has to be 'tt(RPAR())', `tt(])', or `tt(})' respectively. +) +item(tt(w))( +Makes the immediately following modifier work on each word in the +string. +) +item(tt(W:)var(sep)tt(:))( +Like tt(w) but words are considered to be the parts of the string +that are separated by var(sep). Any character can be used instead of +the `tt(:)'; opening parentheses are handled specially, see above. +) +item(tt(s/)var(l)tt(/)var(r)[tt(/)])( +Substitute var(r) for var(l) as described below. +Unless preceded immediately by a tt(g), with no colon between, +the substitution is done only for the +first string that matches var(l). For arrays and filename +expansion, this applies to each word of the expanded text. +) +item(tt(&))( +Repeat the previous tt(s) substitution. Like tt(s), may be preceded +immediately by a tt(g). In variable expansion the tt(&) must appear +inside braces, and in filename expansion it must be quoted with a +backslash. +) +enditem() + +The tt(s/l/r/) substitution works as follows. The left-hand side of +substitutions are not regular expressions, but character strings. Any +character can be used as the delimiter in place of `tt(/)'. A +backslash quotes the delimiter character. The character `tt(&)', in +the right-hand-side var(r), is replaced by the text from the +left-hand-side var(l). The `tt(&)' can be quoted with a backslash. A +null var(l) uses the previous string either from the previous var(l) +or from the contextual scan string var(s) from `tt(!?)var(s)'. You can +omit the rightmost delimiter if a newline immediately follows var(r); +the rightmost `tt(?)' in a context scan can similarly be omitted. +Note the same record of the last var(l) and var(r) is maintained +across all forms of expansion. + +By default, a history reference with no event specification refers to the same +line as the last history reference on that command line, unless it is the +first history reference in a command. In that case, a history reference +with no event specification always refers to the previous command. However, +if the option tt(CSH_JUNKIE_HISTORY) is set, +pindex(CSH_JUNKIE_HISTORY, use of) +then history reference with no +event specification will em(always) refer to the previous command. + +For example, `tt(!!:1)' +will always refer to the first word of the previous command, and `tt(!!$)' +will always refer to the last word of the previous command. And with +tt(CSH_JUNKIE_HISTORY) set, then `tt(!:1)' and `tt(!$)' +will function in the same manner as `tt(!!:1)' and `tt(!!$)', +respectively. However, if tt(CSH_JUNKIE_HISTORY) is unset, then +`tt(!:1)' and `tt(!$)' +will refer to the first and last words respectively, of the last command +referenced on the current command line. However, if they are the first history +reference on the command line, then they refer to the previous command. + +The character sequence `tt(^)var(foo)tt(^)var(bar)' +repeats the last command, replacing the string var(foo) with var(bar). + +If the shell encounters the character sequence `tt(!")' +in the input, the history mechanism is temporarily disabled until +the current list is fully parsed. The `tt(!")' +is removed from the input, and any subsequent `tt(!)' +characters have no special significance. + +A less convenient but more comprehensible +form of command history support +is provided by the tt(fc) builtin. +findex(fc, use of) +texinode(Process Substitution)(Parameter Expansion)(History Expansion)(Expansion) +sect(Process Substitution) +cindex(process substitution) +cindex(substitution, process) +Each command argument of the form +`tt(<LPAR())var(list)tt(RPAR())', +`tt(>LPAR())var(list)tt(RPAR())' or +`tt(=LPAR())var(list)tt(RPAR())' +is subject to process substitution. +In the case of the tt(<) or tt(>) forms, the shell will run process +var(list) asynchronously, connected to a named pipe (FIFO). +The name of this pipe will become the argument to the command. +If the form with tt(>) +is selected then writing on this file will provide input for var(list). +If tt(<) is used, then the file passed as an argument will +be a named pipe connected to the output of the var(list) process. +For example, + +nofill(tt(paste <LPAR()cut -f1) var(file1)tt(RPAR() <LPAR()cut -f3) var(file2)tt(RPAR() | tee >LPAR())var(process1)tt(RPAR() >LPAR())var(process2)tt(RPAR() >/dev/null)) + +cuts fields 1 and 3 from the files var(file1) and var(file2) respectively, +pastes the results together, and sends it to the processes +var(process1) and var(process2). +Note that the file, which is passed as an argument to the command, +is a system pipe, so programs that expect to lseek (see manref(lseek)(2)) +on the file will not work. +Also note that the previous example can be more compactly and +efficiently written as: + +nofill(tt(paste <LPAR()cut -f1) var(file1)tt(RPAR() <LPAR()cut -f3) var(file2)tt(RPAR() > >LPAR())var(process1)tt(RPAR() > >LPAR())var(process2)tt(RPAR())) + +The shell uses pipes instead of FIFOs to implement the latter +two process substitutions in the above example. + +If tt(=) is used, +then the file passed as an argument will be the name +of a temporary file containing the output of the var(list) +process. This may be used instead of the tt(<) +form for a program that expects to lseek (see manref(lseek)(2)) +on the input file. +texinode(Parameter Expansion)(Command Substitution)(Process Substitution)(Expansion) +sect(Parameter Expansion) +cindex(parameter expansion) +cindex(expansion, parameter) +The character `tt($)' is used to introduce parameter expansions. +See +ifzman(\ +zmanref(zshparam) +)\ +ifnzman(\ +noderef(Parameters) +)\ +for a description of parameters. +In the expansions discussed below that require a pattern, the form of +the pattern is the same as that used for filename generation; +see noderef(Filename Generation). In addition to the following +operations, the file modifiers described in +noderef(Modifiers) in noderef(History Expansion) can be +applied: for example, tt(${i:s/foo/bar/}) performs string +substitution on the value of parameter tt($i). + +startitem() +item(tt(${)var(name)tt(}))( +The value, if any, of the parameter var(name) is substituted. +The braces are required if var(name) is followed by +a letter, digit, or underscore that is not to be interpreted +as part of its name. + +If var(name) is an array parameter, then the values of each +element of var(name) is substituted, one element per word. +Otherwise, the expansion results in one word only; no field +splitting is done on the result unless the tt(SH_WORD_SPLIT) +option is set. +) +item(tt(${PLUS())var(name)tt(}))( +If var(name) is the name of a set parameter `tt(1)' is substituted, +otherwise `tt(0)' is substituted. +) +item(tt(${)var(name)tt(:-)var(word)tt(}))( +If var(name) is set and is non-null then substitute its +value; otherwise substitute var(word). If var(name) is +missing, substitute var(word). +) +item(tt(${)var(name)tt(:=)var(word)tt(}))( +If var(name) is unset or is null then +set it to var(word); the value of the parameter is then +substituted. +) +item(tt(${)var(name)tt(:?)var(word)tt(}))( +If var(name) is set and is non-null, then substitute +its value; otherwise, print var(word) and exit from the shell. +If var(word) is omitted, then a standard message is printed. +) +item(tt(${)var(name)tt(:PLUS())var(word)tt(}))( +If var(name) is set and is non-null then substitute +var(word); otherwise substitute nothing. +) +enditem() + +If the colon is omitted from one of the above expressions +containing a colon, then the shell only checks whether +var(name) is set or not, not whether it is null. + +startitem() +item(tt(${)var(name)tt(::=)var(word)tt(}))( +Set var(name) to var(word); the value of the parameter is then +substituted. +) +xitem(tt(${)var(name)tt(#)var(pattern)tt(})) +item(tt(${)var(name)tt(##)var(pattern)tt(}))( +If the var(pattern) matches the beginning of the value of +var(name), then substitute the value of var(name) with +the matched portion deleted; otherwise, just +substitute the value of var(name). In the first +form, the smallest matching pattern is preferred; +in the second form, the largest matching pattern is +preferred. If var(name) is an array and the substitution +is not quoted or the tt((@)) flag or the `var(name)tt([@])' syntax +is used, matching is performed on each array elements separately. +) +xitem(tt(${)var(name)tt(%)var(pattern)tt(})) +item(tt(${)var(name)tt(%%)var(pattern)tt(}))( +If the var(pattern) matches the end of the value of +var(name), then substitute the value of var(name) with +the matched portion deleted; otherwise, just +substitute the value of var(name). In the first +form, the smallest matching pattern is preferred; +in the second form, the largest matching pattern is +preferred. If var(name) is an array and the substitution +is not quoted or the tt((@)) flag or the `var(name)tt([@])' syntax +is used, matching is performed on each array elements separately. +) +item(tt(${)var(name)tt(:#)var(pattern)tt(}))( +If the var(pattern) matches the value of var(name), then substitute +the empty string; otherwise, just substitute the value of var(name). +If var(name) is an array and the substitution +is not quoted or the tt((@)) flag or the `var(name)tt([@])' syntax +is used, matching is performed on each array elements separately, and +the matched array elements are removed (use the tt((M)) flag to +remove the non-matched elements). +) +item(tt(${#)var(spec)tt(}))( +If var(spec) is one of the above substitutions, substitute +the length in characters of the result instead of +the result itself. If var(spec) is an array expression, +substitute the number of elements of the result. +) +item(tt(${^)var(spec)tt(}))( +pindex(RC_EXPAND_PARAM, use of) +cindex(array expansion style, rc) +cindex(rc, array expansion style) +Turn on the tt(RC_EXPAND_PARAM) option for the +evaluation of var(spec); if the `tt(^)' is doubled, turn it off. +When this option is set, array expansions of the form +`var(foo)tt(${)var(xx)tt(})var(bar)', +where the parameter var(xx) +is set to tt(LPAR())var(a b c)tt(RPAR()), are substituted with +`var(fooabar foobbar foocbar)' instead of the default +`var(fooa b cbar)'. + +Internally, each such expansion is converted into the +equivalent list for brace expansion. E.g., tt(${^var}) becomes +tt({$var[1],$var[2],)...tt(}), and is processed as described in +noderef(Brace Expansion) above. +If word splitting is also in effect the +tt($var[)var(N)tt(]) may themselves be split into different list +elements. +) +item(tt(${=)var(spec)tt(}))( +pindex(SH_WORD_SPLIT, use of) +cindex(field splitting, sh style) +cindex(sh, field splitting style) +Turn on the tt(SH_WORD_SPLIT) option for the +evaluation of var(spec); if the `tt(=)' is doubled, turn it off. +vindex(IFS, use of) +When this option is set, parameter values are split into +separate words using tt(IFS) as a delimiter +before substitution. +This is done by default in most other shells. +) +item(tt(${~)var(spec)tt(}))( +pindex(GLOB_SUBST) +Turn on the tt(GLOB_SUBST) option for the evaluation of +var(spec); if the `tt(~)' is doubled, turn it off. When this option is +set, any pattern characters resulting +from the substitution become eligible for file expansion and filename +generation. +) +enditem() + +If a tt(${)...tt(}) type parameter expression or a +tt($LPAR())...tt(RPAR()) type command substitution is used in place of +var(name) above, it is substituted first and the result is used as if +it were the value of var(name). Thus it is +possible to perform nested operations: tt(${${foo#head}%tail}) +substitues the value of tt($foo) with both tt(head) and tt(tail) +deleted. The form with tt($LPAR())...tt(RPAR()) is often useful in +combination with the flags described next; see the example below. +subsect(Parameter Expansion Flags) +cindex(parameter expansion flags) +cindex(flags, parameter expansion) +cindex(expansion, parameter, flags) +If the opening brace is directly followed by an opening parenthesis, +the string up to the matching closing parenthesis will be taken as a +list of flags. Where arguments are valid, any character, or the +matching pairs `tt(LPAR())...tt(RPAR())', `tt({)...tt(})', +`tt([)...tt(])', or `tt(<)...tt(>)', may be used +in place of the colon as delimiters. The following flags are supported: + +startitem() +item(tt(A))( +Create an array parameter with +tt(${)...tt(:=)...tt(}) or tt(${)...tt(::=)...tt(}). +Assignment is made before sorting or padding. +) +item(tt(@))( +In double quotes, array elements are put into separate words. +E.g., `tt("${(@)foo}")' is equivalent to `tt("${foo[@]}")' and +`tt("${(@)foo[1,2]}")' is the same as `tt("$foo[1]" "$foo[2]")'. +) +item(tt(e))( +Perform em(parameter expansion), em(command substitution) and +em(arithmetic expansion) on the result. Such expansions can be +nested but too deep recursion may have unpredictable effects. +) +item(tt(o))( +Sort the resulting words in ascending order. +) +item(tt(O))( +Sort the resulting words in descending order. +) +item(tt(i))( +With tt(o) or tt(O), sort case-independently. +) +item(tt(L))( +Convert all letters in the result to lower case. +) +item(tt(U))( +Convert all letters in the result to upper case. +) +item(tt(C))( +Capitalize the resulting words. +) +item(tt(c))( +With tt(${#)var(name)tt(}), count the total number of characters in an array, +as if the elements were concatenated with spaces between them. +) +item(tt(w))( +With tt(${#)var(name)tt(}), count words in arrays or strings; the tt(s) +flag may be used to set a word delimiter. +) +item(tt(W))( +Similar to tt(w) with the difference that empty words between +repeated delimiters are also counted. +) +item(tt(p))( +Recognize the same escape sequences as the tt(print) builtin +in string arguments to subsequent flags. +) +item(tt(l:)var(expr)tt(::)var(string1)tt(::)var(string2)tt(:))( +Pad the resulting words on the left. Each word will be truncated if +required and placed in a field var(expr) characters wide. 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, this string will be placed +exactly once directly to the left of the resulting word. +) +item(tt(r:)var(expr)tt(::)var(string1)tt(::)var(string2)tt(:))( +As tt(l), but pad the words on the right. +) +item(tt(j:)var(string)tt(:))( +Join the words of arrays together using var(string) as a separator. +pindex(SH_WORD_SPLIT, use of) +Note that this occurs before field splitting by the tt(SH_WORD_SPLIT) +option. +) +item(tt(F))( +Join the words of arrays together using newline as a separator. +This is a shorthand for `tt(pj:\n:)'. +) +item(tt(s:)var(string)tt(:))( +Force field splitting (see the option tt(SH_WORD_SPLIT)) at the +separator var(string). Splitting only occurs in places where an +array value is valid. +) +item(tt(f))( +Split the result of the expansion to lines. This is a shorthand +for `tt(ps:\n:)'. +) +item(tt(S))( +(This and all remaining flags are used with the tt(${)...tt(#)...tt(}) or +tt(${)...tt(%)...tt(}) forms.) +Search substrings as well as beginnings or ends. +) +item(tt(I:)var(expr)tt(:))( +Search the var(expr)th match (where var(expr) evaluates to a number). +) +item(tt(M))( +Include the matched portion in the result. +) +item(tt(R))( +Include the unmatched portion in the result (the em(R)est). +) +item(tt(B))( +Include the index of the beginning of the match in the result. +) +item(tt(E))( +Include the index of the end of the match in the result. +) +item(tt(N))( +Include the length of the match in the result. +) +enditem() +subsect(Example) +The flag tt(f) is useful to split a double-quoted substitution line by +line. For example, `tt("${(f)$LPAR()<)var(file)tt(RPAR()}")' +will substitue the contents of var(file) divided so that one line is +supplied per argument to var(cmd). Compare this with the effect of +`tt($)tt(LPAR()<)var(file)tt(RPAR())' alone, which divides the file +up by words, or the same inside double quotes, where the entire +contents of the file are passed as a single argument. +texinode(Command Substitution)(Arithmetic Expansion)(Parameter Expansion)(Expansion) +sect(Command Substitution) +cindex(command substitution) +cindex(substitution, command) +A command enclosed in parentheses +preceded by a dollar sign, like `tt($LPAR())...tt(RPAR())', or quoted with grave +accents, like `tt(`)...tt(`)', is replaced with its standard output, with any +trailing newlines deleted. +If the substitution is not enclosed in double quotes, the +output is broken into words using the tt(IFS) parameter. +vindex(IFS, use of) +The substitution `tt($LPAR()cat) var(foo)tt(RPAR())' may be replaced +by the equivalent but faster `tt($LPAR()<)var(foo)tt(RPAR())'. +In either case, if the option tt(GLOB_SUBST) is set, +the output is eligible for filename generation. +texinode(Arithmetic Expansion)(Brace Expansion)(Command Substitution)(Expansion) +sect(Arithmetic Expansion) +cindex(arithmetic expansion) +cindex(expansion, arithmetic) +A string of the form `tt($[)var(exp)tt(])' or +`tt($LPAR()LPAR())var(exp)tt(RPAR()RPAR())' is substituted +with the value of the arithmetic expression var(exp). var(exp) is +subjected to em(parameter expansion), em(command substitution) +and em(arithmetic expansion) before it is evaluated. +See noderef(Arithmetic Evaluation). +texinode(Brace Expansion)(Filename Expansion)(Arithmetic Expansion)(Expansion) +sect(Brace Expansion) +cindex(brace expansion) +cindex(expansion, brace) +A string of the form +`var(foo)tt({)var(xx)tt(,)var(yy)tt(,)var(zz)tt(})var(bar)' +is expanded to the individual words +`var(fooxxbar)', `var(fooyybar)' and `var(foozzbar)'. +Left-to-right order is preserved. This construct +may be nested. Commas may be quoted in order to +include them literally in a word. + +An expression of the form `tt({)var(n1)tt(..)var(n2)tt(})', +where var(n1) and var(n2) are integers, +is expanded to every number between +var(n1) and var(n2) inclusive. If either number begins with a +zero, all the resulting numbers will be padded with leading zeroes to +that minimum width. If the numbers are in decreasing order the +resulting sequence will also be in decreasing order. + +If a brace expression matches none of the above forms, it is left +unchanged, unless the tt(BRACE_CCL) option is set. +pindex(BRACE_CCL, use of) +In that case, it is expanded to a sorted list of the individual +characters between the braces, in the manner of a search set. +`tt(-)' is treated specially as in a search set, but `tt(^)' or `tt(!)' as +the first character is treated normally. +texinode(Filename Expansion)(Filename Generation)(Brace Expansion)(Expansion) +sect(Filename Expansion) +cindex(filename expansion) +cindex(expansion, filename) +Each word is checked to see if it begins with an unquoted `tt(~)'. +If it does, then the word up to a `tt(/)', +or the end of the word if there is no `tt(/)', +is checked to see if it can be substituted in one of the ways +described here. If so, then the `tt(~)' and the checked portion are +replaced with the appropriate substitute value. + +A `tt(~)' by itself is replaced by the value of tt($HOME). +A `tt(~)' followed by a `tt(PLUS())' or a `tt(-)' is replaced by the value of +tt($PWD) or tt($OLDPWD), respectively. + +A `tt(~)' followed by a number is replaced by the directory at that +position in the directory stack. +`tt(~0)' is equivalent to `tt(~PLUS())', +and `tt(~1)' is the top of the stack. +`tt(~PLUS())' followed by a number is replaced by the directory at that +position in the directory stack. +`tt(~PLUS()0)' is equivalent to `tt(~PLUS())', +and `tt(~PLUS()1)' is the top of the stack. +`tt(~-)' followed by a number is replaced by the directory that +many positions from the bottom of the stack. +`tt(~-0)' is the bottom of the stack. +pindex(PUSHD_MINUS, use of) +The tt(PUSHD_MINUS) +option exchanges the effects of `tt(~PLUS())' and `tt(~-)' where they are +followed by a number. + +cindex(directories, named) +cindex(named directories) +A `tt(~)' followed by anything not already covered is looked up as a +named directory, and replaced by the value of that named directory if found. +Named directories are typically home directories for users on the system. +They may also be defined if the text after the `tt(~)' is the name +of a string shell parameter whose value begins with a `tt(/)'. +It is also possible to define directory names using the tt(-d) option to the +tt(hash) builtin. + +In certain circumstances (in prompts, for instance), when the shell +prints a path, the path is checked to see if it has a named +directory as its prefix. If so, then the prefix portion +is replaced with a `tt(~)' followed by the name of the directory. +The shortest way of referring to the directory is used, +with ties broken in favour of using a named directory, +except when the directory is tt(/) itself. + +If a word begins with an unquoted `tt(=)' +and the tt(EQUALS) option is set, +the remainder of the word is taken as the +name of a command or alias. If a command +exists by that name, the word is replaced +by the full pathname of the command. +If an alias exists by that name, the word +is replaced with the text of the alias. + +Filename expansion is performed on the right hand side of a parameter +assignment, including those appearing after commands of the +tt(typeset) family. In this case, the right hand side will be treated +as a colon-separated list in the manner of the tt(PATH) parameter, +so that a `tt(~)' or an `tt(=)' following a `tt(:)' is eligible for expansion. +All such behaviour can be +disabled by quoting the `tt(~)', the `tt(=)', or the whole expression (but not +simply the colon); the tt(EQUALS) option is also respected. + +If the option tt(MAGIC_EQUAL_SUBST) is set, any unquoted shell +argument in the form `var(identifier)tt(=)var(expression)' becomes eligible +for file expansion as described in the previous paragraph. Quoting the +first `tt(=)' also inhibits this. +texinode(Filename Generation)()(Filename Expansion)(Expansion) +sect(Filename Generation) +cindex(filename generation) +cindex(globbing) +If a word contains an unquoted instance of one of the characters +`tt(*)', `tt(LPAR())', `tt(|)', `tt(<)', `tt([)', or `tt(?)', it is regarded +as a pattern for filename generation, unless the tt(GLOB) option is unset. +pindex(GLOB, use of) +If the tt(EXTENDED_GLOB) option is set, +pindex(EXTENDED_GLOB, use of) +the `tt(^)' and `tt(#)' characters also denote a pattern; otherwise +they are not treated specially by the shell. + +The word is replaced with a list of sorted filenames that match +the pattern. If no matching pattern is found, the shell gives +an error message, unless the tt(NULL_GLOB) option is set, +pindex(NULL_GLOB, use of) +in which case the word is deleted; or unless the tt(NOMATCH) +option is unset, in which case the word is left unchanged. +pindex(NOMATCH, use of) + +In filename generation, +the character `tt(/)' must be matched explicitly; +also, a `tt(.)' must be matched +explicitly at the beginning of a pattern or after a `tt(/)', unless the +tt(GLOB_DOTS) option is set. +pindex(GLOB_DOTS, use of) +No filename generation pattern +matches the files `tt(.)' or `tt(..)'. In other instances of pattern +matching, the `tt(/)' and `tt(.)' are not treated specially. +subsect(Glob Operators) +startitem() +item(tt(*))( +Matches any string, including the null string. +) +item(tt(?))( +Matches any character. +) +item(tt([)...tt(]))( +Matches any of the enclosed characters. Ranges of characters +can be specified by separating two characters by a `tt(-)'. +A `tt(-)' or `tt(])' may be matched by including it as the +first character in the list. +There are also several named classes of characters, in the form +`tt([:)var(name)(tt:])' with the following meanings: `tt([:alnum:])' +alphanumeric, `tt([:alpha:])' alphabetic, +`tt([:blank:])' space or tab, +`tt([:cntrl:])' control character, `tt([:digit:])' decimal +digit, `tt([:graph:])' printable character except whitespace, +`tt([:lower:])' lowercase letter, `tt([:print:])' printable character, +`tt([:punct:])' printable character neither alphanumeric nor whitespace, +`tt([:space:])' whitespace character, `tt([:upper:])' uppercase letter, +`tt([:xdigit:])' hexadecimal digit. These use the macros provided by +the operating system to test for the given character combinations, +including any modifications due to local language settings: see +manref(ctype)(3). Note that the square brackets are additional +to those enclosing the whole set of characters, so to test for a +single alphanumeric character you need `tt([[:alnum:]])'. Named +character sets can be used alongside other types, +e.g. `tt([[:alpha:]0-9])'. +) +xitem(tt([^)...tt(])) +item(tt([!)...tt(]))( +Like tt([)...tt(]), except that it matches any character which is +not in the given set. +) +item(tt(<)[var(x)]tt(-)[var(y)]tt(>))( +Matches any number in the range var(x) to var(y), inclusive. +Either of the numbers may be omitted to make the range open-ended; +hence `tt(<->)' matches any number. +) +item(tt(LPAR())...tt(RPAR()))( +Matches the enclosed pattern. This is used for grouping. +If the tt(KSH_GLOB) option is set, then a +`tt(@)', `tt(*)', `tt(+)', `tt(?)' or `tt(!)' immediately preceding +the `tt(LPAR())' is treated specially, as detailed below. +) +item(var(x)tt(|)var(y))( +Matches either var(x) or var(y). +This operator has lower precedence than any other. +The `tt(|)' character +must be within parentheses, to avoid interpretation as a pipeline. +) +item(tt(^)var(x))( +(Requires tt(EXTENDED_GLOB) to be set.) +Matches anything except the pattern var(x). +This has a higher precedence than `tt(/)', so `tt(^foo/bar)' +will search directories in `tt(.)' except `tt(./foo)' +for a file named `tt(bar)'. +) +item(var(x)tt(~)var(y))( +(Requires tt(EXTENDED_GLOB) to be set.) +Match anything that matches the pattern var(x) but does not match var(y). +This has lower precedence than any operator except `tt(|)', so +`tt(*/*~foo/bar)' will search for all files in all directories in `tt(.)' +and then exclude `tt(foo/bar)' if there was such a match. +It groups left-to-right, so multiple patterns can be excluded by +`var(foo)tt(~)var(bar)tt(~)var(baz)'. +In the exclusion pattern (var(y)), `tt(/)' and `tt(.)' are not treated +specially the way they usually are in globbing. +) +item(var(x)tt(#))( +(Requires tt(EXTENDED_GLOB) to be set.) +Matches zero or more occurrences of the pattern var(x). +This operator has high precedence; `tt(12#)' is equivalent to `tt(1(2#))', +rather than `tt((12)#)'. +) +item(var(x)tt(##))( +(Requires tt(EXTENDED_GLOB) to be set.) +Matches one or more occurrences of the pattern var(x). +This operator has high precedence; `tt(12##)' is equivalent to `tt(1(2##))', +rather than `tt((12)##)'. +) +enditem() +subsect(ksh-like Glob Operators) +pindex(KSH_GLOB, use of) +If the tt(KSH_GLOB) option is set, the effects of parentheses can be +modified by a preceding `tt(@)', `tt(*)', `tt(+)', `tt(?)' or `tt(!)'. +This character need not be unquoted to have special effects, +but the `tt(LPAR())' must be. + +startitem() +item(tt(@LPAR())...tt(RPAR()))( +Match the pattern in the parentheses. (Like `tt(LPAR())...tt(RPAR())'.) +) +item(tt(*LPAR())...tt(RPAR()))( +Match any number of occurrences. (Like `tt(LPAR())...tt(RPAR()#)'.) +) +item(tt(PLUS()LPAR())...tt(RPAR()))( +Match at least one occurrence. (Like `tt(LPAR())...tt(RPAR()##)'.) +) +item(tt(?LPAR())...tt(RPAR()))( +Match zero or one occurrence. (Like `tt(LPAR()|)...tt(RPAR())'.) +) +item(tt(!LPAR())...tt(RPAR()))( +Match anything but the expression in parentheses. +(Like `tt(LPAR()^LPAR())...tt(RPAR()RPAR())'.) +) +enditem() +subsect(Recursive Globbing) +A pathname component of the form `tt(LPAR())var(foo)tt(/RPAR()#)' +matches a path consisting of zero or more directories +matching the pattern var(foo). +As a shorthand, `tt(**/)' is equivalent to `tt((*/)#)'. +Thus: + +nofill(tt(ls (*/)#bar)) + +or + +nofill(tt(ls **/bar)) + +does a recursive directory search for files named `tt(bar)', not following +symbolic links. To follow links, use `tt(***/)'. +subsect(Glob Qualifiers) +cindex(globbing, qualifiers) +cindex(qualifiers, globbing) +Patterns used for filename generation may end in a +list of qualifiers enclosed in parentheses. +The qualifiers specify which filenames that otherwise match the given pattern +will be inserted in the argument list. + +pindex(BARE_GLOB_QUAL, use of) +If the option tt(BARE_GLOB_QUAL) is set, then a trailing set of parentheses +containing no `tt(|)' or `tt(LPAR())' characters (or `tt(~)' if it is special) +is taken as a set of +glob qualifiers. A glob subexpression that would normally be taken as glob +qualifiers, for example `tt((^x))', can be forced to be treated as part of +the glob pattern by doubling the parentheses, for example `tt(((^x)))'. + +A qualifier may be any one of the following: + +startitem() +item(tt(/))( +directories +) +item(tt(.))( +plain files +) +item(tt(@))( +symbolic links +) +item(tt(=))( +sockets +) +item(tt(p))( +named pipes (FIFOs) +) +item(tt(*))( +executable plain files (0100) +) +item(tt(%))( +device files (character or block special) +) +item(tt(%b))( +block special files +) +item(tt(%c))( +character special files +) +item(tt(r))( +owner-readable files (0400) +) +item(tt(w))( +owner-writable files (0200) +) +item(tt(x))( +owner-executable files (0100) +) +item(tt(A))( +group-readable files (0040) +) +item(tt(I))( +group-writable files (0020) +) +item(tt(E))( +group-executable files (0010) +) +item(tt(R))( +world-readable files (0004) +) +item(tt(W))( +world-writable files (0002) +) +item(tt(X))( +world-executable files (0001) +) +item(tt(s))( +setuid files (04000) +) +item(tt(S))( +setgid files (02000) +) +item(tt(t))( +files with the sticky bit (01000) +) +item(tt(d)var(dev))( +files on the device var(dev) +) +item(tt(l)[tt(-)|tt(PLUS())]var(ct))( +files having a link count less than var(ct) (tt(-)), greater than +var(ct) (tt(PLUS())), or is equal to var(ct) +) +item(tt(U))( +files owned by the effective user ID +) +item(tt(G))( +files owned by the effective group ID +) +item(tt(u)var(id))( +files owned by user ID var(id) if it is a number, if not, than the +character after the `tt(u)' will be used as a separator and the string +between it and the next matching separator +(`tt(LPAR())', `tt([)', `tt({)', and `tt(<)' +match `tt(RPAR())', `tt(])', `tt(})', and `tt(>)' respectively, +any other character matches +itself) will be taken as a user name, and the user ID of this user will +be taken (e.g. `tt(u:foo:)' or `tt(u[foo])' for user `tt(foo)') +) +item(tt(g)var(id))( +like tt(u)var(id) but with group IDs or names +) +item(tt(a)[tt(Mwhm)][tt(-)|tt(PLUS())]var(n))( +files accessed exactly var(n) days ago. Files accessed within the +last var(n) days are selected using a negative value for var(n) +(tt(-)var(n)). Files accessed more than var(n) days ago are selected by a +positive var(n) value (tt(PLUS())var(n)). Optional unit specifiers `tt(M)', +`tt(w)', `tt(h)' or `tt(m)' (e.g. `tt(ah5)') cause the check to be +performed with months (of 30 days), weeks, hours, or minutes instead of +days, respectively. For instance, `tt(echo *(ah-5))' would echo files +accessed within the last five hours. +) +item(tt(m)[tt(Mwhm)][tt(-)|tt(PLUS())]var(n))( +like the file access qualifier, except that it uses the file modification +time. +) +item(tt(c)[tt(Mwhm)][tt(-)|tt(PLUS())]var(n))( +like the file access qualifier, except that it uses the file inode change +time. +) +item(tt(L)[tt(PLUS())|tt(-)]var(n))( +files less than var(n) bytes (tt(-)), more than var(n) bytes (tt(PLUS())), or +exactly var(n) bytes in length. If this flag is directly followed by a `tt(k)' +(`tt(K)'), `tt(m)' (`tt(M)'), or `tt(p)' (`tt(P)') (e.g. `tt(Lk-50)') +the check is performed with kilobytes, megabytes, or blocks (of 512 bytes) +instead. +) +item(tt(^))( +negates all qualifiers following it +) +item(tt(-))( +toggles between making the qualifiers work on symbolic links (the +default) and the files they point to +) +item(tt(M))( +sets the tt(MARK_DIRS) option for the current pattern +pindex(MARK_DIRS, setting in pattern) +) +item(tt(T))( +appends a trailing qualifier mark to the file names, analogous to the +tt(LIST_TYPES) option, for the current pattern (overrides tt(M)) +) +item(tt(N))( +sets the tt(NULL_GLOB) option for the current pattern +pindex(NULL_GLOB, setting in pattern) +) +item(tt(D))( +sets the tt(GLOB_DOTS) option for the current pattern +pindex(GLOB_DOTS, setting in pattern) +) +enditem() + +More than one of these lists can be combined, separated by commas. The +whole list matches if at least one of the sublists matches (they are +`or'ed, the qualifiers in the sublists are `and'ed). + +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)). Note that +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 is performed. +Thus: + +nofill(tt(ls *(-/))) + +lists all directories and symbolic links that point to directories, +and + +nofill(tt(ls *(%W))) + +lists all world-writable device files in the current directory, and + +nofill(tt(ls *(W,X))) + +lists all files in the current directory that are +world-writable or world-executable, and + +nofill(tt(echo /tmp/foo*(u0^@:t))) + +outputs the basename of all root-owned files beginning with the string +`tt(foo)' in tt(/tmp), ignoring symlinks, and + +nofill(tt(ls *.*~(lex|parse).[ch](^D^l1))) + +lists all files having a link count of one whose names contain a dot +(but not those starting with a dot, since tt(GLOB_DOTS) is explicitly +switched off) except for tt(lex.c), tt(lex.h), tt(parse.c) and tt(parse.h). diff --git a/Doc/Zsh/filelist.yo b/Doc/Zsh/filelist.yo new file mode 100644 index 000000000..298eff074 --- /dev/null +++ b/Doc/Zsh/filelist.yo @@ -0,0 +1,15 @@ +sect(Files) +cindex(files used) +startlist() +list(tt($ZDOTDIR/.zshenv)) +list(tt($ZDOTDIR/.zprofile)) +list(tt($ZDOTDIR/.zshrc)) +list(tt($ZDOTDIR/.zlogin)) +list(tt($ZDOTDIR/.zlogout)) +list(tt(${TMPPREFIX}*) (default is /tmp/zsh*)) +list(tt(/etc/zshenv)) +list(tt(/etc/zprofile)) +list(tt(/etc/zshrc)) +list(tt(/etc/zlogin)) +list(tt(/etc/zlogout) (installation-specific - tt(/etc) is the default)) +endlist() diff --git a/Doc/Zsh/files.yo b/Doc/Zsh/files.yo new file mode 100644 index 000000000..0d775a14f --- /dev/null +++ b/Doc/Zsh/files.yo @@ -0,0 +1,26 @@ +texinode(Files)(Shell Grammar)(Invocation)(Top) +chapter(Files) +sect(Startup/Shutdown Files) +cindex(files, startup) +cindex(startup files) +cindex(files, shutdown) +cindex(shutdown files) +pindex(NO_RCS, use of) +Commands are first read from tt(/etc/zshenv). +If the tt(RCS) option is unset +within tt(/etc/zshenv), all other +initialization files are skipped. +Otherwise, commands are read +from tt($ZDOTDIR/.zshenv). +pindex(LOGIN, use of) +If the shell is a login shell, commands +are read from tt(/etc/zprofile) and then tt($ZDOTDIR/.zprofile). +Then, if the shell is interactive, +commands are read from tt(/etc/zshrc) and then tt($ZDOTDIR/.zshrc). +Finally, if the shell is a login shell, tt(/etc/zlogin) and +tt($ZDOTDIR/.zlogin) are read. + +If tt(ZDOTDIR) is unset, tt(HOME) is used instead. +Those files listed above as being in tt(/etc) may be in another +directory, depending on the installation. +ifnzman(includefile(Zsh/filelist.yo)) diff --git a/Doc/Zsh/func.yo b/Doc/Zsh/func.yo new file mode 100644 index 000000000..c2fc71d55 --- /dev/null +++ b/Doc/Zsh/func.yo @@ -0,0 +1,107 @@ +texinode(Functions)(Jobs & Signals)(Command Execution)(Top) +chapter(Functions) +ifzman(\ +sect(Functions) +)\ +cindex(functions) +findex(function) +The tt(function) reserved word is used to define shell functions. +Shell functions are read in and stored internally. +Alias names are resolved when the function is read. +Functions are executed like commands with the arguments +passed as positional parameters. +(See noderef(Command Execution).) + +Functions execute in the same process as the caller and +share all files +and present working directory with the +caller. A trap on tt(EXIT) set inside a function +is executed after the function completes in the environment +of the caller. + +findex(return, use of) +The tt(return) builtin is used to return from function calls. + +findex(functions, use of) +Function identifiers can be listed with the tt(functions) builtin. +findex(unfunction, use of) +Functions can be undefined with the tt(unfunction) builtin. +sect(Autoloading Functions) +findex(autoload, use of) +cindex(autoloading functions) +cindex(functions, autoloading) +A function can be marked as em(undefined) using the tt(autoload) builtin +(or `tt(functions -u)' or `tt(typeset -fu)'). Such a function has no +body. When the function is first executed, the tt(fpath) +variable will be searched for a file with the same name as the +function. + +pindex(KSH_AUTOLOAD, use of) +If the tt(KSH_AUTOLOAD) option is set, or the file contains only a simple +definition of the function, the file's contents will be +executed. It would normally define the function in question, but may +also perform initialisation. +It is executed in the context of the function +execution, and may therefore define local parameters. + +Otherwise, the function is defined such that its body is the +complete contents of the file. This form allows the file to be +used directly as an executable shell script. +Initialisation code can be executed, but only as part of the first +function execution, so the function would have to redefine itself to +avoid reinitialising on the next execution. + +If this processing of the file results in the function being +fully defined, the function itself is then executed. +sect(Special Functions) +The following functions, if defined, have special meaning to +the shell: + +startitem() +findex(chpwd) +item(tt(chpwd))( +Executed whenever the current working directory is changed. +) +findex(periodic) +item(tt(periodic))( +vindex(PERIOD) +If the parameter tt(PERIOD) +is set, this function is executed every tt($PERIOD) +seconds, just before a prompt. +) +findex(precmd) +item(tt(precmd))( +Executed before each prompt. +) +findex(preexec) +item(tt(preexec))( +Executed just after a command has been read and is about to be +executed. If the history mechanism is active, the string to be +executed is passed as an argument. +) +item(tt(TRAP)var(NAL))( +cindex(signals, trapping) +cindex(trapping signals) +If defined and non-null, +this function will be executed whenever the shell +catches a signal tt(SIG)var(NAL), where var(NAL) is a signal +name as specified for the tt(kill) builtin. +The signal number will be passed as the first parameter to the function. + +If a function of this form is defined and null, +the shell and processes spawned by it will ignore tt(SIG)var(NAL). +) +findex(TRAPDEBUG) +item(tt(TRAPDEBUG))( +Executed after each command. +) +findex(TRAPEXIT) +item(tt(TRAPEXIT))( +Executed when the shell exits, +or when the current function exits if defined inside a function. +) +findex(TRAPZERR) +item(tt(TRAPZERR))( +Executed whenever a command has a non-zero exit status. +) +enditem() diff --git a/Doc/Zsh/grammar.yo b/Doc/Zsh/grammar.yo new file mode 100644 index 000000000..c78aed4b4 --- /dev/null +++ b/Doc/Zsh/grammar.yo @@ -0,0 +1,335 @@ +texinode(Shell Grammar)(Redirection)(Files)(Top) +chapter(Shell Grammar) +cindex(shell grammar) +cindex(grammar, shell) +startmenu() +menu(Simple Commands & Pipelines) +menu(Precommand Modifiers) +menu(Complex Commands) +menu(Alternate Forms For Complex Commands) +menu(Reserved Words) +menu(Comments) +menu(Aliasing) +menu(Quoting) +endmenu() +texinode(Simple Commands & Pipelines)(Precommand Modifiers)()(Shell Grammar) +sect(Simple Commands & Pipelines) +cindex(simple commands) +cindex(commands, simple) +A em(simple command) is a sequence of optional parameter +assignments followed by blank-separated words, +with optional redirections interspersed. +The first word is the command to be executed, and the remaining +words, if any, are arguments to the command. +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. + +cindex(pipeline) +A em(pipeline) is either a simple command, or a sequence of two or more +simple commands where each command is separated from the next by `tt(|)' +or `tt(|&)'. Where commands are separated by `tt(|)', the standard +output of the first command is connected to the +standard input of the next. `tt(|&)' is shorthand for `tt(2>&1 |)', which +connects both the standard output and the standard error of the +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. + +findex(coproc) +cindex(coprocess) +If a pipeline is preceded by `tt(coproc)', it is executed as a coprocess; +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(!)'. + +cindex(sublist) +A em(sublist) is either a single pipeline, or a sequence of two or more +pipelines separated by `tt(&&)' or `tt(||)'. If two pipelines are separated +by `tt(&&)', the second pipeline is executed only if the first succeeds +(returns a zero value). If two pipelines are separated by `tt(||)', the +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. + +cindex(list) +A em(list) is a sequence of zero or more sublists, in which each sublist +is terminated by `tt(;)', `tt(&)', `tt(&|)', `tt(&!)', or a newline. +This terminator +may optionally be omitted from the last sublist in the list when the +list appears as a complex command inside `tt(LPAR())...tt(RPAR())' +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. +texinode(Precommand Modifiers)(Complex Commands)(Simple Commands & Pipelines)(Shell Grammar) +sect(Precommand Modifiers) +cindex(precommand modifiers) +cindex(modifiers, precommand) +A simple command may be preceded by a em(precommand modifier), +which will alter how the command is interpreted. These modifiers are +shell builtin commands with the exception of tt(nocorrect) which is +a reserved word. + +startitem() +item(tt(-))( +The command is executed with a `tt(-)' prepended to its +tt(argv[0]) string. +) +item(tt(noglob))( +Filename generation (globbing) is not performed on any of +the words. +) +item(tt(nocorrect))( +Spelling correction is not done on any of the words. +) +item(tt(exec))( +The command is executed in the parent shell without forking. +) +item(tt(command))( +The command word is taken to be the name of an external command, +rather than a shell function or builtin. +) +item(tt(builtin))( +The command word is taken to be the name of a builtin command, +rather than a shell function or external command. +) +enditem() +texinode(Complex Commands)(Alternate Forms For Complex Commands)(Precommand Modifiers)(Shell Grammar) +sect(Complex Commands) +cindex(complex commands) +cindex(commands, complex) +A em(complex command) in zsh is one of the following: + +startitem() +findex(if) +cindex(if construct) +item(tt(if) var(list) tt(then) var(list) [ tt(elif) var(list) tt(then) var(list) ] ... [ tt(else) var(list) ] tt(fi))( +The tt(if) var(list) is executed, and if it returns a zero exit status, +the tt(then) var(list) is executed. +Otherwise, the tt(elif) var(list) is executed and if its value is zero, +the tt(then) var(list) is executed. +If each tt(elif) var(list) returns nonzero, the tt(else) var(list) is executed. +) +findex(for) +cindex(for loops) +cindex(loops, for) +item(tt(for) var(name) [ tt(in) var(word) ... var(term) ] tt(do) var(list) tt(done))( +where var(term) is at least one newline or tt(;). +Expand the list of var(word)s, and set the parameter +var(name) to each of them in turn, executing +var(list) each time. If the tt(in) var(word) is omitted, +use the positional parameters instead of the var(word)s. +) +item(tt(for LPAR()LPAR()) [var(expr1)] tt(;) [var(expr2)] tt(;) [var(expr3)] tt(RPAR()RPAR() do) var(list) tt(done))( +The arithmetic expression var(expr1) is evaluated first (see +noderef(Arithmetic Evaluation)). The arithmetic expression +var(expr2) is repeatedly evaluated until it evaluates to zero and +when non-zero, var(list) is executed and the arithmetic expression +var(expr3) evaluated. If any expression is omitted, then it behaves +as if it evaluated to 1. +) +findex(while) +cindex(while loops) +cindex(loops, while) +item(tt(while) var(list) tt(do) var(list) tt(done))( +Execute the tt(do) var(list) as long as the tt(while) var(list) +returns a zero exit status. +) +findex(until) +cindex(until loops) +cindex(loops, until) +item(tt(until) var(list) tt(do) var(list) tt(done))( +Execute the tt(do) var(list) as long as tt(until) var(list) +returns a nonzero exit status. +) +findex(repeat) +cindex(repeat loops) +cindex(loops, repeat) +item(tt(repeat) var(word) tt(do) var(list) tt(done))( +var(word) is expanded and treated as an arithmetic expression, +which must evaluate to a number var(n). +var(list) is then executed var(n) times. +) +findex(case) +cindex(case selection) +cindex(selection, case) +item(tt(case) var(word) tt(in) [ [tt(LPAR())] var(pattern) [ tt(|) var(pattern) ] ... tt(RPAR()) var(list) (tt(;;)|tt(;&)) ] ... tt(esac))( +Execute the var(list) associated with the first var(pattern) +that matches var(word), if any. The form of the patterns +is the same as that used for filename generation. See +noderef(Filename Generation). +If the var(list) that is executed is terminated with tt(;&) rather than +tt(;;), the following list is also executed. This continues until either +a list is terminated with tt(;;) or the tt(esac) is reached. +) +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(;). +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) +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. +The contents of the line read from standard input is saved +in the parameter tt(REPLY). var(list) is executed +for each selection until a break or end-of-file is encountered. +) +cindex(subshells) +item(tt(LPAR()) var(list) tt(RPAR()))( +Execute var(list) in a subshell. Traps set by the tt(trap) builtin +are reset to their default values while executing var(list). +) +item(tt({) var(list) tt(}))( +Execute var(list). +) +xitem(tt(function) var(word) ... [ tt(()) ] [ var(term) ] tt({) var(list) tt(})) +xitem(var(word) ... tt(()) [ var(term) ] tt({) var(list) tt(})) +item(var(word) ... tt(()) [ var(term) ] var(command))( +where var(term) is one or more newline or tt(;). +Define a function which is referenced by any one of var(word). +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). +) +cindex(timing) +item(tt(time) [ var(pipeline) ])( +The var(pipeline) is executed, and timing statistics are +reported on the standard error in the form specified +by the tt(TIMEFMT) parameter. +If var(pipeline) is omitted, print statistics about the +shell process and its children. +) +cindex(testing conditional expression) +item(tt([[) var(exp) tt(]]))( +Evaluates the conditional expression var(exp) +and return a zero exit status if it is true. +See noderef(Conditional Expressions) +for a description of var(exp). +) +enditem() +texinode(Alternate Forms For Complex Commands)(Reserved Words)(Complex Commands)(Shell Grammar) +sect(Alternate Forms For Complex Commands) +cindex(alternate forms for complex commands) +cindex(commands, alternate forms for complex) +Many of zsh's complex commands have alternate forms. These particular +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. + +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). +) +item(tt(if) var(list) var(sublist))( +A short form of the alternate `if'. +) +item(tt(for) var(name) tt(LPAR()) var(word) ... tt(RPAR()) var(sublist))( +A short form of tt(for). +) +item(tt(for) var(name) [ tt(in) var(word) ... var(term) ] var(sublist))( +where var(term) is at least one newline or tt(;). +Another short form of tt(for). +) +item(tt(for LPAR()LPAR()) [var(expr1)] tt(;) [var(expr2)] tt(;) [var(expr3)] tt(RPAR()RPAR()) var(sublist))( +A short form of the arithmetic tt(for) command. +) +item(tt(foreach) var(name) tt(LPAR()) var(word) ... tt(RPAR()) var(list) tt(end))( +Another form of tt(for). +) +item(tt(while) var(list) tt({) var(list) tt(}))( +An alternative form of tt(while). +) +item(tt(until) var(list) tt({) var(list) tt(}))( +An alternative form of tt(until). +) +item(tt(repeat) var(word) var(sublist))( +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(}))( +An alternative form of tt(case). +) +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). +) +enditem() +texinode(Reserved Words)(Comments)(Alternate Forms For Complex Commands)(Shell Grammar) +sect(Reserved Words) +cindex(reserved words) +findex(disable, use of) +The following words are recognized as reserved words when used as the first +word of a command unless quoted or disabled using tt(disable -r): + +tt(do done esac then elif else fi for case +if while function repeat time until +select coproc nocorrect foreach end ! [[ { }) + +Additionally, `tt(})' is recognized in any position if the tt(IGNORE_BRACES) option +is not set. +texinode(Comments)(Aliasing)(Reserved Words)(Shell Grammar) +sect(Comments) +cindex(comments) +pindex(INTERACTIVE_COMMENTS, use of) +vindex(histchars, use of) +In noninteractive shells, or in interactive shells with the +tt(INTERACTIVE_COMMENTS) option set, a word beginning +with the third character of the tt(histchars) parameter +(`tt(#)' by default) causes that word and all the following +characters up to a newline to be ignored. +texinode(Aliasing)(Quoting)(Comments)(Shell Grammar) +sect(Aliasing) +cindex(aliasing) +Every token in the shell input is checked to see if there +is an alias defined for it. +If so, it is replaced by the text of the alias if it is in command +position (if it could be the first word of a simple command), +or if the alias is global. +If the text ends with a space, the next word in the shell input +is treated as though it were in command position for purposes of alias +expansion. +findex(alias, use of) +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 +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. +texinode(Quoting)()(Aliasing)(Shell Grammar) +sect(Quoting) +cindex(quoting) +A character may be var(quoted) (that is, made +to stand for itself) by preceding it with a `tt(\)'. +`tt(\)' followed by a newline is ignored. + +A string enclosed between `tt($')' and `tt(')' is +processed the same way as the string arguments of the +tt(print) builtin, and the resulting string is considered to be +entirely quoted. A literal `tt(')' character can be included in the +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. + +Inside double quotes (tt("")), parameter and +command substitution occurs, and `tt(\)' quotes the characters +`tt(\)', `tt(`)', `tt(")', and `tt($)'. diff --git a/Doc/Zsh/guide.yo b/Doc/Zsh/guide.yo new file mode 100644 index 000000000..d38a0d308 --- /dev/null +++ b/Doc/Zsh/guide.yo @@ -0,0 +1,149 @@ +texiifinfo(\ +texinode(Top)(The Z Shell Guide)((dir))((dir)) +texitop(The Z Shell Guide) +This Info file documents Zsh, a freely available UNIX command interpreter +(shell), which of the standard shells most closely resembles the Korn shell +(ksh), although it is not completely compatible. + +Version version(), last updated date(). +)\ + +startmenu() +menu(The Z Shell Guide) +menu(Introduction) +menu(Invocation) +menu(Files) +menu(Shell Grammar) +menu(Redirection) +menu(Command Execution) +menu(Functions) +menu(Jobs & Signals) +menu(Arithmetic Evaluation) +menu(Conditional Expressions) +menu(Compatibility) +menu(Prompt Expansion) +menu(Restricted Shell) +menu(Expansion) +menu(Parameters) +menu(Options) +menu(Shell Builtin Commands) +menu(Zsh Line Editor) +menu(Programmable Completion) +menu(Zsh Modules) + + --- Indices --- + +menu(Concept Index) +menu(Variables Index) +menu(Options Index) +menu(Functions Index) +menu(Editor Functions Index) +menu(Keystroke Index) + + --- The Detailed Node Listing --- + +Introduction + +menu(Author) +menu(Availability) +menu(Mailing Lists) +menu(The Zsh FAQ) +menu(The Zsh Web Page) +menu(See Also) + +Shell Grammar + +menu(Simple Commands & Pipelines) +menu(Precommand Modifiers) +menu(Complex Commands) +menu(Alternate Forms For Complex Commands) +menu(Reserved Words) +menu(Comments) +menu(Aliasing) +menu(Quoting) + +Expansion + +menu(History Expansion) +menu(Process Substitution) +menu(Parameter Expansion) +menu(Command Substitution) +menu(Arithmetic Expansion) +menu(Brace Expansion) +menu(Filename Expansion) +menu(Filename Generation) + +Parameters + +menu(Local Parameters) +menu(Array Parameters) +menu(Positional Parameters) +menu(Parameters Set By The Shell) +menu(Parameters Used By The Shell) + +Options + +menu(Description of Options) +menu(Single Letter Options) + +Zsh Line Editor + +menu(Movement) +menu(History Control) +menu(Modifying Text) +menu(Arguments) +menu(Completion) +menu(Miscellaneous) + +Programmable Completion + +menu(Command Flags) +menu(Option Flags) +menu(Alternative Completion) +menu(Extended Completion) +menu(Example) + +Zsh Modules + +menu(The cap Module) +menu(The clone Module) +menu(The comp1 Module) +menu(The compctl Module) +menu(The deltochar Module) +menu(The example Module) +menu(The files Module) +menu(The sched Module) +menu(The stat Module) +menu(The zle Module) +endmenu() +texinode(The Z Shell Guide)(Introduction)(Top)(Top) +chapter(The Z Shell Guide) +This document has been produced from the texinfo file tt(zsh.texi), +included in the tt(Doc) sub-directory of the Zsh distribution. +sect(Producing documentation from zsh.texi) +The texinfo source may be converted into several formats: + +startitem() +item(The Info guide)( +The Info format allows searching for topics, commands, functions, etc. +from the many Indices. The command `tt(makeinfo zsh.texi)' is used to +produce the Info documentation. +) +item(The printed guide)( +The command `tt(texi2dvi zsh.texi)' will output tt(zsh.dvi) which can +then be processed with bf(dvips) and optionally bf(gs) (Ghostscript) to +produce a nicely formatted printed guide. +) +item(The HTML guide)( +Mark Borges, tt(<mdb@cdc.noaa.gov), maintains an HTML version of this +guide at tt(http://www.peak.org/zsh/Doc/zsh_toc.html). +(The HTML version is produced with bf(texi2html), which may be obtained +from tt(http://wwwcn.cern.ch/dci/texi2html/). The command is +`tt(texi2html -split_chapter -expandinfo zsh.texi)'.) +) +enditem() + +For those who do not have the necessary tools to process texinfo, +precompiled documentation (PostScript, dvi, info and HTML formats) +is available from the zsh archive site or its mirrors, in the file +tt(zsh-doc.tar.gz). (See noderef(Availability) for a list of sites.) diff --git a/Doc/Zsh/index.yo b/Doc/Zsh/index.yo new file mode 100644 index 000000000..7afa14d07 --- /dev/null +++ b/Doc/Zsh/index.yo @@ -0,0 +1,24 @@ +ifztexi(\ +def(printindex)(2)(\ + NOTRANS(@unnumbered) ARG1NL()\ + NL()\ + NOTRANS(@printindex) ARG2\ +)\ +texinode(Concept Index)(Variables Index)(Top)(Top) +printindex(Concept Index)(cp) + +texinode(Variables Index)(Options Index)(Concept Index)(Top) +printindex(Variables Index)(vr) + +texinode(Options Index)(Functions Index)(Variables Index)(Top) +printindex(Options Index)(pg) + +texinode(Functions Index)(Editor Functions Index)(Options Index)(Top) +printindex(Functions Index)(fn) + +texinode(Editor Functions Index)(Keystroke Index)(Functions Index)(Top) +printindex(Editor Functions Index)(tp) + +texinode(Keystroke Index)()(Editor Functions Index)(Top) +printindex(Keystroke Index)(ky) +)\ diff --git a/Doc/Zsh/intro.yo b/Doc/Zsh/intro.yo new file mode 100644 index 000000000..ebb678f70 --- /dev/null +++ b/Doc/Zsh/intro.yo @@ -0,0 +1,38 @@ +texinode(Introduction)(Invocation)(The Z Shell Guide)(Top) +chapter(Introduction) +ifzman(\ +sect(Synopsis) +Because zsh contains many features, the zsh manual has been split into +a number of section+CHAR(s)\ +ifzshall(\ +. This manual page includes all the separate manual pages in the +following order\ +)\ +: + +startlist() +ifzshone(\ +list(em(zsh) Zsh overview (this section)) +)\ +list(em(zshmisc) Anything not fitting into the other sections) +list(em(zshexpn) Zsh command and parameter expansion) +list(em(zshparam) Zsh parameters) +list(em(zshoptions) Zsh options) +list(em(zshbuiltins) Zsh built-in functions) +list(em(zshzle) Zsh command line editing) +list(em(zshcompctl) Zsh completion control) +list(em(zshmodules) Zsh loadable modules) +ifzshone(\ +list(em(zshall) Meta-man page containing all of the above) +)\ +endlist() +sect(Description) +)\ +Zsh is a UNIX command interpreter (shell) usable as an interactive +login shell and as a shell script command processor. Of the standard shells, +zsh most closely resembles bf(ksh) but includes many enhancements. Zsh +has command line editing, builtin spelling correction, programmable +command completion, shell functions (with autoloading), a history +mechanism, and a host of other features. +includefile(Zsh/metafaq.yo) +ifnzman(includefile(Zsh/seealso.yo)) diff --git a/Doc/Zsh/invoke.yo b/Doc/Zsh/invoke.yo new file mode 100644 index 000000000..40a5513d0 --- /dev/null +++ b/Doc/Zsh/invoke.yo @@ -0,0 +1,23 @@ +texinode(Invocation)(Files)(Introduction)(Top) +chapter(Invocation) +cindex(invocation) +sect(Invocation Options) +cindex(flags, shell) +cindex(shell flags) +If the tt(-s) flag is not present and an argument is given, +the first argument is taken to be the pathname of a script to +execute. The remaining arguments are assigned to the positional +parameters. The following flags are interpreted by the shell +when invoked: + +startitem() +item(tt(-c) var(string))( +Read commands from var(string). +) +item(tt(-i))( +Force shell to be interactive. +) +item(tt(-s))( +Read command from the standard input. +) +enditem() diff --git a/Doc/Zsh/jobs.yo b/Doc/Zsh/jobs.yo new file mode 100644 index 000000000..752181f02 --- /dev/null +++ b/Doc/Zsh/jobs.yo @@ -0,0 +1,91 @@ +texinode(Jobs & Signals)(Arithmetic Evaluation)(Functions)(Top) +chapter(Jobs & Signals) +sect(Jobs) +cindex(jobs) +If the tt(MONITOR) option is set, +an interactive shell associates a em(job) with each pipeline. +It keeps a table of current jobs, printed by the tt(jobs) +command, and assigns them small integer numbers. +When a job is started asynchronously with `tt(&)', +the shell prints a line which looks like: + +nofill(tt([1] 1234)) + +indicating that the job which was started asynchronously was job number +1 and had one (top-level) process, whose process ID was 1234. + +If a job is started with `tt(&|)' or `tt(&!)', +then that job is immediately disowned. After startup, it +does not have a place in the job table, and is not subject +to the job control features described here. + +If you are running a job and wish to do something else you may hit the key +^Z (control-Z) which sends a tt(TSTP) signal to the current job. +cindex(jobs, suspending) +cindex(suspending jobs) +The shell will then normally indicate that the job has been `suspended', +and print another prompt. You can then manipulate the state of this job, +findex(bg, use of) +putting it in the background with the tt(bg) command, or run some other +commands and then eventually bring the job back into the foreground with +findex(fg, use of) +the foreground command tt(fg). A ^Z takes effect immediately and +is like an interrupt in that pending output and unread input are discarded +when it is typed. + +A job being run in the background will suspend if it tries to read +from the terminal. +cindex(background jobs, I/O) +cindex(jobs, background, I/O) +Background jobs are normally allowed to produce output, +but this can be disabled by giving the command `tt(stty tostop)'. +If you set this +tty option, then background jobs will suspend when they try to produce +output like they do when they try to read input. + +cindex(jobs, referring to) +cindex(referring to jobs) +There are several ways to refer to jobs in the shell. +A job can be referred to by the process ID of any process of the job +or by one of the following: + +startsitem() +sitem(tt(%)var(number))(The job with the given number.) +sitem(tt(%)var(string))(Any job whose command line begins with var(string).) +sitem(tt(%?)var(string))(Any job whose command line contains var(string).) +sitem(tt(%%))(Current job.) +sitem(tt(%PLUS()))(Equivalent to `tt(%%)'.) +sitem(tt(%-))(Previous job.) +endsitem() + +The shell learns immediately whenever a process changes state. +pindex(NOTIFY, use of) +It normally informs you whenever a job becomes blocked so that +no further progress is possible. If the tt(NOTIFY) option is not set, +it waits until just before it prints a prompt before it informs you. + +When the monitor mode is on, each background job that completes +triggers any trap set for tt(CHLD). + +When you try to leave the shell while jobs are running or suspended, you will +be warned that `You have suspended (running) jobs'. +You may use the tt(jobs) command to see what they are. +If you do this or immediately try to +exit again, the shell will not warn you a second time; the suspended +jobs will be terminated, and the running jobs will be sent +a tt(SIGHUP) signal, if the tt(HUP) option is set. +pindex(HUP, use of) + +cindex(jobs, disowning) +cindex(disowning jobs) +findex(disown, use of) +To avoid having the shell terminate the running jobs, either +use the bf(nohup) command (see manref(nohup)(1)) +or the tt(disown) builtin. +sect(Signals) +The tt(INT) and tt(QUIT) signals for an invoked +command are ignored if the command is followed by +`tt(&)' and the tt(MONITOR) option is not active. +Otherwise, signals have the values +inherited by the shell from its parent +(but see the tt(TRAP)var(NAL) special functions in noderef(Functions)). diff --git a/Doc/Zsh/metafaq.yo b/Doc/Zsh/metafaq.yo new file mode 100644 index 000000000..a9e0bbecf --- /dev/null +++ b/Doc/Zsh/metafaq.yo @@ -0,0 +1,142 @@ +startmenu() +menu(Author) +menu(Availability) +menu(Mailing Lists) +menu(The Zsh FAQ) +menu(The Zsh Web Page) +menu(See Also) +endmenu() +texinode(Author)(Availability)()(Introduction) +sect(Author) +cindex(author) +Zsh was originally written by Paul Falstad tt(<pf@zsh.org>). +Zsh is now maintained by the members of the zsh-workers mailing +list tt(<zsh-workers@math.gatech.edu>). The development is currently +coordinated by Andrew Main (Zefram) tt(<zefram@zsh.org>). The coordinator +can be contacted at tt(<coordinator@zsh.org>), but matters relating to +the code should generally go to the mailing list. +texinode(Availability)(Mailing Lists)(Author)(Introduction) +sect(Availability) +Zsh is available from the following anonymous FTP sites. These mirror +sites are kept frequently up to date. The sites marked with em((G)) +may be mirroring tt(ftp.math.gatech.edu) instead of the primary site. +The sites marked with em((H)) may be mirroring tt(ftp.cs.elte.hu) +instead of the primary site. + +startitem() +item(Primary site)( +nofill(tt(ftp://ftp.zsh.org/pub/zsh/) +tt(http://www.zsh.org/pub/zsh/)) +) +item(Australia)( +nofill(tt(ftp://ftp.zsh.org/pub/zsh/) +tt(http://www.zsh.org/pub/zsh/) +tt(ftp://ftp.ips.oz.au/pub/packages/zsh/) em((G)) em((H))) +) +item(Denmark)( +nofill(tt(ftp://sunsite.auc.dk/pub/unix/shells/zsh/)) +) +item(Finland)( +nofill(tt(ftp://ftp.funet.fi/pub/unix/shells/zsh/) em((H))) +) +item(France)( +nofill(tt(ftp://ftp.cenatls.cena.dgac.fr/pub/shells/zsh/)) +) +item(Germany)( +nofill(tt(ftp://ftp.fu-berlin.de/pub/unix/shells/zsh/) em((H)) +tt(ftp://ftp.gmd.de/packages/zsh/) em((H)) +tt(ftp://ftp.uni-trier.de/pub/unix/shell/zsh/) em((H))) +) +item(Hungary)( +nofill(tt(ftp://ftp.cs.elte.hu/pub/zsh/) +tt(http://www.cs.elte.hu/pub/zsh/) +tt(ftp://ftp.kfki.hu/pub/packages/zsh/) em((H))) +) +item(Israel)( +nofill(tt(ftp://ftp.math.technion.ac.il/mirror/ftp.zsh.org/pub/zsh/) +tt(http://www.math.technion.ac.il/mirror/ftp.zsh.org/pub/zsh/)) +) +item(Japan)( +nofill(tt(ftp://ftp.tohoku.ac.jp/mirror/zsh/) em((H)) +tt(ftp://ftp.nis.co.jp/pub/shells/zsh/) em((H))) +) +item(Norway)( +nofill(tt(ftp://ftp.uit.no/pub/unix/shells/zsh/) em((H))) +) +item(Romania)( +nofill(tt(ftp://ftp.roedu.net/pub/mirrors/ftp.zsh.org/pub/zsh/)) +) +item(Slovenia)( +nofill(tt(ftp://ftp.siol.net/pub/unix/shells/zsh/) em((H))) +) +item(Sweden)( +nofill(tt(ftp://ftp.lysator.liu.se/pub/unix/zsh/) em((H))) +) +item(UK)( +nofill(tt(ftp://ftp.net.lut.ac.uk/zsh/) em((H)) +tt(ftp://sunsite.doc.ic.ac.uk/packages/unix/shells/zsh/) em((G))) +) +item(USA)( +nofill(tt(ftp://ftp.math.gatech.edu/pub/zsh/) +tt(ftp://uiarchive.uiuc.edu/pub/packages/shells/zsh/) +tt(ftp://ftp.sterling.com/zsh/) em((G)) em((H)) +tt(ftp://ftp.rge.com/pub/shells/zsh/) em((G)) em((H)) +tt(ftp://foad.org/pub/zsh/) +tt(http://foad.org/zsh/)) +) +enditem() +texinode(Mailing Lists)(The Zsh FAQ)(Availability)(Introduction) +sect(Mailing Lists) +cindex(mailing lists) +Zsh has 3 mailing lists: + +startitem() +item(tt(<zsh-announce@math.gatech.edu>))( +Announcements about releases, major changes in the shell and the +monthly posting of the Zsh FAQ. (moderated) +) +item(tt(<zsh-users@math.gatech.edu>))( +User discussions. +) +item(tt(<zsh-workers@math.gatech.edu>))( +Hacking, development, bug reports and patches. +) +enditem() + +To subscribe, send mail with the SUBJECT `tt(subscribe) var(<e-mail-address>)' +to the associated administrative address for the mailing list. + +startlist() +list(tt(<zsh-announce-request@math.gatech.edu>)) +list(tt(<zsh-users-request@math.gatech.edu>)) +list(tt(<zsh-workers-request@math.gatech.edu>)) +endlist() + +Unsubscribing is done similarly. + +YOU ONLY NEED TO JOIN ONE OF THE MAILING LISTS AS THEY ARE NESTED. +All submissions to bf(zsh-announce) are automatically forwarded to +bf(zsh-users). All submissions to bf(zsh-users) are automatically +forwarded to bf(zsh-workers). + +If you have problems subscribing/unsubscribing to any of the mailing +lists, send mail to tt(<listmaster@zsh.org>). The mailing lists are +maintained by Richard Coleman tt(<coleman@zsh.org>). + +The mailing lists are archived; the archives can be accessed via the +administrative addresses listed above. There is also a hypertext +archive, maintained by Geoff Wing tt(<gcw@zsh.org>), available at +tt(http://www.zsh.org/mla/). +texinode(The Zsh FAQ)(The Zsh Web Page)(Mailing Lists)(Introduction) +sect(The Zsh FAQ) +Zsh has a list of Frequently Asked Questions (FAQ), maintained by +Peter Stephenson tt(<pws@zsh.org>). It is regularly posted to the +newsgroup bf(comp.unix.shell) and the bf(zsh-announce) mailing list. +The latest version can be found at any of the Zsh FTP sites, or at +tt(http://www.zsh.org/FAQ/). The contact address for FAQ-related matters +is tt(<faqmaster@zsh.org>). +texinode(The Zsh Web Page)(See Also)(The Zsh FAQ)(Introduction) +sect(The Zsh Web Page) +Zsh has a web page which is located at tt(http://www.zsh.org/). This is +maintained by Karsten Thygesen tt(<karthy@zsh.org>), of SunSITE Denmark. +The contact address for web-related matters is tt(<webmaster@zsh.org>). diff --git a/Doc/Zsh/mod_cap.yo b/Doc/Zsh/mod_cap.yo new file mode 100644 index 000000000..f6513b314 --- /dev/null +++ b/Doc/Zsh/mod_cap.yo @@ -0,0 +1,28 @@ +texinode(The cap Module)(The clone Module)()(Zsh Modules) +sect(The cap Module) +The tt(cap) module is used for manipulating POSIX.1e (POSIX.6) capability +sets. If the operating system does not support this interface, the +builtins defined by this module will do nothing. +The builtins in this module are: + +startitem() +findex(cap) +cindex(capabilities, setting) +item(tt(cap) [ var(capabilities) ])( +Change the shell's process capability sets to the specified var(capabilities), +otherwise display the shell's current capabilities. +) +findex(getcap) +cindex(capabilities, getting from files) +item(tt(getcap) var(filename) ...)( +This is a built-in implementation of the POSIX standard utility. It displays +the capability sets on each specified var(filename). +) +findex(setcap) +cindex(capabilities, setting on files) +item(tt(setcap) var(capabilities) var(filename) ...)( +This is a built-in implementation of the POSIX standard utility. It sets +the capability sets on each specified var(filename) to the specified +var(capabilities). +) +enditem() diff --git a/Doc/Zsh/mod_clone.yo b/Doc/Zsh/mod_clone.yo new file mode 100644 index 000000000..9bb7dc255 --- /dev/null +++ b/Doc/Zsh/mod_clone.yo @@ -0,0 +1,19 @@ +texinode(The clone Module)(The comp1 Module)(The cap Module)(Zsh Modules) +sect(The clone Module) +The tt(clone) module makes available one builtin command: + +startitem() +findex(clone) +cindex(shell, cloning) +cindex(cloning the shell) +cindex(terminal) +item(tt(clone) var(tty))( +Creates a forked instance of the current shell, attached to the specified +var(tty). In the new shell, the tt(PID), tt(PPID) and tt(TTY) special +parameters are changed appropriately. tt($!) is set to zero in the new +shell, and to the new shell's PID in the original shell. + +The return value of the builtin is zero in both shells if successful, +and non-zero on error. +) +enditem() diff --git a/Doc/Zsh/mod_comp1.yo b/Doc/Zsh/mod_comp1.yo new file mode 100644 index 000000000..879b6d927 --- /dev/null +++ b/Doc/Zsh/mod_comp1.yo @@ -0,0 +1,11 @@ +texinode(The comp1 Module)(The compctl Module)(The clone Module)(Zsh Modules) +sect(The comp1 Module) +The tt(comp1) module does nothing that is visible to the user. +Its purpose is to provide the internal basis of the programmable +completion mechanism. + +This module must be loaded before any module that +provides a means of controlling completion (such as the tt(compctl) +module), or that uses completions (such as the tt(zle) module). +This is done automatically for modules distributed with zsh, and +for other modules can be effected by the use of tt(zmodload -d). diff --git a/Doc/Zsh/mod_compctl.yo b/Doc/Zsh/mod_compctl.yo new file mode 100644 index 000000000..b7adf8fa6 --- /dev/null +++ b/Doc/Zsh/mod_compctl.yo @@ -0,0 +1,7 @@ +texinode(The compctl Module)(The deltochar Module)(The comp1 Module)(Zsh Modules) +sect(The compctl Module) +The tt(compctl) module makes available one builtin command, tt(compctl), +which is the standard way to control completions for ZLE. See +ifzman(zmanref(zshcompctl))\ +ifnzman(noderef(Programmable Completion))\ +. diff --git a/Doc/Zsh/mod_deltochar.yo b/Doc/Zsh/mod_deltochar.yo new file mode 100644 index 000000000..f92a3da0d --- /dev/null +++ b/Doc/Zsh/mod_deltochar.yo @@ -0,0 +1,12 @@ +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: + +startitem() +tindex(delete-to-char) +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. +) +enditem() diff --git a/Doc/Zsh/mod_example.yo b/Doc/Zsh/mod_example.yo new file mode 100644 index 000000000..5339253d9 --- /dev/null +++ b/Doc/Zsh/mod_example.yo @@ -0,0 +1,16 @@ +texinode(The example Module)(The files Module)(The deltochar Module)(Zsh Modules) +sect(The example Module) +The tt(example) module makes available one builtin command: + +startitem() +findex(example) +cindex(modules, example) +cindex(modules, writing) +cindex(writing modules) +item(tt(example) [ tt(-flags) ] [ var(args) ... ])( +Displays the flags and arguments it is invoked with. +) +enditem() + +The purpose of the module is to serve as an example of how to write a +module. diff --git a/Doc/Zsh/mod_files.yo b/Doc/Zsh/mod_files.yo new file mode 100644 index 000000000..541ebb4a9 --- /dev/null +++ b/Doc/Zsh/mod_files.yo @@ -0,0 +1,100 @@ +texinode(The files Module)(The sched Module)(The example Module)(Zsh Modules) +sect(The files Module) +cindex(files, manipulating) +The tt(files) module makes some standard commands available as builtins: + +startitem() +findex(ln) +xitem(tt(ln) [ tt(-dfis) ] var(filename) var(dest)) +item(tt(ln) [ tt(-dfis) ] var(filename) ... var(dir))( +Creates hard (or, with tt(-s), symbolic) links. In the first form, the +specified var(dest)ination is created, as a link to the specified +var(filename). In the second form, each of the var(filename)s is +taken in turn, and linked to a pathname in the specified var(dir)ectory +that has the same last pathname component. + +Normally, tt(ln) will not attempt to create hard links to +directories. This check can be overridden using the tt(-d) option. +Typically only the super-user can actually succeed in creating +hard links to directories. +This does not apply to symbolic links in any case. + +By default, existing files cannot be replaced by links. +The tt(-i) option causes the user to be queried about replacing +existing files. The tt(-f) option causes existing files to be +silently deleted, without querying. tt(-f) takes precedence. +) +findex(mkdir) +item(tt(mkdir) [ tt(-p) ] [ tt(-m) var(mode) ] var(dir) ...)( +Creates directories. With the tt(-p) option, non-existing parent +directories are first created if necessary, and there will be +no complaint if the directory already exists. +The tt(-m) option can be used to specify (in octal) a set of file permissions +for the created directories, otherwise mode 777 modified by the current +tt(umask) (see manref(umask)(2)) is used. +) +findex(mv) +xitem(tt(mv) [ tt(-fi) ] var(filename) var(dest)) +item(tt(mv) [ tt(-fi) ] var(filename) ... var(dir))( +Moves files. In the first form, the specified var(filename) is moved +to the specified var(dest)ination. In the second form, each of the +var(filename)s is +taken in turn, and moved to a pathname in the specified var(dir)ectory +that has the same last pathname component. + +By default, the user will be queried before replacing any file +that the user cannot write to, but writable files will be silently +removed. +The tt(-i) option causes the user to be queried about replacing +any existing files. The tt(-f) option causes any existing files to be +silently deleted, without querying. tt(-f) takes precedence. + +Note that this tt(mv) will not move files across devices. +Historical versions of tt(mv), when actual renaming is impossible, +fall back on copying and removing files; if this behaviour is desired, +use tt(cp) and tt(rm) manually. This may change in a future version. +) +findex(rm) +item(tt(rm) [ tt(-dfirs) ] var(filename) ...)( +Removes files and directories specified. + +Normally, tt(rm) will not remove directories (except with the tt(-r) +option). The tt(-d) option causes tt(rm) to try removing directories +with tt(unlink) (see manref(unlink)(2)), the same method used for files. +Typically only the super-user can actually succeed in unlinking +directories in this way. +tt(-d) takes precedence over tt(-r). + +By default, the user will be queried before removing any file +that the user cannot write to, but writable files will be silently +removed. +The tt(-i) option causes the user to be queried about removing +any files. The tt(-f) option causes files to be +silently deleted, without querying, and suppresses all error indications. +tt(-f) takes precedence. + +The tt(-r) option causes tt(rm) to recursively descend into directories, +deleting all files in the directory before removing the directory with +the tt(rmdir) system call (see manref(rmdir)(2)). + +The tt(-s) option is a zsh extension to tt(rm) functionality. It enables +paranoid behaviour, intended to avoid common security problems involving +a root-run tt(rm) being tricked into removing files other than the ones +intended. It will refuse to follow symbolic links, so that (for example) +``tt(rm /tmp/foo/passwd)'' can't accidentally remove tt(/etc/passwd) +if tt(/tmp/foo) happens to be a link to tt(/etc). It will also check +where it is after leaving directories, so that a recursive removal of +a deep directory tree can't end up recursively removing tt(/usr) as +a result of directories being moved up the tree. +) +findex(rmdir) +item(tt(rmdir) var(dir) ...)( +Removes empty directories specified. +) +findex(sync) +item(tt(sync))( +Calls the system call of the same name (see manref(sync)(2)), which +flushes dirty buffers to disk. It might return before the I/O has +actually been completed. +) +enditem() diff --git a/Doc/Zsh/mod_sched.yo b/Doc/Zsh/mod_sched.yo new file mode 100644 index 000000000..1be550a79 --- /dev/null +++ b/Doc/Zsh/mod_sched.yo @@ -0,0 +1,17 @@ +texinode(The sched Module)(The stat Module)(The files Module)(Zsh Modules) +sect(The sched Module) +The tt(sched) module makes available one builtin command: + +startitem() +findex(sched) +cindex(timed execution) +cindex(execution, timed) +xitem(tt(sched) [tt(PLUS())]var(hh)tt(:)var(mm) var(command) ...) +item(tt(sched) [ tt(-)var(item) ])( +Make an entry in the scheduled list of commands to execute. +The time may be specified in either absolute or relative time. +With no arguments, prints the list of scheduled commands. +With the argument `tt(-)var(item)', removes the given item +from the list. +) +enditem() diff --git a/Doc/Zsh/mod_stat.yo b/Doc/Zsh/mod_stat.yo new file mode 100644 index 000000000..22fbe2a73 --- /dev/null +++ b/Doc/Zsh/mod_stat.yo @@ -0,0 +1,145 @@ +texinode(The stat Module)(The zle Module)(The sched Module)(Zsh Modules) +sect(The stat Module) +The tt(stat) module makes available one builtin command: + +startitem() +findex(stat) +cindex(files, listing) +cindex(files, examining) +item(tt(stat) [ tt(-gnNlLtTrs) ] [ tt(-f) var(fd) ] [ tt(-A) var(array) ] \ + [ tt(-F) var(fmt) ] [ tt(PLUS())var(element) ] [ var(file) ... ])( +The command acts as a front end to the tt(stat) system call (see +manref(stat)(2)). +If the tt(stat) call fails, the appropriate system error message +printed and status 1 is returned. +The fields of tt(struct stat) give information about +the files provided as arguments to the command. In addition to those +available from the tt(stat) call, an extra element `tt(link)' is provided. +These elements are: + +startitem() +item(tt(device))( +The number of the device on which the file resides. +) +item(tt(inode))( +The unique number of the file on this device (`em(inode)' number). +) +item(tt(mode))( +The mode of the file; that is, the file's type and access permissions. +With the tt(-s) option, this will +be returned as a string corresponding to the first column in the +display of the tt(ls -l) command. +) +item(tt(nlink))( +The number of hard links to the file. +) +item(tt(uid))( +The user ID of the owner of the file. With the tt(-s) +option, this is displayed as a user name. +) +item(tt(gid))( +The group ID of the file. With the tt(-s) option, this +is displayed as a group name. +) +item(tt(rdev))( +The raw device number. This is only useful for special devices. +) +item(tt(size))( +The size of the file in bytes. +) +xitem(tt(atime)) +xitem(tt(mtime)) +item(tt(ctime))( +The last access, modification and inode change times +of the file, respectively, as the number of seconds since +midnight GMT on 1st January, 1970. With the tt(-s) option, +these are printed as strings for the local time zone; the format +can be altered with the tt(-F) option, and with the tt(-g) +option the times are in GMT. +) +item(tt(blksize))( +The number of bytes in one allocation block on the +device on which the file resides. +) +item(tt(block))( +The number of disk blocks used by the file. +) +item(tt(link))( +If the file is a link and the tt(-L) option is in +effect, this contains the name of the file linked to, otherwise +it is empty. Note that if this element is selected (``tt(stat PLUS()link)'') +then the tt(-L) option is automatically used. +) +enditem() + +A particular element may be selected by including its name +preceded by a `tt(PLUS())' in the option list; only one element is allowed. +The element may be shortened to any unique set of leading +characters. Otherwise, all elements will be shown for all files. + +Options: + +startitem() +item(tt(-A) var(array))( +Instead of displaying the results on standard +output, assign them to an var(array), one tt(struct stat) element per array +element for each file in order. In this case neither the name +of the element nor the name of the files is provided unless the +tt(-t) or tt(-n) options are provided, respectively. In the +former case the element name appears as a prefix to the +appropriate array element and in the latter case the file name +appears as a separate array element preceding all the others. +Other formatting options are respected. +) +item(tt(-f) var(fd))( +Use the file on file descriptor var(fd) instead of +named files; no list of file names is allowed in this case. +) +item(tt(-F) var(fmt))( +Supplies a tt(strftime) (see manref(strftime)(3)) string for the +formatting of the time elements. The tt(-s) option is implied. +) +item(tt(-g))( +Show the time elements in the GMT time zone. The +tt(-s) option is implied. +) +item(tt(-l))( +List the names of the type elements (to standard +output or an array as appropriate) and return immediately; +options other than tt(-A) and arguments are ignored. +) +item(tt(-L))( +Perform an tt(lstat) (see manref(lstat)(2)) rather than a tt(stat) +system call. In this case, if the file is a link, information +about the link itself rather than the target file is returned. +This option is required to make the tt(link) element useful. +) +item(tt(-n))( +Always show the names of files. Usually these are +only shown when output is to standard output and there is more +than one file in the list. +) +item(tt(-N))( +Never show the names of files. +) +item(tt(-r))( +Print raw data (the default format) alongside string +data (the tt(-s) format); the string data appears in parentheses +after the raw data. +) +item(tt(-s))( +Print tt(mode), tt(uid), tt(gid) and the three time +elements as strings instead of numbers. In each case the format +is like that of tt(ls -l). +) +item(tt(-t))( +Always show the type names for the elements of +tt(struct stat). Usually these are only shown when output is to +standard output and no individual element has been selected. +) +item(tt(-T))( +Never show the type names of the tt(struct stat) elements. +) +enditem() +) +enditem() diff --git a/Doc/Zsh/mod_zftp.yo b/Doc/Zsh/mod_zftp.yo new file mode 100644 index 000000000..a15be60d6 --- /dev/null +++ b/Doc/Zsh/mod_zftp.yo @@ -0,0 +1,421 @@ +texinode(The zftp Module)(The zle Module)(The stat Module)(Zsh Modules) +sect(The zftp Module) +The tt(zftp) module makes available one builtin command: + +startitem() +findex(zftp) +cindex(FTP) +cindex(files, transferring) +item(tt(zftp) var(subcommand) [ var(args) ])( +The tt(zftp) module is a client for FTP (file transfer protocol). It +is implemented as a builtin to allow full use of shell command line +editing, file I/O, and job control mechanisms. Often, users will +access it via shell functions providing higher level abilities such as +username and password lookup. However, it is entirely usable in its +own right. + +All commands consist of the command name tt(zftp) followed by the name +of a subcommand. These are listed below. The return status of each +subcommand is supposed to reflect the success or failure of the remote +operation. See a description of the variable tt(ZFTP_VERBOSE) for +more information on how responses from the server may be printed. +) +enditem() + +subsect(Subcommands) +cindex(zftp, subcommands) + +startitem() +cindex(FTP, starting a session) +item(tt(open) var(host) [ var(user) [ var(password) [ var(account) ] ] ])( +Open a new FTP session to var(host), which may be the name of a TCP/IP +connected host or an IP number in the standard dot notation. +Remaining arguments are passed to the tt(login) subcommand. Note that +if no arguments beyond var(host) are supplied, tt(open) will em(not) +automatically call tt(login). If no arguments at all are supplied, +tt(open) will use the parameters set by the tt(params) subcommand. + +After a successful open, the shell variables tt(ZFTP_HOST), +tt(ZFTP_IP) and tt(ZFTP_SYSTEM) are available; see `Variables' +below. +) +xitem(tt(login) [ var(name) [ var(password) [ var(account) ] ] ]) +item(tt(user) [ var(name) [ var(password) [ var(account) ] ] ])( +Login the user var(name) with parameters var(password) and var(account). +Any of the parameters can be omitted, and will be read from standard +input if needed (var(name) is always needed). If +standard input is a terminal, a prompt for each one will be printed on +standard error and var(password) will not be echoed. If any of the +parameters are not used, a warning message is printed. + +After a successful login, the shell variables tt(ZFTP_USER), +tt(ZFTP_ACCOUNT) and tt(ZFTP_PWD) are available; see `Variables' +below. + +This command may be re-issued when a user is already logged in, and +the server will first be reinitialized for a new user. +) +xitem(tt(params) [ var(host) [ var(user) [ var(password) \ +[ var(account) ] ] ] ]) +item(tt(params) tt(-))( +Store the given parameters for a later tt(open) command with no +arguments. Only those given on the command line will be remembered. +Any of the parameters may, however, be specified as a `tt(?)', which +may need to be quoted to protect it from shell expansion: in this case, +the appropriate parameter will be read from stdin as with the +tt(login) subcommand, including special handling of var(password). + +If no arguments are given, the parameters currently set are printed, +although the password will appear as a line of stars. + +If instead a single `tt(-)' is given, the existing parameters, if any, +are deleted. In that case, calling tt(open) with no arguments will +cause an error. + +The list of parameters is not deleted after a tt(close), however it +will be deleted if the tt(zftp) module is unloaded. + +For example, + +nofill(tt(zftp params ftp.elsewhere.xx juser '?')) + +will store the host tt(ftp.elsewhere.xx) and the user tt(juser) and +then prompt the user for the corresponding password. + +This command may also be used to set up a transfer which then takes +place completely in the background, freeing tt(zftp) for concurrent +foreground use. For example, + +nofill(tt(zftp params ftp.soreeyes.ca bubble squeak)) +nofill(tt(LPAR()zftp open; zftp get foo >bar; zftp close)tt(RPAR() &)) + +--- here, the connection is restricted to a background subshell and +you are free to open a simultaneous connection in the foreground. +) +item(tt(cd) var(directory))( +Change the remote directory to var(directory). Also alters the shell +variable tt(ZFTP_PWD). +) +item(tt(cdup))( +Change the remote directory to the one higher in the directory tree. +Note that tt(cd ..) will also work correctly on non-UNIX systems. +) +item(tt(dir) [ var(args...) ])( +Give a (verbose) listing of the remote directory. The var(args) are +passed directly to the server. The command's behaviour is implementation +dependent, but a UNIX server will typically interpret var(args) as +arguments to the tt(ls) command and with no arguments return the +result of `tt(ls -l)'. The directory is listed to standard output. +) +item(tt(ls) [ var(args) ])( +Give a (short) listing of the remote directory. With no var(args), +produces a raw list of the files in the directory, one per line. +Otherwise, up to vagaries of the server implementation, behaves +similar to tt(dir). +) +item(tt(type) [ var(type) ])( +Change the type for transfer to var(type), or print the current type +if var(type) is absent. The allowed values are `tt(A)' (ASCII), +`tt(I)' (Image, i.e. binary), or `tt(B)' (a synonym for `tt(I)'). + +The FTP default for a transfer is ASCII. However, if tt(zftp) finds +that the remote host is a UNIX machine with 8-bit byes, it will +automatically switch to using binary for file transfers upon +tt(open). This can subsequently be overridden. + +The transfer type is only passed to the remote host when a data +connection is established; this command involves no network overhead. +) +item(tt(ascii))( +The same as tt(type A). +) +item(tt(binary))( +The same as tt(type I). +) +item(tt(mode) [ tt(S) | tt(B) ])( +Set the mode type to stream (tt(S)) or block (tt(B)). Stream mode is +the default; block mode is not widely supported. +) +xitem(tt(remote) var(files...)) +item(tt(local) [ var(files...) ])( +Print the size and last modification time of the remote or local +files. If there is more than one item on the list, the name of the +file is printed first. The first number is the file size, the second +is the last modification time of the file in the format +tt(CCYYMMDDhhmmSS) consisting of year, month, date, hour, minutes and +seconds in GMT. Note that this format, including the length, is +guaranteed, so that time strings can be directly compared via the +tt([[) builtin's tt(<) and tt(>) operators, even if they are too long +to be represented as integers. + +Not all servers support the commands for retrieving this information. +In that case, the tt(remote) command will print nothing and return +status 2, compared with status 1 for a file not found. + +The tt(local) command (but not tt(remote)) may be used with no +arguments, in which case the information comes from examining file +descriptor zero. This is the same file as seen by a tt(put) command +with no further redirection. +) +item(tt(get) var(file) [...])( +Retrieve all var(file)s from the server, concatenating them +and sending them to standard output. +) +item(tt(put) var(file) [...])( +For each var(file), read a file from standard input and send that to +the remote host with the given name. +) +item(tt(append) var(file) [...])( +As tt(put), but if the remote var(file) already exists, data is +appended to it instead of overwriting it. +) +xitem(tt(getat) var(file) var(point)) +xitem(tt(putat) var(file) var(point)) +item(tt(appendat) var(file) var(point))( +Versions of tt(get), tt(put) and tt(append) which will start the +transfer at the given var(point) in the remote var(file). This is +useful for appending to an incomplete local file. However, note that +this ability is not universally supported by servers (and is not quite +the behaviour specified by the standard). +) +item(tt(delete) var(file) [...])( +Delete the list of files on the server. +) +item(tt(mkdir) var(directory))( +Create a new directory var(directory) on the server. +) +item(tt(rmdir) var(directory))( +Delete the diretory var(directory) on the server. +) +item(tt(rename) var(old-name) var(new-name))( +Rename file var(old-name) to var(new-name) on the server. +) +item(tt(site) var(args...))( +Send a host-specific command to the server. You will probably +only need this if instructed by the server to use it. +) +item(tt(quote) var(args...))( +Send the raw FTP command sequence to the server. You should be +familiar with the FTP command set as defined in RFC959 before doing +this. Useful comands may include tt(STAT) and tt(HELP). Note also +the mechanism for returning messages as described for the variable +tt(ZFTP_VERBOSE) below, in particular that all messages from the +control connection are sent to standard error. +) +xitem(tt(close)) +item(tt(quit))( +Close the current data connection. This unsets the shell parameters +tt(ZFTP_HOST), tt(ZFTP_IP), tt(ZFTP_SYSTEM), tt(ZFTP_USER), +tt(ZFTP_ACCOUNT) and tt(ZFTP_PWD). +) +enditem() + +subsect(Parameters) +cindex(zftp, parameters) +The following shell parameters are used by tt(zftp). Currently none +of them are special. + +startitem() +item(tt(ZFTP_TMOUT))( +Integer. The time in seconds to wait for a network operation to +complete before returning an error. If this is not set when the +module is loaded, it will be given the default value 60. A value of +zero turns off timeouts. If a timeout occurs on the control +connection it will be closed. Use a larger value if this occurs too +frequently. +) +vindex(ZFTP_IP) +item(tt(ZFTP_IP))( +Readonly. The IP address of the current connection in dot notation. +) +vindex(ZFTP_HOST) +item(tt(ZFTP_HOST))( +Readonly. The hostname of the current remote server. If the host was +opened as an IP number, tt(ZFTP_HOST) contains that instead; this +saves the overhead for a name lookup, as IP numbers are most commonly +used when a nameserver is unavailable. +) +vindex(ZFTP_SYSTEM) +item(tt(ZFTP_SYSTEM))( +Readonly. The system type string returned by the server in response +to an FTP tt(SYST) request. The most interesting case is a string +beginning tt("UNIX Type: L8"), which ensures maximum compatibility +with a local UNIX host. +) +vindex(ZFTP_TYPE) +item(tt(ZFTP_TYPE))( +Readonly. The type to be used for data transfers , either `tt(A)' or +`tt(I)'. Use the tt(type) subcommand to change this. +) +vindex(ZFTP_USER) +item(tt(ZFTP_USER))( +Readonly. The username currently logged in, if any. +) +vindex(ZFTP_ACCT) +item(tt(ZFTP_ACCT))( +Readonly. The account name of the current user, if any. Most servers +do not require an account name. +) +vindex(ZFTP_PWD) +item(tt(ZFTP_PWD))( +Readonly. The current directory on the server. +) +vindex(ZFTP_CODE) +item(tt(ZFTP_CODE))( +Readonly. The three digit code of the last FTP reply from the server +as a string. This can still be read after the connection is closed. +) +vindex(ZFTP_REPLY) +item(tt(ZFTP_REPLY))( +Readonly. The last line of the last reply sent by the server. This +can still be read after the connection is closed. +) +vindex(ZFTP_PREFS) +item(tt(ZFTP_PREFS))( +A string of preferences for altering aspects of tt(zftp)'s behaviour. +Each preference is a single character. The following are defined: + +startitem() +item(tt(P))( +Passive: attempt to make the remote server initiate data transfers. +This is slightly more efficient than sendport mode. If the letter +tt(S) occurs later in the string, tt(zftp) will use sendport mode if +passive mode is not available. +) +item(tt(S))( +Sendport: initiate transfers by the FTP tt(PORT) command. If this +occurs before any tt(P) in the string, passive mode will never be +attempted. +) +item(tt(D))( +Dumb: use only the bare minimum of FTP commands. This prevents +the variables tt(ZFTP_SYSTEM) and tt(ZFTP_PWD) from being set, and +will mean all connections default to ASCII type. It may prevent +tt(ZFTP_SIZE) from being set during a transfer if the server +does not send it anyway (many servers do). +) +enditem() + +If tt(ZFTP_PREFS) is not set when tt(zftp) is loaded, it will be set to a +default of `tt(PS)', i.e. use passive mode if available, otherwise +fall back to sendport mode. +) +vindex(ZFTP_VERBOSE) +item(tt(ZFTP_VERBOSE))( +A string of digits between 0 and 5 inclusive, specifying which +responses from the server should be printed. All responses go to +standard error. If any of the numbers 1 to 5 appear in the string, +raw responses from the server with reply codes beginning with that +digit will be printed to standard error. The first digit of the three +digit reply code is defined by RFC959 to correspond to: + +startitem() +item(1.)( +A positive prelimnary reply. +) +item(2.)( +A positive completion reply. +) +item(3.)( +A positive intermediate reply. +) +item(4.)( +A transient negative completion reply. +) +item(5.)( +A permanent negative completion reply. +) +enditem() + +It should be noted that, for unknown reasons, the reply `Service not +available', which forces termination of a connection, is classified as +421, i.e. `transient negative', an interesting interpretation of the word +`transient'. + +The code 0 is special: it indicates that all but the last line of +multiline replies read from the server will be printed to standard +error in a processed format. By convention, servers use this +mechanism for sending information for the user to read. The +appropriate reply code, if it matches the same response, takes +priority. + +If tt(ZFTP_VERBOSE) is not set when tt(zftp) is loaded, it will be +set to the default value tt(450), i.e., messages destined for the user +and all errors will be printed. A null string is valid and +specifies that no messages should be printed. +) +enditem() + +subsect(Functions) +cindex(zftp, functions) + +startitem() +findex(zftp_chpwd) +item(tt(zftp_chpwd))( +If this function is set by the user, it is called every time the +directory changes on the server, including when a user is logged +in, or when a connection is closed. In the last case, tt($ZFTP_PWD) +will be unset; otherwise it will reflect the new directory. +) +findex(zftp_progress) +item(tt(zftp_progress))( +If this function is set by the user, it will be called during +a tt(get), tt(put) or tt(append) operation each time sufficient data +has been received from the host. During a tt(get), the data is sent +to standard output, so it is vital that this function should write +to standard error or directly to the terminal, em(not) to standard +output. + +When it is called with a transfer in progress, the following +additional shell parameters are set: + +startitem() +vindex(ZFTP_FILE) +item(tt(ZFTP_FILE))( +The name of the remote file being transferred from or to. +) +vindex(ZFTP_TRANSFER) +item(tt(ZFTP_TRANSFER))( +A tt(G) for a tt(get) operation and a tt(P) for a tt(put) operation. +) +vindex(ZFTP_SIZE) +item(tt(ZFTP_SIZE))( +The total size of the complete file being transferred: +the same as the first value provided by the +tt(remote) and tt(local) subcommands for a particular file. +If the server cannot supply this value for a remote file being +retrieved, it will not be set. If input is from a pipe the value may +be incorrect and correspond simply to a full pipe buffer. +) +vindex(ZFTP_COUNT) +item(tt(ZFTP_COUNT))( +The amount of data so far transferred; a number between zero and +tt($ZFTP_SIZE), if that is set. This number is always available. +) +enditem() + +The function is initially called with tt(ZFTP_TRANSFER) set +appropriately and tt(ZFTP_COUNT) set to zero. After the transfer is +finished, the function will be called one more time with +tt(ZFTP_TRANSFER) set to tt(GF) or tt(PF), in case it wishes to tidy +up. It is otherwise never called twice with the same value of +tt(ZFTP_COUNT). + +Sometimes the progress meter may cause disruption. It is up to the +user to decide whether the function should be defined and to use +tt(unfunction) when necessary. +) + +subsect(Problems) +cindex(zftp, problems) + +With the exception noted for the tt(params) subcommand, a connection +may not be opened in the left hand side of a pipe as this occurs in a +subshell and the file information is not updated in the main shell. +In the case of type or mode changes or closing the connection in a +subshell, the information is returned but variables are not updated +until the next call to tt(zftp). Other status changes in subshells +will not be reflected by changes to the variables (but should +be otherwise harmless). + +enditem() diff --git a/Doc/Zsh/mod_zle.yo b/Doc/Zsh/mod_zle.yo new file mode 100644 index 000000000..9aa03f7f8 --- /dev/null +++ b/Doc/Zsh/mod_zle.yo @@ -0,0 +1,193 @@ +texinode(The zle Module)()(The stat Module)(Zsh Modules) +sect(The zle Module) +The tt(zle) module contains the Zsh Line Editor. See +ifzman(zmanref(zshzle))\ +ifnzman(noderef(Zsh Line Editor))\ +. It also contains three related builtin commands: + +startitem() +findex(bindkey) +cindex(keys, rebinding) +cindex(rebinding keys) +cindex(keys, binding) +cindex(binding keys) +cindex(keymaps) +xitem(tt(bindkey) [ var(options) ] tt(-l)) +xitem(tt(bindkey) [ var(options) ] tt(-d)) +xitem(tt(bindkey) [ var(options) ] tt(-D) var(keymap) ...) +xitem(tt(bindkey) [ var(options) ] tt(-A) var(old-keymap new-keymap)) +xitem(tt(bindkey) [ var(options) ] tt(-N) var(new-keymap) [ var(old-keymap) ]) +xitem(tt(bindkey) [ var(options) ] tt(-m)) +xitem(tt(bindkey) [ var(options) ] tt(-r) var(in-string) ...) +xitem(tt(bindkey) [ var(options) ] tt(-s) var(in-string out-string) ...) +xitem(tt(bindkey) [ var(options) ] var(in-string command) ...) +item(tt(bindkey) [ var(options) ] [ var(in-string) ])( +tt(bindkey)'s options can be divided into three categories: keymap selection, +operation selection, and others. The keymap selection options are: + +startitem() +item(tt(-e))( +Selects keymap `tt(emacs)', and also links it to `tt(main)'. +) +item(tt(-v))( +Selects keymap `tt(viins)', and also links it to `tt(main)'. +) +item(tt(-a))( +Selects keymap `tt(vicmd)'. +) +item(tt(-M))( +The first non-option argument is used as a keymap name, +and does not otherwise count as an argument. +) +enditem() + +Some operations do not permit a keymap to be selected. +If a keymap selection is required and none of the options above are used, the +`tt(main)' keymap is used. These operations do not permit a keymap to be +selected: + +startitem() +item(tt(-l))( +List all existing keymap names. If the tt(-L) +option is used, list in the form of tt(bindkey) +commands to create the keymaps. +) +item(tt(-d))( +Delete all existing keymaps and reset to the default state. +) +item(tt(-D) var(keymap) ...)( +Delete the named var(keymap)s. +) +item(tt(-A) var(old-keymap new-keymap))( +Make the var(new-keymap) name an alias for var(old-keymap), so that +both names refer to the same keymap. The names have equal standing; +if either is deleted, the other remains. If there is already a keymap +with the var(new-keymap) name, it is deleted. +) +item(tt(-N) var(new-keymap) [ var(old-keymap) ])( +Create a new keymap, named var(new-keymap). If a keymap already has that +name, it is deleted. If an var(old-keymap) name is given, the new keymap +is initialised to be a duplicate of it, otherwise the new keymap will +be empty. +) +enditem() + +The following operations require a keymap to be selected: + +startitem() +item(tt(-m))( +Add the built-in set of meta-key bindings to the selected keymap. +Only keys that are unbound or bound to tt(self-insert) are affected. +) +item(tt(-r) var(in-string) ...)( +Unbind the specified var(in-string)s in the selected keymap. +This is exactly equivalent to binding the strings to tt(undefined-key). +) +item(tt(-s) var(in-string out-string) ...)( +Bind each var(in-string) to each var(out-string). +When var(in-string) is typed, var(out-string) will be +pushed back and treated as input to the line editor. +) +item(var(in-string command) ...)( +Bind each var(in-string) to each var(command). +) +item([ var(in-string) ])( +List key bindings. If an var(in-string) is specified, the binding of +that string in the selected keymap is displayed. Otherwise, all key +bindings in the selected keymap are displayed. As an exception, +if the tt(-e) or tt(-v) options are used alone, the keymap is em(not) +displayed - the implicit linking of keymaps is the only thing that happens. +) +enditem() + +In the binding operations, if the tt(-R) option is used, the var(in-string)s +are interpreted as ranges, instead of plain strings. A valid range +consists of two characters, with an optional `tt(-)' +between them. All characters between the two specified, inclusive, +are bound as specified. + +For either var(in-string) or var(out-string), the following +escape sequences are recognised: + +startsitem() +sitem(tt(\a))(bell character) +sitem(tt(\b))(backspace) +sitem(tt(\e), tt(\E))(escape) +sitem(tt(\f))(form feed) +sitem(tt(\n))(linefeed (newline)) +sitem(tt(\r))(carriage return) +sitem(tt(\t))(horizontal tab) +sitem(tt(\v))(vertical tab) +sitem(tt(\)var(NNN))(character code in octal) +sitem(tt(\x)var(NN))(character code in hexadecimal) +sitem(tt(\M)[tt(-)]var(X))(character with meta bit set) +sitem(tt(\C)[tt(-)]var(X))(control character) +sitem(tt(^)var(X))(control character) +endsitem() + +In all other cases, `tt(\)' escapes the following character. Delete is +written as `tt(^?)'. Note that `tt(\M^?)' and `tt(^\M?)' are not the same. +) +findex(vared) +cindex(parameters, editing) +cindex(editing parameters) +item(tt(vared) [ tt(-ch) ] [ tt(-p) var(prompt) ] [ tt(-r) var(rprompt) ] var(name))( +The value of the parameter var(name) is loaded into the edit +buffer, and the line editor is invoked. When the editor exits, +var(name) is set to the string value returned by the editor. +If the tt(-c) flag is given, the parameter is created if it doesn't +already exist. +If the tt(-p) flag is given, the following string will be taken as +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. +) +findex(zle) +cindex(widgets, rebinding) +cindex(rebinding widgets) +cindex(widgets, binding) +cindex(binding widgets) +cindex(widgets, invoking) +cindex(invoking widgets) +cindex(widgets, calling) +cindex(calling widgets) +cindex(widgets, defining) +cindex(defining widgets) +xitem(tt(zle) tt(-l) [ tt(-L) ]) +xitem(tt(zle) tt(-D) var(widget) ...) +xitem(tt(zle) tt(-A) var(old-widget) var(new-widget)) +xitem(tt(zle) tt(-N) var(widget) [ var(function) ]) +item(tt(zle) var(widget))( +The tt(zle) builtin performs a number of different actions concerning +ZLE. Which operation it performs depends on its options: + +startitem() +item(tt(-l) [ tt(-L) ])( +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. +Built-in widgets are not listed. +) +item(tt(-D) var(widget) ...)( +Delete the named var(widget)s. +) +item(tt(-A) var(old-widget) var(new-widget))( +Make the var(new-widget) name an alias for var(old-widget), so that +both names refer to the same widget. The names have equal standing; +if either is deleted, the other remains. If there is already a widget +with the var(new-widget) name, it is deleted. +) +item(tt(-N) var(widget) [ var(function) ])( +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. +) +item(var(widget))( +Invoke the specified widget. This can only be done when ZLE is +active; normally this will be within a user-defined widget. +) +enditem() +) +enditem() diff --git a/Doc/Zsh/modules.yo b/Doc/Zsh/modules.yo new file mode 100644 index 000000000..b44b00e6b --- /dev/null +++ b/Doc/Zsh/modules.yo @@ -0,0 +1,64 @@ +texinode(Zsh Modules)()(Programmable Completion)(Top) +chapter(Zsh Modules) +cindex(modules) +sect(Description) +Some optional parts of zsh are in modules, separate from the core +of the shell. Each of these modules may be linked in to the +shell at build time, +or can be dynamically linked while the shell is running +if the installation supports this feature. The modules available are: + +startitem() +item(tt(cap))( +Builtins for manipulating POSIX.1e (POSIX.6) capability (privilege) sets. +) +item(tt(clone))( +A builtin that can clone a running shell onto another terminal. +) +item(tt(comp1))( +Base of the completion system. Used by the tt(compctl) and tt(zle) modules. +) +item(tt(compctl))( +The tt(compctl) builtin for controlling completion. +) +item(tt(deltochar))( +A ZLE function duplicating EMACS' tt(zap-to-char). +) +item(tt(example))( +An example of how to write a module. +) +item(tt(files))( +Some basic file manipulation commands as builtins. +) +item(tt(sched))( +A builtin that provides a timed execution facility within the shell. +) +item(tt(stat))( +A builtin command interface to the tt(stat) system call. +) +item(tt(zle))( +The Zsh Line Editor, including the tt(bindkey) and tt(vared) builtins. +) +enditem() +startmenu() +menu(The cap Module) +menu(The clone Module) +menu(The comp1 Module) +menu(The compctl Module) +menu(The deltochar Module) +menu(The example Module) +menu(The files Module) +menu(The sched Module) +menu(The stat Module) +menu(The zle Module) +endmenu() +includefile(Zsh/mod_cap.yo) +includefile(Zsh/mod_clone.yo) +includefile(Zsh/mod_comp1.yo) +includefile(Zsh/mod_compctl.yo) +includefile(Zsh/mod_deltochar.yo) +includefile(Zsh/mod_example.yo) +includefile(Zsh/mod_files.yo) +includefile(Zsh/mod_sched.yo) +includefile(Zsh/mod_stat.yo) +includefile(Zsh/mod_zle.yo) diff --git a/Doc/Zsh/options.yo b/Doc/Zsh/options.yo new file mode 100644 index 000000000..0fdf78e8a --- /dev/null +++ b/Doc/Zsh/options.yo @@ -0,0 +1,1039 @@ +texinode(Options)(Shell Builtin Commands)(Parameters)(Top) +chapter(Options) +cindex(options) +startmenu() +menu(Specifying Options) +menu(Description of Options) +menu(Option Aliases) +menu(Single Letter Options) +endmenu() +texinode(Specifying Options)(Description of Options)()(Options) +sect(Specifying Options) +cindex(options, specifying) +Options are primarily referred to by name. +These names are case insensitive and underscores are ignored. +For example, `tt(allexport)' is equivalent to `tt(A__lleXP_ort)'. + +The sense of an option name may be inverted by preceding it with +`tt(no)', so `tt(setopt No_Beep)' is equivalent to `tt(unsetopt beep)'. +This inversion can only be done once, so `tt(nonobeep)' is em(not) +a synonym for `tt(beep)'. Similarly, `tt(tify)' is not a synonym for +`tt(nonotify)' (the inversion of `tt(notify)'). + +Some options also have one or more single letter names. +There are two sets of single letter options: one used by default, +and another used to emulate bf(sh)/bf(ksh) (used when the +tt(SH_OPTION_LETTERS) option is set). +The single letter options can be used on the shell command line, +or with the tt(set), tt(setopt) and tt(unsetopt) +builtins, as normal Unix options preceded by `tt(-)'. + +The sense of the single letter options may be inverted by using +`tt(PLUS())' instead of `tt(-)'. +Some of the single letter option names refer to an option being off, +in which case the inversion of that name refers to the option being on. +For example, `tt(PLUS()n)' is the short name of `tt(exec)', and +`tt(-n)' is the short name of its inversion, `tt(noexec)'. +texinode(Description of Options)(Option Aliases)(Specifying Options)(Options) +sect(Description of Options) +cindex(options, description) +startitem() +pindex(ALL_EXPORT) +cindex(export, automatic) +item(tt(ALL_EXPORT) (tt(-a), ksh: tt(-a)))( +All parameters subsequently defined are automatically exported. +) +pindex(ALWAYS_LAST_PROMPT) +item(tt(ALWAYS_LAST_PROMPT))( +If unset, key functions that list completions try to return to the last +prompt if given a numeric argument. If set these functions try to +return to the last prompt if given em(no) numeric argument. +) +pindex(ALWAYS_TO_END) +item(tt(ALWAYS_TO_END))( +If a completion is performed with the cursor within a word, and a +full completion is inserted, the cursor is moved to the end of the +word. That is, the cursor is moved to the end of the word if either +a single match is inserted or menu completion is performed. +) +pindex(APPEND_HISTORY) +cindex(history, appending to a file) +item(tt(APPEND_HISTORY))( +If this is set, zsh sessions will append their history list to +the history file, rather than overwrite it. Thus, multiple parallel +zsh sessions will all have their history lists added to the +history file, in the order they are killed. +) +pindex(AUTO_CD) +cindex(cd, automatic) +item(tt(AUTO_CD) (tt(-J)))( +If a command is issued that can't be executed as a normal command, +and the command is the name of a directory, perform the tt(cd) +command to that directory. +) +pindex(AUTO_LIST) +cindex(completion, listing choices) +item(tt(AUTO_LIST) (tt(-9)))( +Automatically list choices on an ambiguous completion. +) +pindex(AUTO_MENU) +cindex(completion, menu) +item(tt(AUTO_MENU))( +Automatically use menu completion after the second consecutive request for +completion, for example by pressing the tab key repeatedly. This option +is overridden by tt(MENU_COMPLETE). +) +pindex(AUTO_NAME_DIRS) +cindex(directories, named) +item(tt(AUTO_NAME_DIRS))( +Any parameter that is set to the absolute name of a directory +immediately becomes a name for that directory, that will be used +by the `tt(%~)' +and related prompt sequences, and will be available when completion +is performed on a word starting with `tt(~)'. +(Otherwise, the parameter must be used in the form `tt(~)var(param)' first.) +) +pindex(AUTO_PARAM_KEYS) +item(tt(AUTO_PARAM_KEYS))( +If a parameter name was completed and a following character +(normally a space) automatically +inserted, and the next character typed is one +of those that have to come directly after the name (like `tt(})', `tt(:)', +etc.), the automatically added character is deleted, so that the character +typed comes immediately after the parameter name. +Completion in a brace expansion is affected similarly: the added character +is a `tt(,)', which will be removed if `tt(})' is typed next. +) +pindex(AUTO_PARAM_SLASH) +item(tt(AUTO_PARAM_SLASH))( +If a parameter is completed whose content is the name of a directory, +then add a trailing slash instead of a space. +) +pindex(AUTO_PUSHD) +cindex(cd, behaving like pushd) +cindex(pushd, making cd behave like) +item(tt(AUTO_PUSHD) (tt(-N)))( +Make tt(cd) push the old directory onto the directory stack. +) +pindex(AUTO_REMOVE_SLASH) +cindex(slash, removing trailing) +item(tt(AUTO_REMOVE_SLASH))( +When the last character resulting from a completion is a slash and the next +character typed is a word delimiter or a slash, remove the slash. +) +pindex(AUTO_RESUME) +cindex(jobs, resuming automatically) +cindex(resuming jobs automatically) +item(tt(AUTO_RESUME) (tt(-W)))( +Treat single word simple commands without redirection +as candidates for resumption of an existing job. +) +pindex(BAD_PATTERN) +cindex(globbing, bad pattern) +cindex(filename generation, bad pattern) +item(tt(BAD_PATTERN) (tt(PLUS()2)))( +If a pattern for filename generation is badly formed, print an error message. +(If this option is unset, the pattern will be left unchanged.) +) +pindex(BANG_HIST) +cindex(history, enable substitution) +cindex(enable history substitution) +item(tt(BANG_HIST) (tt(PLUS()K)))( +Perform textual history substitution, bf(csh)-style, +treating the character `tt(!)' specially. +) +pindex(BARE_GLOB_QUAL) +cindex(globbing qualifiers, enable) +cindex(enable globbing qualifiers) +item(tt(BARE_GLOB_QUAL))( +In a glob pattern, treat a trailing set of parentheses as a qualifier +list, if it contains no `tt(|)', `tt(LPAR())' or (if special) `tt(~)' +characters. See noderef(Filename Generation). +) +pindex(BEEP) +cindex(beep, enabling) +cindex(enabling the beep) +item(tt(BEEP) (tt(PLUS()B)))( +Beep on error in ZLE. +) +pindex(BG_NICE) +cindex(jobs, background priority) +cindex(background jobs, priority of) +cindex(priority of background jobs) +item(tt(BG_NICE) (tt(-6)))( +Run all background jobs at a lower priority. This option +is set by default. +) +pindex(BRACE_CCL) +cindex(brace expansion, extending) +cindex(expansion, brace, extending) +item(tt(BRACE_CCL))( +Expand expressions in braces which would not otherwise undergo brace +expansion to a lexically ordered list of all the characters. See +noderef(Brace Expansion). +) +pindex(BSD_ECHO) +cindex(echo, BSD compatible) +item(tt(BSD_ECHO))( +Make the tt(echo) builtin compatible with the BSD manref(echo)(1) command. +This disables backslashed escape sequences in echo strings unless the +tt(-e) option is specified. +) +pindex(CDABLE_VARS) +cindex(cd, to parameter) +item(tt(CDABLE_VARS) (tt(-T)))( +If the argument to a tt(cd) command (or an implied tt(cd) with the +tt(AUTO_CD) option set) is not a directory, and does not begin with a +slash, try to expand the expression as if it were preceded by a `tt(~)' (see +noderef(Filename Expansion)). +) +pindex(CHASE_LINKS) +cindex(links, symbolic) +cindex(symbolic links) +item(tt(CHASE_LINKS) (tt(-w)))( +Resolve symbolic links to their true values when changing directory. +) +pindex(CLOBBER) +cindex(clobbering, of files) +cindex(file clobbering, allowing) +item(tt(CLOBBER) (tt(PLUS()C), ksh: tt(PLUS()C)))( +Allows `tt(>)' redirection to truncate existing files, +and `tt(>>)' to create files. +Otherwise `tt(>!)' or `tt(>|)' must be used to truncate a file, +and `tt(>>!)' or `tt(>>|)' to create a file. +) +pindex(COMPLETE_ALIASES) +cindex(aliases, completion of) +item(tt(COMPLETE_ALIASES))( +Prevents aliases on the command line from being internally substituted +before completion is attempted. The effect is to make the alias a +distinct command for completion purposes. +) +pindex(COMPLETE_IN_WORD) +item(tt(COMPLETE_IN_WORD))( +If unset, the cursor is set to the end of the word if completion is +started. Otherwise it stays there and completion is done from both ends. +) +pindex(CORRECT) +cindex(correction, spelling) +cindex(spelling correction) +item(tt(CORRECT) (tt(-0)))( +Try to correct the spelling of commands. +) +pindex(CORRECT_ALL) +item(tt(CORRECT_ALL) (tt(-O)))( +Try to correct the spelling of all arguments in a line. +) +pindex(CSH_JUNKIE_HISTORY) +cindex(csh, history style) +cindex(history style, csh) +item(tt(CSH_JUNKIE_HISTORY))( +A history reference without an event specifier will always refer to the +previous command. Without this option, such a history reference refers +to the same event as the previous history reference, defaulting to the +previous command. +) +pindex(CSH_JUNKIE_LOOPS) +cindex(csh, loop style) +cindex(loop style, csh) +item(tt(CSH_JUNKIE_LOOPS))( +Allow loop bodies to take the form `var(list); tt(end)' instead of +`tt(do) var(list); tt(done)'. +) +pindex(CSH_JUNKIE_QUOTES) +cindex(csh, quoting style) +cindex(quoting style, csh) +item(tt(CSH_JUNKIE_QUOTES))( +Changes the rules for single- and double-quoted text to match that of +bf(csh). These require that embedded newlines be preceded by a backslash; +unescaped newlines will cause an error message. +In double-quoted strings, it is made impossible to escape `tt($)', `tt(`)' +or `tt(")' (and `tt(\)' itself no longer needs escaping). +Command substitutions are only expanded once, and cannot be nested. +) +pindex(CSH_NULL_GLOB) +cindex(csh, null globbing style) +cindex(null globbing style, csh) +cindex(globbing, null, style, csh) +item(tt(CSH_NULL_GLOB))( +If a pattern for filename generation has no matches, +delete the pattern from the argument list; +do not report an error unless all the patterns +in a command have no matches. +Overrides tt(NULL_GLOB). +) +pindex(EQUALS) +cindex(filename substitution, =) +item(tt(EQUALS))( +Perform tt(=) filename substitution. +(See noderef(Filename Expansion).) +) +pindex(ERR_EXIT) +cindex(exit status, trapping) +item(tt(ERR_EXIT) (tt(-e), ksh: tt(-e)))( +If a command has a non-zero exit status, execute the tt(ZERR) +trap, if set, and exit. This is disabled while running initialization +scripts. +) +pindex(EXEC) +cindex(command execution, enabling) +item(tt(EXEC) (tt(PLUS()n), ksh: tt(PLUS()n)))( +Do execute commands. Without this option, commands are +read and checked for syntax errors, but not executed. +) +pindex(EXTENDED_GLOB) +cindex(globbing, extended) +item(tt(EXTENDED_GLOB))( +Treat the `tt(#)', `tt(~)' and `tt(^)' characters as part of patterns +for filename generation, etc. (An initial unquoted `tt(~)' +always produces named directory expansion.) +) +pindex(EXTENDED_HISTORY) +cindex(history, timestamping) +item(tt(EXTENDED_HISTORY))( +Save beginning and ending timestamps to the history file. +The format of these timestamps is +`tt(:)var(<beginning time>)tt(:)var(<ending time>)tt(:)var(<command>)'. +) +pindex(FLOW_CONTROL) +cindex(flow control) +item(tt(FLOW_CONTROL))( +If this option is unset, +output flow control via start/stop characters (usually assigned to +^S/^Q) is disabled in the shell's editor. +) +pindex(FUNCTION_ARGZERO) +cindex($0, setting) +item(tt(FUNCTION_ARGZERO))( +When executing a shell function or sourcing a script, set tt($0) +temporarily to the name of the function/script. +) +pindex(GLOB) +cindex(globbing, enabling) +cindex(enabling globbing) +item(tt(GLOB) (tt(PLUS()F), ksh: tt(PLUS()f)))( +Perform filename generation (globbing). +(See noderef(Filename Generation).) +) +pindex(GLOB_ASSIGN) +item(tt(GLOB_ASSIGN))( +If this option is set, filename generation (globbing) is +performed on the right hand side of scalar parameter assignments of +the form `var(name)tt(=)var(pattern) (e.g. `tt(foo=*)'). +If the result has more than one word the parameter will become an array +with those words as arguments. This option is provided for backwards +compatibility only: globbing is always performed on the right hand side +of array assignments of the form `var(name)tt(=LPAR())var(value)tt(RPAR())' +(e.g. `tt(foo=(*))') and this form is recommended for clarity; +with this option set, it is not possible to predict whether the result +will be an array or a scalar. +) +pindex(GLOB_COMPLETE) +item(tt(GLOB_COMPLETE))( +When the current word has a glob pattern, do not insert all the words +resulting from the expansion but cycle through them like +tt(MENU_COMPLETE). If no matches are found, a `tt(*)' is added to the end of the +word or inserted at the cursor if tt(COMPLETE_IN_WORD) is set, and expansion +is attempted again. Using patterns works not only for files but for all +completions, such as options, user names, etc. +) +pindex(GLOB_DOTS) +cindex(globbing, of . files) +item(tt(GLOB_DOTS) (tt(-4)))( +Do not require a leading `tt(.)' in a filename to be matched explicitly. +) +pindex(GLOB_SUBST) +item(tt(GLOB_SUBST))( +Treat any characters resulting from parameter substitution as being +eligible for file expansion and filename generation, and any +characters resulting from command substitution as being eligible for +filename generation. +) +pindex(HASH_CMDS) +cindex(hashing, of commands) +cindex(command hashing) +item(tt(HASH_CMDS))( +Note the location of each command the first time it is executed. +Subsequent invocations of the same command will use the +saved location, avoiding a path search. +If this option is unset, no path hashing will be done at all. +) +pindex(HASH_DIRS) +cindex(hashing, of directories) +cindex(directories, hashing) +item(tt(HASH_DIRS))( +Whenever a command is executed, hash the directory containing it, +as well as all directories that occur earlier in the path. +Has no effect if tt(HASH_CMDS) is unset. +) +pindex(HASH_LIST_ALL) +item(tt(HASH_LIST_ALL))( +Whenever a command completion is attempted, make sure the entire +command path is hashed first. This makes the first completion slower. +) +pindex(HIST_ALLOW_CLOBBER) +item(tt(HIST_ALLOW_CLOBBER))( +Add `tt(|)' to output redirections in the history. This allows history +references to clobber files even when tt(CLOBBER) is unset. +) +pindex(HIST_BEEP) +cindex(history beeping) +cindex(beep, history) +item(tt(HIST_BEEP))( +Beep when an attempt is made to access a history entry which +isn't there. +) +pindex(HIST_IGNORE_DUPS) +cindex(history, ignoring duplicates) +item(tt(HIST_IGNORE_DUPS) (tt(-h)))( +Do not enter command lines into the history list +if they are duplicates of the previous event. +) +pindex(HIST_IGNORE_SPACE) +cindex(history, ignoring spaces) +item(tt(HIST_IGNORE_SPACE) (tt(-g)))( +Do not enter command lines into the history list +if any command on the line begins with a blank. +) +pindex(HIST_NO_FUNCTIONS) +item(tt(HIST_NO_FUNCTIONS))( +Do not store function definitions in the history list. +) +pindex(HIST_NO_STORE) +item(tt(HIST_NO_STORE))( +Remove the tt(history) (tt(fc -l)) command from +the history when invoked. +) +pindex(HIST_REDUCE_BLANKS) +item(tt(HIST_REDUCE_BLANKS))( +Remove superfluous blanks from each command line +being added to the history list. +) +pindex(HIST_VERIFY) +cindex(history, verifying substitution) +item(tt(HIST_VERIFY))( +Whenever the user enters a line with history substitution, +don't execute the line directly; instead, perform +history substitution and reload the line into the editing buffer. +) +pindex(HUP) +cindex(jobs, HUP) +item(tt(HUP))( +Send the tt(HUP) signal to running jobs when the +shell exits. +) +pindex(IGNORE_BRACES) +cindex(disabling brace expansion) +cindex(brace expansion, disabling) +cindex(expansion, brace, disabling) +item(tt(IGNORE_BRACES) (tt(-I)))( +Do not perform brace expansion. +) +pindex(IGNORE_EOF) +cindex(EOF, ignoring) +item(tt(IGNORE_EOF) (tt(-7)))( +Do not exit on end-of-file. Require the use +of tt(exit) or tt(logout) instead. +However, ten consecutive EOFs will cause the shell to exit anyway, +to avoid the shell hanging if its tty goes away. +) +pindex(INTERACTIVE) +item(tt(INTERACTIVE) (tt(-i), ksh: tt(-i)))( +This is an interactive shell. This option is set upon initialisation if +the standard input is a tty and commands are being read from standard input. +(See the discussion of tt(SHIN_STDIN).) +This heuristic may be overridden by specifying a state for this option +on the command line. +The value of this option cannot be changed anywhere other than the command line. +) +pindex(INTERACTIVE_COMMENTS) +cindex(comments, in interactive shells) +item(tt(INTERACTIVE_COMMENTS) (tt(-k)))( +Allow comments even in interactive shells. +) +pindex(KSH_ARRAYS) +cindex(arrays, ksh style) +cindex(array style, ksh) +cindex(ksh, array style) +item(tt(KSH_ARRAYS))( +Emulate bf(ksh) array handling as closely as possible. If this option +is set, array elements are numbered from zero, an array parameter +without subscript refers to the first element instead of the whole array, +and braces are required to delimit a subscript (`tt(${path[2]})' rather +than just `tt($path[2])'). +) +pindex(KSH_AUTOLOAD) +item(tt(KSH_AUTOLOAD))( +Emulate bf(ksh) function autoloading. This means that when a function is +autoloaded, the corresponding file is merely executed, and must define +the function itself. (By default, the function is defined to the contents +of the file. However, the most common bf(ksh)-style case - of the file +containing only a simple definition of the function - is always handled +in the bf(ksh)-compatible manner.) +) +pindex(KSH_GLOB) +item(tt(KSH_GLOB))( +In pattern matching, the interpretation of parentheses is affected by +a preceding `tt(@)', `tt(*)', `tt(+)', `tt(?)' or `tt(!)'. +See noderef(Filename Generation). +) +pindex(KSH_OPTION_PRINT) +cindex(option printing, ksh style) +cindex(option printing style, ksh) +cindex(ksh, option printing style) +item(tt(KSH_OPTION_PRINT))( +Alters the way options settings are printed. +) +pindex(LIST_AMBIGUOUS) +cindex(ambiguous completion) +cindex(completion, ambiguous) +item(tt(LIST_AMBIGUOUS))( +If this option is set, completions are shown only if the completions +don't have a unambiguous prefix or suffix that could be inserted in +the command line. +) +pindex(LIST_BEEP) +cindex(beep, ambiguous completion) +cindex(completion, beep on ambiguous) +item(tt(LIST_BEEP))( +Beep on an ambiguous completion. +) +pindex(LIST_TYPES) +cindex(marking file types) +cindex(files, marking type of) +item(tt(LIST_TYPES) (tt(-X)))( +When listing files that are possible completions, show the +type of each file with a trailing identifying mark. +) +pindex(LOCAL_OPTIONS) +item(tt(LOCAL_OPTIONS))( +If this option is set at the point of return from a shell function, +all the options (including this one) which were in force upon entry to +the function are restored. Otherwise, only this option and the +tt(XTRACE) and tt(PRINT_EXIT_VALUE) options are restored. Hence +if this is explicitly unset by a shell function the other options in +force at the point of return will remain so. +A shell function can also guarantee itself a known shell configuration +with a formulation like `tt(emulate zsh; setopt localoptions)'. +) +pindex(LOGIN) +item(tt(LOGIN) (tt(-l), ksh: tt(-l)))( +This is a login shell. +If this option is not explicitly set, the shell is a login shell if +the first character of the tt(argv[0]) passed to the shell is a `tt(-)'. +) +pindex(LONG_LIST_JOBS) +cindex(jobs, list format) +item(tt(LONG_LIST_JOBS) (tt(-R)))( +List jobs in the long format by default. +) +pindex(MAGIC_EQUAL_SUBST) +item(tt(MAGIC_EQUAL_SUBST))( +All unquoted arguments of the form `var(identifier)tt(=)var(expression)' +appearing after the command name have filename expansion (that is, +where var(expression) has a leading `tt(~)' or `tt(=)') performed on +var(expression) as if it were a parameter assignment. The argument is +not otherwise treated specially; it is passed to the command as a single +argument, and not used as an actual parameter assignment. +) +pindex(MAIL_WARNING) +cindex(mail, warning of reading) +item(tt(MAIL_WARNING) (tt(-U)))( +Print a warning message if a mail file has been +accessed since the shell last checked. +) +pindex(MARK_DIRS) +cindex(directories, marking) +cindex(marking directories) +item(tt(MARK_DIRS) (tt(-8), ksh: tt(-X)))( +Append a trailing `tt(/)' to all directory +names resulting from filename generation (globbing). +) +pindex(MENU_COMPLETE) +cindex(completion, menu) +item(tt(MENU_COMPLETE) (tt(-Y)))( +On an ambiguous completion, instead of listing possibilities or beeping, +insert the first match immediately. Then when completion is requested +again, remove the first match and insert the second match, etc. +When there are no more matches, go back to the first one again. +tt(reverse-menu-complete) may be used to loop through the list +in the other direction. This option overrides tt(AUTO_MENU). +) +pindex(MONITOR) +cindex(job control, allowing) +item(tt(MONITOR) (tt(-m), ksh: tt(-m)))( +Allow job control. Set by default in interactive shells. +) +pindex(MULTIOS) +item(tt(MULTIOS))( +Perform implicit bf(tee)s or bf(cat)s when multiple +redirections are attempted (see noderef(Redirection)). +) +pindex(NOMATCH) +cindex(globbing, no matches) +item(tt(NOMATCH) (tt(PLUS()3)))( +If a pattern for filename generation has no matches, +print an error, instead of +leaving it unchanged in the argument list. +This also applies to file expansion +of an initial `tt(~)' or `tt(=)'. +) +pindex(NOTIFY) +cindex(background jobs, notification) +cindex(notification of background jobs) +item(tt(NOTIFY) (tt(-5), ksh: tt(-b)))( +Report the status of background jobs immediately, rather than +waiting until just before printing a prompt. +) +pindex(NULL_GLOB) +cindex(globbing, no matches) +item(tt(NULL_GLOB) (tt(-G)))( +If a pattern for filename generation has no matches, +delete the pattern from the argument list instead +of reporting an error. Overrides tt(NOMATCH). +) +pindex(NUMERIC_GLOB_SORT) +cindex(globbing, sorting numerically) +item(tt(NUMERIC_GLOB_SORT))( +If numeric filenames are matched by a filename generation pattern, +sort the filenames numerically rather than lexicographically. +) +pindex(OVERSTRIKE) +cindex(editor, overstrike mode) +cindex(overstrike mode, of editor) +item(tt(OVERSTRIKE))( +Start up the line editor in overstrike mode. +) +pindex(PATH_DIRS) +cindex(path search, extended) +item(tt(PATH_DIRS) (tt(-Q)))( +Perform a path search even on command names with slashes in them. +Thus if `tt(/usr/local/bin)' is in the user's path, and he types +`tt(X11/xinit)', the command `tt(/usr/local/bin/X11/xinit)' will be executed +(assuming it exists). +Commands explicitly beginning with `tt(/)', `tt(./)' or `tt(../)' +are not subject to the path search. +This also applies to the tt(.) builtin, +and searches for modules performed by the tt(zmodload) builtin. +) +pindex(POSIX_BUILTINS) +item(tt(POSIX_BUILTINS))( +When this option is set the tt(command) builtin can be used to execute +shell builtin commands. Parameter assignments specified before shell +functions and special builtins are kept after the command completes unless +the special builtin is prefixed with the tt(command) builtin. Special +builtins are +tt(.), +tt(:), +tt(break), +tt(continue), +tt(declare), +tt(eval), +tt(exit), +tt(export), +tt(integer), +tt(local), +tt(readonly), +tt(return), +tt(set), +tt(shift), +tt(source), +tt(times), +tt(trap) and +tt(unset). +) +pindex(PRINT_EIGHT_BIT) +cindex(exit status, printing) +item(tt(PRINT_EIGHT_BIT))( +Print eight bit characters literally in completion lists, etc. +This option is not necessary if your system correctly returns the +printability of eight bit characters (see manref(ctype)(3)). +) +pindex(PRINT_EXIT_VALUE) +cindex(exit status, printing) +item(tt(PRINT_EXIT_VALUE) (tt(-1)))( +Print the exit value of programs with non-zero exit status. +) +pindex(PRIVILEGED) +cindex(privileged mode) +cindex(mode, privileged) +item(tt(PRIVILEGED) (tt(-p), ksh: tt(-p)))( +Turn on privileged mode. This is enabled automatically on startup if the +effective user (group) ID is not equal to the real user (group) ID. Turning +this option off causes the effective user and group IDs to be set to the +real user and group IDs. This option disables sourcing user startup files. +If zsh is invoked as `tt(sh)' or `tt(ksh)' with this option set, +tt(/etc/suid_profile) is sourced (after tt(/etc/profile) on interactive +shells). Sourcing tt(~/.profile) is disabled and the contents of the +tt(ENV) variable is ignored. This option cannot be changed using the +tt(-m) option of tt(setopt) and tt(unsetopt), and changing it inside a +function always changes it globally regardless of the tt(LOCAL_OPTIONS) +option. +) +pindex(PROMPT_BANG) +cindex(prompt, ! expansion) +item(tt(PROMPT_BANG))( +If set, `tt(!)' is treated specially in prompt expansion. +See noderef(Prompt Expansion). +) +pindex(PROMPT_CR) +cindex(prompt, with CR) +item(tt(PROMPT_CR) (tt(PLUS()V)))( +Print a carriage return just before printing +a prompt in the line editor. +) +pindex(PROMPT_PERCENT) +cindex(prompt, % expansion) +item(tt(PROMPT_PERCENT))( +If set, `tt(%)' is treated specially in prompt expansion. +See noderef(Prompt Expansion). +) +pindex(PROMPT_SUBST) +cindex(prompt, parameter expansion) +item(tt(PROMPT_SUBST))( +If set, em(parameter expansion), em(command substitution) and +em(arithmetic expansion) are performed in prompts. +) +pindex(PUSHD_IGNORE_DUPS) +cindex(directory stack, ignoring duplicates) +item(tt(PUSHD_IGNORE_DUPS))( +Don't push multiple copies of the same directory onto the directory stack. +) +pindex(PUSHD_MINUS) +cindex(directory stack, controlling syntax) +item(tt(PUSHD_MINUS))( +Exchanges the meanings of `tt(PLUS())' and `tt(-)' +when used with a number to specify a directory in the stack. +) +pindex(PUSHD_SILENT) +cindex(directory stack, silencing) +item(tt(PUSHD_SILENT) (tt(-E)))( +Do not print the directory stack after tt(pushd) or tt(popd). +) +pindex(PUSHD_TO_HOME) +cindex(pushd, to home) +item(tt(PUSHD_TO_HOME) (tt(-D)))( +Have tt(pushd) with no arguments act like `tt(pushd $HOME)'. +) +pindex(RC_EXPAND_PARAM) +cindex(rc, parameter expansion style) +cindex(parameter expansion style, rc) +item(tt(RC_EXPAND_PARAM) (tt(-P)))( +Array expansions of the form +`var(foo)tt(${)var(xx)tt(})var(bar)', where the parameter +var(xx) is set to tt(LPAR())var(a b c)tt(RPAR()), are substituted with +`var(fooabar foobbar foocbar)' instead of the default +`var(fooa b cbar)'. +) +pindex(RC_QUOTES) +cindex(rc, quoting style) +cindex(quoting style, rc) +item(tt(RC_QUOTES))( +Allow the character sequence `tt('')' to signify a single quote +within singly quoted strings. +) +pindex(RCS) +cindex(startup files, sourcing) +item(tt(RCS) (tt(PLUS()f)))( +After tt(/etc/zshenv) is sourced on startup, source the +tt(.zshenv), tt(/etc/zprofile), tt(.zprofile), +tt(/etc/zshrc), tt(.zshrc), tt(/etc/zlogin), tt(.zlogin), and tt(.zlogout) +files, as described in noderef(Files). +If this option is unset, only the tt(/etc/zshenv) file is sourced. +) +pindex(REC_EXACT) +cindex(completion, exact matches) +item(tt(REC_EXACT) (tt(-S)))( +In completion, recognize exact matches even +if they are ambiguous. +) +pindex(RESTRICTED) +cindex(restricted shell) +item(tt(RESTRICTED) (tt(-r)))( +Enables restricted mode. This option cannot be changed using +tt(unsetopt), and setting it inside a function always changes it +globally regardless of the tt(LOCAL_OPTIONS) option. See +noderef(Restricted Shell). +) +pindex(RM_STAR_SILENT) +cindex(rm *, querying before) +cindex(querying before rm *) +item(tt(RM_STAR_SILENT) (tt(-H)))( +Do not query the user before executing `tt(rm *)' or `tt(rm path/*)'. +) +pindex(RM_STAR_WAIT) +cindex(rm *, waiting before) +cindex(waiting before rm *) +item(tt(RM_STAR_WAIT))( +If querying the user before executing `tt(rm *)' or `tt(rm path/*)', +first wait ten seconds and ignore anything typed in that time. +This avoids the problem of reflexively answering `yes' to the query +when one didn't really mean it. The wait and query can always be +avoided by expanding the `tt(*)' in ZLE (with tab). +) +pindex(SH_FILE_EXPANSION) +cindex(sh, expansion style) +cindex(expansion style, sh) +item(tt(SH_FILE_EXPANSION))( +Perform filename expansion (e.g., ~ expansion) em(before) +parameter expansion, command substitution, arithmetic expansion +and brace expansion. +If this option is unset, it is performed em(after) +brace expansion, so things like `tt(~$USERNAME)' and +`tt(~{pfalstad,rc})' will work. +) +pindex(SH_GLOB) +cindex(sh, globbing style) +cindex(globbing style, sh) +item(tt(SH_GLOB))( +Disables the special meaning of `tt(LPAR())', `tt(|)', `tt(RPAR())' +and 'tt(<)' for globbing the result of parameter and command substitutions, +and in some other places where +the shell accepts patterns. This option is set by default if zsh is +invoked as tt(sh) or tt(ksh). +) +pindex(SHIN_STDIN) +item(tt(SHIN_STDIN) (tt(-s), ksh: tt(-s)))( +Commands are being read from the standard input. +Commands are read from standard input if no command is specified with +tt(-c) and no file of commands is specified. If tt(SHIN_STDIN) +is set explicitly on the command line, +any argument that would otherwise have been +taken as a file to run will instead be treated as a normal positional +parameter. +Note that setting or unsetting this option on the command line does not +necessarily affect the state the option will have while the shell is +running - that is purely an indicator of whether on not commands are +em(actually) being read from standard input. +The value of this option cannot be changed anywhere other than the command line. +) +pindex(SH_OPTION_LETTERS) +cindex(sh, single letter options style) +cindex(ksh, single letter options style) +cindex(single letter options, ksh style) +cindex(options, single letter, ksh style) +item(tt(SH_OPTION_LETTERS))( +If this option is set the shell tries to interpret single letter options +(which are used with tt(set) and tt(setopt)) like bf(ksh) does. +This also affects the value of the tt(-) special parameter. +) +pindex(SHORT_LOOPS) +item(tt(SHORT_LOOPS))( +Allow the short forms of tt(for), tt(select), +tt(if), and tt(function) constructs. +) +pindex(SH_WORD_SPLIT) +cindex(field splitting, sh style) +cindex(sh, field splitting style) +item(tt(SH_WORD_SPLIT) (tt(-y)))( +Causes field splitting to be performed on unquoted parameter expansions. +Note that this option has nothing to do with word splitting. +(See noderef(Parameter Expansion).) +) +pindex(SINGLE_COMMAND) +cindex(single command) +pindex(INTERACTIVE, use of) +item(tt(SINGLE_COMMAND) (tt(-t), ksh: tt(-t)))( +If the shell is reading from standard input, it exits after a single command +has been executed. This also makes the shell non-interactive, unless the +tt(INTERACTIVE) option is explicitly set on the command line. +The value of this option cannot be changed anywhere other than the command line. +) +pindex(SINGLE_LINE_ZLE) +cindex(editor, single line mode) +item(tt(SINGLE_LINE_ZLE) (tt(-M)))( +Use single-line command line editing instead of multi-line. +) +pindex(SUN_KEYBOARD_HACK) +cindex(sun keyboard, annoying) +cindex(annoying keyboard, sun) +item(tt(SUN_KEYBOARD_HACK) (tt(-L)))( +If a line ends with a backquote, and there are an odd number +of backquotes on the line, ignore the trailing backquote. +This is useful on some keyboards where the return key is +too small, and the backquote key lies annoyingly close to it. +) +pindex(UNSET) +cindex(parameters, substituting unset) +cindex(unset parameters, substituting) +item(tt(UNSET) (tt(PLUS()u), ksh: tt(PLUS()u)))( +Treat unset parameters as if they were empty when substituting. +Otherwise they are treated as an error. +) +pindex(VERBOSE) +cindex(tracing, of input lines) +cindex(input, tracing) +item(tt(VERBOSE) (tt(-v), ksh: tt(-v)))( +Print shell input lines as they are read. +) +pindex(XTRACE) +cindex(tracing, of commands) +cindex(commands, tracing) +item(tt(XTRACE) (tt(-x), ksh: tt(-x)))( +Print commands and their arguments as they are executed. +) +pindex(ZLE) +cindex(editor, enabling) +cindex(enabling the editor) +item(tt(ZLE) (tt(-Z)))( +Use the zsh line editor. +) +enditem() +texinode(Option Aliases)(Single Letter Options)(Description of Options)(Options) +sect(Option Aliases) +cindex(options, aliases) +Some options have alternative names. These aliases are never used for +output, but can be used just like normal option names when specifying +options to the shell. + +startitem() +pindex(BRACE_EXPAND) +item(tt(BRACE_EXPAND))( +em(NO_)tt(IGNORE_BRACES) +(ksh and bash compatibility) +) +pindex(DOT_GLOB) +item(tt(DOT_GLOB))( +tt(GLOB_DOTS) +(bash compatibility) +) +pindex(HASH_ALL) +item(tt(HASH_ALL))( +tt(HASH_CMDS) +(bash compatibility) +) +pindex(HIST_APPEND) +item(tt(HIST_APPEND))( +tt(APPEND_HISTORY) +(bash compatibility) +) +pindex(HIST_EXPAND) +item(tt(HIST_EXPAND))( +tt(BANG_HIST) +(bash compatibility) +) +pindex(LOG) +item(tt(LOG))( +em(NO_)tt(HIST_NO_FUNCTIONS) +(ksh compatibility) +) +pindex(MAIL_WARN) +item(tt(MAIL_WARN))( +tt(MAIL_WARNING) +(bash compatibility) +) +pindex(ONE_CMD) +item(tt(ONE_CMD))( +tt(SINGLE_COMMAND) +(bash compatibility) +) +pindex(PHYSICAL) +item(tt(PHYSICAL))( +tt(CHASE_LINKS) +(ksh and bash compatibility) +) +pindex(PROMPT_VARS) +item(tt(PROMPT_VARS))( +tt(PROMPT_SUBST) +(bash compatibility) +) +pindex(STDIN) +item(tt(STDIN))( +tt(SHIN_STDIN) +(ksh compatibility) +) +pindex(TRACK_ALL) +item(tt(TRACK_ALL))( +tt(HASH_CMDS) +(ksh compatibility) +) +enditem() +texinode(Single Letter Options)()(Option Aliases)(Options) +sect(Single Letter Options) +cindex(options, single letter) +cindex(single letter options) +subsect(Default set) +startsitem() +sitem(tt(-0))(CORRECT) +sitem(tt(-1))(PRINT_EXIT_VALUE) +sitem(tt(-2))(em(NO_)BAD_PATTERN) +sitem(tt(-3))(em(NO_)NOMATCH) +sitem(tt(-4))(GLOB_DOTS) +sitem(tt(-5))(NOTIFY) +sitem(tt(-6))(BG_NICE) +sitem(tt(-7))(IGNORE_EOF) +sitem(tt(-8))(MARK_DIRS) +sitem(tt(-9))(AUTO_LIST) +sitem(tt(-B))(em(NO_)BEEP) +sitem(tt(-C))(em(NO_)CLOBBER) +sitem(tt(-D))(PUSHD_TO_HOME) +sitem(tt(-E))(PUSHD_SILENT) +sitem(tt(-F))(em(NO_)GLOB) +sitem(tt(-G))(NULL_GLOB) +sitem(tt(-H))(RM_STAR_SILENT) +sitem(tt(-I))(IGNORE_BRACES) +sitem(tt(-J))(AUTO_CD) +sitem(tt(-K))(em(NO_)BANG_HIST) +sitem(tt(-L))(SUN_KEYBOARD_HACK) +sitem(tt(-M))(SINGLE_LINE_ZLE) +sitem(tt(-N))(AUTO_PUSHD) +sitem(tt(-O))(CORRECT_ALL) +sitem(tt(-P))(RC_EXPAND_PARAM) +sitem(tt(-Q))(PATH_DIRS) +sitem(tt(-R))(LONG_LIST_JOBS) +sitem(tt(-S))(REC_EXACT) +sitem(tt(-T))(CDABLE_VARS) +sitem(tt(-U))(MAIL_WARNING) +sitem(tt(-V))(em(NO_)PROMPT_CR) +sitem(tt(-W))(AUTO_RESUME) +sitem(tt(-X))(LIST_TYPES) +sitem(tt(-Y))(MENU_COMPLETE) +sitem(tt(-Z))(ZLE) +sitem(tt(-a))(ALL_EXPORT) +sitem(tt(-e))(ERR_EXIT) +sitem(tt(-f))(em(NO_)RCS) +sitem(tt(-g))(HIST_IGNORE_SPACE) +sitem(tt(-h))(HIST_IGNORE_DUPS) +sitem(tt(-i))(INTERACTIVE) +sitem(tt(-k))(INTERACTIVE_COMMENTS) +sitem(tt(-l))(LOGIN) +sitem(tt(-m))(MONITOR) +sitem(tt(-n))(em(NO_)EXEC) +sitem(tt(-p))(PRIVILEGED) +sitem(tt(-r))(RESTRICTED) +sitem(tt(-s))(SHIN_STDIN) +sitem(tt(-t))(SINGLE_COMMAND) +sitem(tt(-u))(em(NO_)UNSET) +sitem(tt(-v))(VERBOSE) +sitem(tt(-w))(CHASE_LINKS) +sitem(tt(-x))(XTRACE) +sitem(tt(-y))(SH_WORD_SPLIT) +endsitem() +subsect(sh/ksh emulation set) +startsitem() +sitem(tt(-C))(em(NO_)CLOBBER) +sitem(tt(-X))(MARK_DIRS) +sitem(tt(-a))(ALL_EXPORT) +sitem(tt(-b))(NOTIFY) +sitem(tt(-e))(ERR_EXIT) +sitem(tt(-f))(em(NO_)GLOB) +sitem(tt(-i))(INTERACTIVE) +sitem(tt(-l))(LOGIN) +sitem(tt(-m))(MONITOR) +sitem(tt(-n))(em(NO_)EXEC) +sitem(tt(-p))(PRIVILEGED) +sitem(tt(-r))(RESTRICTED) +sitem(tt(-s))(SHIN_STDIN) +sitem(tt(-t))(SINGLE_COMMAND) +sitem(tt(-u))(em(NO_)UNSET) +sitem(tt(-v))(VERBOSE) +sitem(tt(-x))(XTRACE) +endsitem() +subsect(Also note) +startsitem() +sitem(tt(-A))(Used by tt(set) for setting arrays) +sitem(tt(-c))(Used on the command line to specify a single command) +sitem(tt(-m))(Used by tt(setopt) for pattern-matching option setting) +sitem(tt(-o))(Used in all places to allow use of long option names) +sitem(tt(-s))(Used by tt(set) to sort positional parameters) +endsitem() diff --git a/Doc/Zsh/params.yo b/Doc/Zsh/params.yo new file mode 100644 index 000000000..4c25a18ef --- /dev/null +++ b/Doc/Zsh/params.yo @@ -0,0 +1,812 @@ +texinode(Parameters)(Options)(Expansion)(Top) +chapter(Parameters) +cindex(parameters) +sect(Description) +A parameter has a name, a value, and a number of attributes. +A name may be any sequence of alphanumeric +characters and underscores, or the single characters +`tt(*)', `tt(@)', `tt(#)', `tt(?)', `tt(-)', `tt($)', or `tt(!)'. +The value may be a em(scalar) (a string), +an integer, or an array. +To assign a scalar or integer value to a parameter, +use the tt(typeset) builtin. +findex(typeset, use of) +To assign an array value, use `tt(set -A) var(name) var(value) ...'. +findex(set, use of) +The value of a parameter may also be assigned by writing: + +nofill(var(name)tt(=)var(value)) + +If the integer attribute, tt(-i), is set for var(name), +the var(value) is subject to arithmetic evaluation. + +In the parameter lists, the mark `<S>' indicates that the parameter is special. +Special parameters cannot have their type changed, and they stay special even +if unset. `<Z>' indicates that the parameter does not exist when the shell +initialises in tt(sh) or tt(ksh) emulation mode. +startmenu() +menu(Local Parameters) +menu(Array Parameters) +menu(Positional Parameters) +menu(Parameters Set By The Shell) +menu(Parameters Used By The Shell) +endmenu() +texinode(Local Parameters)(Array Parameters)()(Parameters) +sect(Local Parameters) +Shell function executions delimit scopes for shell parameters. +(Parameters are dynamically scoped.) The tt(typeset) builtin, and its +alternative forms tt(declare), tt(integer), tt(local) and tt(readonly) +(but not tt(export)), can be used to declare a parameter as being local +to the innermost scope. + +When a parameter is read or assigned to, the +innermost existing parameter of that name is used. (That is, the +local parameter hides any less-local parameter.) However, assigning +to a non-existent parameter, or declaring a new parameter with tt(export), +causes it to be created in the em(outer)most scope. + +Local parameters disappear when their scope ends. +tt(unset) can be used to delete a parameter while it is still in scope; this +will reveal the next outer parameter of the same name. However, em(special) +parameters are still special when unset. +texinode(Array Parameters)(Positional Parameters)(Local Parameters)(Parameters) +sect(Array Parameters) +The value of an array parameter may be assigned by writing: + +nofill(var(name)tt(=LPAR())var(value) ...tt(RPAR())) + +Individual elements of an array may be selected using a +subscript. A subscript of the form `tt([)var(exp)tt(])' +selects the single element var(exp), where var(exp) is +an arithmetic expression which will be subject to arithmetic +expansion as if it were surrounded by `tt($LPAR()LPAR())...tt(RPAR()RPAR())'. +The elements are numbered beginning with 1 unless the +tt(KSH_ARRAYS) option is set when they are numbered from zero. +pindex(KSH_ARRAYS, use of) + +A subscript of the form `tt([*])' or `tt([@])' evaluates to all +elements of an array; there is no difference between the two +except when they appear within double quotes. +`tt("$foo[*]")' evaluates to `tt("$foo[1] $foo[2] )...tt(")', while +`tt("$foo[@]")' evaluates to `tt("$foo[1]" "$foo[2]")', etc. + +A subscript of the form `tt([)var(exp1)tt(,)var(exp2)tt(])' +selects all elements in the range var(exp1) to var(exp2), +inclusive. +If one of the subscripts evaluates to a negative number, +say tt(-)var(n), then the var(n)th element from the end +of the array is used. Thus `tt($foo[-3])' is the third element +from the end of the array tt(foo), and +`tt($foo[1,-1])' is the same as `tt($foo[*])'. + +Subscripting may also be performed on non-array values, in which +case the subscripts specify a substring to be extracted. +For example, if tt(FOO) is set to `tt(foobar)', then +`tt(echo $FOO[2,5])' prints `tt(ooba)'. + +Subscripts may be used inside braces used to delimit a parameter name, thus +`tt(${foo[2]})' is equivalent to `tt($foo[2])'. If the tt(KSH_ARRAYS) +option is set, the braced form is the only one that will +work, the subscript otherwise not being treated specially. + +If a subscript is used on the left side of an assignment the selected +range is replaced by the expression on the right side. + +If the opening bracket or the comma is directly followed by an opening +parentheses the string up to the matching closing one is considered to +be a list of flags. The flags currently understood are: + +startitem() +item(tt(e))( +this option has no effect and retained for backward compatibility only. +) +item(tt(w))( +if the parameter subscripted is a scalar than this flag makes +subscription work on a per-word basis instead of characters. +) +item(tt(s:)var(string)tt(:))( +this gives the var(string) that separates words (for use with the +tt(w) flag). +) +item(tt(p))( +Recognize the same escape sequences as the tt(print) builtin in +the string argument of a subsequent `tt(s)' flag. +) +item(tt(f))( +if the parameter subscripted is a scalar than this flag makes +subscription work on a per-line basis instead of characters. +This is a shorthand for `tt(pws:\n:)'. +) +item(tt(r))( +if this flag is given the var(exp) is taken as a 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); note that this is like giving a +number: `tt($foo[(r))var(??)tt(,3])' and `tt($foo[(r))var(??)tt(,(r)f*])' work. +) +item(tt(R))( +like `tt(r)', but gives the last match. +) +item(tt(i))( +like `tt(r)', but gives the index of the match instead; this may not +be combined with a second argument. +) +item(tt(I))( +like `tt(i), but gives the index of the last match. +) +item(tt(n:)var(expr)tt(:))( +if combined with `tt(r)', `tt(R)', `tt(i)' or `tt(I)', makes them give +the var(n)th or var(n)th last match (if var(expr) evaluates to +var(n)). +) +enditem() +texinode(Positional Parameters)(Parameters Set By The Shell)(Array Parameters)(Parameters) +sect(Positional Parameters) +Positional parameters are set by the shell on invocation, +by the tt(set) builtin, or by direct assignment. +The parameter var(n), where var(n) is a number, +is the var(n)th positional parameter. +The parameters tt(*), tt(@) and tt(argv) are +arrays containing all the positional parameters; +thus `tt($argv[)var(n)tt(])', etc., is equivalent to simply `tt($)var(n)'. + +texinode(Parameters Set By The Shell)(Parameters Used By The Shell)(Positional Parameters)(Parameters) +sect(Parameters Set By The Shell) +The following parameters are automatically set by the shell: + +startitem() +vindex(!) +item(tt(!) <S>)( +The process ID of the last background command invoked. +) +vindex(#) +item(tt(#) <S>)( +The number of positional parameters in decimal. +) +vindex(ARGC) +item(tt(ARGC) <S> <Z>)( +Same as tt(#). +) +vindex($) +item(tt($) <S>)( +The process ID of this shell. +) +vindex(-) +item(tt(-) <S>)( +Flags supplied to the shell on invocation or by the tt(set) +or tt(setopt) commands. +) +vindex(*) +item(tt(*) <S>)( +An array containing the positional parameters. +) +vindex(argv) +item(tt(argv) <S> <Z>)( +Same as tt(*). +) +vindex(@) +item(tt(@) <S>)( +Same as tt(argv[@]). +) +vindex(?) +item(tt(?) <S>)( +The exit value returned by the last command. +) +vindex(0) +item(tt(0) <S>)( +The name used to invoke the current shell. If the tt(FUNCTION_ARGZERO) option +is set, this is set temporarily within a shell function to the name of the +function, and within a sourced script to the name of the script. +) +vindex(status) +item(tt(status) <S> <Z>)( +Same as tt(?). +) +vindex(_) +item(tt(_) <S>)( +The last argument of the previous command. +Also, this parameter is set in the environment of every command +executed to the full pathname of the command. +) +vindex(EGID) +item(tt(EGID) <S>)( +The effective group ID of the shell process. If you have sufficient +privileges, you may change the effective group ID of the shell +process by assigning to this parameter. Also (assuming sufficient +privileges), you may start a single command with a different +effective group ID by `tt(LPAR()EGID=)var(gid)tt(; command+RPAR())' +) +vindex(EUID) +item(tt(EUID) <S>)( +The effective user ID of the shell process. If you have sufficient +privileges, you may change the effective user ID of the shell process +by assigning to this parameter. Also (assuming sufficient privileges), +you may start a single command with a different +effective user ID by `tt(LPAR()EUID=)var(uid)tt(; command+RPAR())' +) +vindex(ERRNO) +item(tt(ERRNO) <S>)( +The value of errno (see manref(errno)(3)) +as set by the most recently failed system call. +This value is system dependent and is intended for debugging +purposes. +) +vindex(GID) +item(tt(GID) <S>)( +The real group ID of the shell process. If you have sufficient privileges, +you may change the group ID of the shell process by assigning to this +parameter. Also (assuming sufficient privileges), you may start a single +command under a different +group ID by `tt(LPAR()GID=)var(gid)tt(; command+RPAR())' +) +vindex(HOST) +item(tt(HOST))( +The current hostname. +) +vindex(LINENO) +item(tt(LINENO) <S>)( +The line number of the current line within the current script +being executed. +) +vindex(LOGNAME) +item(tt(LOGNAME))( +If the corresponding variable is not set in the environment of the +shell, it is initialized to the login name corresponding to the +current login session. This parameter is exported by default but +this can be disabled using the tt(typeset) builtin. +) +vindex(MACHTYPE) +item(tt(MACHTYPE))( +The machine type (microprocessor class or machine model), +as determined at compile time. +) +vindex(OLDPWD) +item(tt(OLDPWD))( +The previous working directory. This is set when the shell initialises +and whenever the directory changes. +) +vindex(OPTARG) +item(tt(OPTARG) <S>)( +The value of the last option argument processed by the tt(getopts) +command. +) +vindex(OPTIND) +item(tt(OPTIND) <S>)( +The index of the last option argument processed by the tt(getopts) +command. +) +vindex(OSTYPE) +item(tt(OSTYPE))( +The operating system, as determined at compile time. +) +vindex(PPID) +item(tt(PPID) <S>)( +The process ID of the parent of the shell. +) +vindex(PWD) +item(tt(PWD))( +The present working directory. This is set when the shell initialises +and whenever the directory changes. +) +vindex(RANDOM) +item(tt(RANDOM) <S>)( +A random integer from 0 to 32767, newly generated each time +this parameter is referenced. The random number generator +can be seeded by assigning a numeric value to tt(RANDOM). +) +vindex(SECONDS) +item(tt(SECONDS) <S>)( +The number of seconds since shell invocation. If this parameter +is assigned a value, then the value returned upon reference +will be the value that was assigned plus the number of seconds +since the assignment. +) +vindex(SHLVL) +item(tt(SHLVL) <S>)( +Incremented by one each time a new shell is started. +) +vindex(signals) +item(tt(signals))( +An array containing the names of the signals. +) +vindex(TTY) +item(tt(TTY))( +The name of the tty associated with the shell, if any. +) +vindex(TTYIDLE) +item(tt(TTYIDLE) <S>)( +The idle time of the tty associated with the shell in seconds or -1 if there +is no such tty. +) +vindex(UID) +item(tt(UID) <S>)( +The real user ID of the shell process. If you have sufficient privileges, +you may change the user ID of the shell by assigning to this parameter. +Also (assuming sufficient privileges), you may start a single command +under a different +user ID by `tt(LPAR()UID=)var(uid)tt(; command+RPAR())' +) +vindex(USERNAME) +item(tt(USERNAME) <S>)( +The username corresponding to the real user ID of the shell process. If you +have sufficient privileges, you may change the username (and also the +user ID and group ID) of the shell by assigning to this parameter. +Also (assuming sufficient privileges), you may start a single command +under a different username (and user ID and group ID) +by `tt(LPAR()USERNAME=)var(username)tt(; command+RPAR())' +) +vindex(VENDOR) +item(tt(VENDOR))( +The vendor, as determined at compile time. +) +vindex(ZSH_NAME) +item(tt(ZSH_NAME))( +Expands to the basename of the command used to invoke this instance +of zsh. +) +vindex(ZSH_VERSION) +item(tt(ZSH_VERSION))( +The version number of this zsh. +) +enditem() +texinode(Parameters Used By The Shell)()(Parameters Set By The Shell)(Parameters) +sect(Parameters Used By The Shell) +The following parameters are used by the shell: + +startitem() +vindex(ARGV0) +item(tt(ARGV0))( +If exported, its value is used as tt(argv[0]) of external commands. +Usually used in constructs like `tt(ARGV0=emacs nethack)'. +) +vindex(BAUD) +item(tt(BAUD))( +The baud rate of the current connection. Used by the line editor +update mechanism to compensate for a slow terminal by delaying +updates until necessary. This may be profitably set to a lower value +in some circumstances, e.g. +for slow modems dialing into a communications server which is connected +to a host via a fast link; in this case, this variable +would be set by default to the speed of the fast link, and not +the modem. +This parameter should be set to the baud +rate of the slowest part of the link for best performance. The compensation +mechanism can be turned off by setting the variable to zero. +) +vindex(cdpath) +vindex(CDPATH) +item(tt(cdpath) <S> <Z> (tt(CDPATH) <S>))( +An array (colon-separated list) +of directories specifying the search path for the tt(cd) command. +) +vindex(COLUMNS) +item(tt(COLUMNS) <S>)( +The number of columns for this terminal session. +Used for printing select lists and for the line editor. +) +vindex(DIRSTACKSIZE) +item(tt(DIRSTACKSIZE))( +The maximum size of the directory stack. If the +stack gets larger than this, it will be truncated automatically. +This is useful with the tt(AUTO_PUSHD) option. +pindex(AUTO_PUSHD, use of) +) +vindex(FCEDIT) +item(tt(FCEDIT))( +The default editor for the tt(fc) builtin. +) +vindex(fignore) +vindex(FIGNORE) +item(tt(fignore) <S> <Z> (tt(FIGNORE) <S>))( +An array (colon separated list) +containing the suffixes of files to be ignored +during filename completion. However, if the completion generates only files +which would match if this variable would be ignored, than these files are +completed anyway. +) +vindex(fpath) +vindex(FPATH) +item(tt(fpath) <S> <Z> (tt(FPATH) <S>))( +An array (colon separated list) +of directories specifying the search path for +function definitions. This path is searched when a function +with the tt(-u) attribute is referenced. If an executable +file is found, then it is read and executed in the current environment. +) +vindex(histchars) +item(tt(histchars) <S>)( +Three characters used by the shell's history and lexical analysis +mechanism. The first character signals the start of a history +substitution (default `tt(!)'). The second character signals the +start of a quick history substitution (default `tt(^)'). The third +character is the comment character (default `tt(#)'). +) +vindex(HISTCHARS) +item(tt(HISTCHARS) <S> <Z>)( +Same as tt(histchars). (Deprecated.) +) +vindex(HISTFILE) +item(tt(HISTFILE))( +The file to save the history in when an interactive shell exits. +If unset, the history is not saved. +) +vindex(HISTSIZE) +item(tt(HISTSIZE) <S>)( +The maximum size of the history list. +) +vindex(HOME) +item(tt(HOME) <S>)( +The default argument for the tt(cd) command. +) +vindex(IFS) +item(tt(IFS) <S>)( +Internal field separators (by default space, tab, newline and NUL), that +are used to separate words which result from +command or parameter substitution and words read by +the tt(read) builtin. Any characters from the set space, tab and +newline that appear in the IFS are called em(IFS white space). +One or more IFS white space characters or one non-IFS white space +character together with any adjacent IFS white space character delimit +a field. If an IFS white space character appears twice consecutively +in the IFS, this character is treated as if it were not an IFS white +space character. +) +vindex(KEYTIMEOUT) +item(tt(KEYTIMEOUT))( +The time the shell waits, in hundredths of seconds, for another key to +be pressed when reading bound multi-character sequences. +) +vindex(LANG) +item(tt(LANG) <S>)( +This variable determines the locale category for any category not +specifically selected via a variable starting with `tt(LC_)'. +) +vindex(LC_ALL) +item(tt(LC_ALL) <S>)( +This variable overrides the value of the `tt(LANG)' variable and the value +of any of the other variables starting with `tt(LC_)'. +) +vindex(LC_COLLATE) +item(tt(LC_COLLATE) <S>)( +This variable determines the locale category for character collation +information within ranges in glob brackets and for sorting. +) +vindex(LC_CTYPE) +item(tt(LC_CTYPE) <S>)( +This variable determines the locale category for character handling +functions. +) +vindex(LC_MESSAGES) +item(tt(LC_MESSAGES) <S>)( +This variable determines the language in which messages should be +written. Note that zsh does not use message catalogs. +) +vindex(LC_TIME) +item(tt(LC_TIME) <S>)( +This variable determines the locale category for date and time +formatting in prompt escape sequences. +) +vindex(LINES) +item(tt(LINES) <S>)( +The number of lines for this terminal session. +Used for printing select lists and for the line editor. +) +vindex(LISTMAX) +item(tt(LISTMAX))( +In the line editor, the number of filenames to list without asking first. +If set to zero, the shell asks only if the top of the listing would scroll +off the screen. +) +vindex(LOGCHECK) +item(tt(LOGCHECK))( +The interval in seconds between checks for login/logout activity +using the tt(watch) parameter. +) +vindex(MAIL) +item(tt(MAIL))( +If this parameter is set and tt(mailpath) is not set, +the shell looks for mail in the specified file. +) +vindex(MAILCHECK) +item(tt(MAILCHECK))( +The interval in seconds between checks for new mail. +) +vindex(mailpath) +vindex(MAILPATH) +item(tt(mailpath) <S> <Z> (tt(MAILPATH) <S>))( +An array (colon-separated list) of filenames to check for +new mail. Each filename can be followed by a `tt(?)' and a +message that will be printed. The message will undergo +parameter expansion, command substitution and arithmetic +substitution with the variable tt($_) defined as the name +of the file that has changed. The default message is +`tt(You have new mail)'. If an element is a directory +instead of a file the shell will recursively check every +file in every subdirectory of the element. +) +vindex(manpath) +vindex(MANPATH) +item(tt(manpath) <S> <Z> (tt(MANPATH) <S> <Z>))( +An array (colon-separated list) +whose value is not used by the shell. The tt(manpath) +array can be useful, however, since setting it also sets +tt(MANPATH), and vice versa. +) +vindex(module_path) +vindex(MODULE_PATH) +item(tt(module_path) <S> <Z> (tt(MODULE_PATH) <S>))( +An array (colon-separated list) +of directories that tt(zmodload) +searches for dynamically loadable modules. +This is initialised to a standard pathname, +usually `tt(/usr/local/lib/zsh/$ZSH_VERSION)'. +(The `tt(/usr/local/lib)' part varies from installation to installation.) +For security reasons, any value set in the environment when the shell +is started will be ignored. + +These parameters only exist if the installation supports dynamic +module loading. +) +vindex(NULLCMD) +cindex(null command style) +cindex(csh, null command style) +cindex(ksh, null command style) +item(tt(NULLCMD) <S>)( +The command name to assume if a redirection is specified +with no command. Defaults to tt(cat). For bf(sh)/bf(ksh) +behavior, change this to tt(:). For bf(csh)-like +behavior, unset this parameter; the shell will print an +error message if null commands are entered. +) +vindex(path) +vindex(PATH) +item(tt(path) <S> <Z> (tt(PATH) <S>))( +An array (colon-separated list) +of directories to search for commands. +When this parameter is set, each directory is scanned +and all files found are put in a hash table. +) +vindex(POSTEDIT) +item(tt(POSTEDIT) <S>)( +This string is output whenever the line editor exits. +It usually contains termcap strings to reset the terminal. +) +vindex(PS1) +item(tt(PS1) <S>)( +The primary prompt string, printed before a command is read. +the default is `tt(%m%# )'. It undergoes a special form of expansion +before being displayed; see noderef(Prompt Expansion). +) +vindex(PS2) +item(tt(PS2) <S>)( +The secondary prompt, printed when the shell needs more information +to complete a command. +It is expanded in the same way as tt(PS1). +The default is `tt(%_> )', which displays any shell constructs or quotation +marks which are currently being processed. +) +vindex(PS3) +item(tt(PS3) <S>)( +Selection prompt used within a tt(select) loop. +It is expanded in the same way as tt(PS1). +The default is `tt(?# )'. +) +vindex(PS4) +item(tt(PS4) <S>)( +The execution trace prompt. Default is `tt(PLUS() )'. +) +vindex(PROMPT) +xitem(tt(PROMPT) <S> <Z>) +vindex(PROMPT2) +xitem(tt(PROMPT2) <S> <Z>) +vindex(PROMPT3) +xitem(tt(PROMPT3) <S> <Z>) +vindex(PROMPT4) +item(tt(PROMPT4) <S> <Z>)( +Same as tt(PS1), tt(PS2), tt(PS3) and tt(PS4), +respectively. +) +vindex(psvar) +vindex(PSVAR) +item(tt(psvar) <S> <Z> (tt(PSVAR) <S>))( +An array (colon-separated list) whose first nine values can be used in +tt(PROMPT) strings. Setting tt(psvar) also sets tt(PSVAR), and +vice versa. +) +vindex(prompt) +item(tt(prompt) <S> <Z>)( +Same as tt(PS1). +) +vindex(READNULLCMD) +item(tt(READNULLCMD) <S>)( +The command name to assume if a single input redirection +is specified with no command. Defaults to tt(more). +) +vindex(REPORTTIME) +item(tt(REPORTTIME))( +If nonnegative, commands whose combined user and system execution times +(measured in seconds) are greater than this value have timing +statistics printed for them. +) +vindex(RPROMPT) +xitem(tt(RPROMPT) <S>) +vindex(RPS1) +item(tt(RPS1) <S>)( +This prompt is displayed on the right-hand side of the screen +when the primary prompt is being displayed on the left. +This does not work if the tt(SINGLELINEZLE) option is set. +It is expanded in the same way as tt(PS1). +) +vindex(SAVEHIST) +item(tt(SAVEHIST))( +The maximum number of history events to save in the history file. +) +vindex(SPROMPT) +item(tt(SPROMPT) <S>)( +The prompt used for spelling correction. The sequence +`tt(%R)' expands to the string which presumably needs spelling +correction, and `tt(%r)' expands to the proposed correction. +All other prompt escapes are also allowed. +) +vindex(STTY) +item(tt(STTY))( +If this parameter is set in a command's environment, the shell runs the +tt(stty) command with the value of this parameter as arguments in order to +set up the terminal before executing the command. The modes apply only to the +command, and are reset when it finishes or is suspended. If the command is +suspended and continued later with the tt(fg) or tt(wait) builtins it will +see the modes specified by tt(STTY), as if it were not suspended. This +(intentionally) does not apply if the command is continued via `tt(kill -CONT)'. +tt(STTY) is ignored if the command is run in the background, or if it is in the +environment of the shell but not explicitly assigned to in the input line. This +avoids running stty at every external command by accidentally exporting it. +Also note that tt(STTY) should not be used for window size specifications; these +will not be local to the command. +) +vindex(TERM) +item(tt(TERM) <S>)( +The type of terminal in use. This is used when looking up termcap sequences. +) +vindex(TIMEFMT) +item(tt(TIMEFMT))( +The format of process time reports with the tt(time) keyword. +The default is `tt(%E real %U user %S system %P %J)'. +Recognizes the following escape sequences: + +startsitem() +sitem(tt(%%))(A `tt(%)'.) +sitem(tt(%U))(CPU seconds spent in user mode.) +sitem(tt(%S))(CPU seconds spent in kernel mode.) +sitem(tt(%E))(Elapsed time in seconds.) +sitem(tt(%P))(The CPU percentage, computed as (tt(%U)PLUS()tt(%S))/tt(%E).) +sitem(tt(%J))(The name of this job.) +endsitem() + +A star may be inserted between the percent sign and flags printing time. +This cause the time to be printed in +`var(hh)tt(:)var(mm)tt(:)var(ss)tt(.)var(ttt)' +format (hours and minutes are only printed if they are not zero). +) +vindex(TMOUT) +item(tt(TMOUT))( +If this parameter is nonzero, the shell will receive an tt(ALRM) +signal if a command is not entered within the specified number of +seconds after issuing a prompt. If there is a trap on tt(SIGALRM), it +will be executed and a new alarm is scheduled using the value of the +tt(TMOUT) parameter after executing the trap. If no trap is set, and +the idle time of the terminal is not less than the value of the +tt(TMOUT) parameter, zsh terminates. Otherwise a new alarm is +scheduled to tt(TMOUT) seconds after the last keypress. +) +vindex(TMPPREFIX) +item(tt(TMPPREFIX))( +A pathname prefix which the shell will use for all temporary files. +Note that this should include an initial part for the file name as +well as any directory names. The default is `tt(/tmp/zsh)'. +) +vindex(watch) +vindex(WATCH) +item(tt(watch) <S> <Z> (tt(WATCH) <S>))( +An array (colon-separated list) of login/logout events to report. +If it contains the single word `tt(all)', then all login/logout events +are reported. If it contains the single word `tt(notme)', then all +events are reported as with `tt(all)' except tt($USERNAME). +An entry in this list may consist of a username, +an `tt(@)' followed by a remote hostname, +and a `tt(%)' followed by a line (tty). +Any or all of these components may be present in an entry; +if a login/logout event matches all of them, +it is reported. +) +vindex(WATCHFMT) +item(tt(WATCHFMT))( +The format of login/logout reports if the tt(watch) parameter is set. +Default is `tt(%n has %a %l from %m)'. +Recognizes the following escape sequences: + +startitem() +item(tt(%n))( +The name of the user that logged in/out. +) +item(tt(%a))( +The observed action, i.e. "logged on" or "logged off". +) +item(tt(%l))( +The line (tty) the user is logged in on. +) +item(tt(%M))( +The full hostname of the remote host. +) +item(tt(%m))( +The hostname up to the first `tt(.)'. If only the +IP address is available or the utmp field contains +the name of an X-windows display, the whole name is printed. + +em(NOTE:) +The `tt(%m)' and `tt(%M)' escapes will work only if there is a host name +field in the utmp on your machine. Otherwise they are +treated as ordinary strings. +) +item(tt(%S) LPAR()tt(%s)RPAR())( +Start (stop) standout mode. +) +item(tt(%U) LPAR()tt(%u)RPAR())( +Start (stop) underline mode. +) +item(tt(%B) LPAR()tt(%b)RPAR())( +Start (stop) boldface mode. +) +xitem(tt(%t)) +item(tt(%@))( +The time, in 12-hour, am/pm format. +) +item(tt(%T))( +The time, in 24-hour format. +) +item(tt(%w))( +The date in `var(day)tt(-)var(dd)' format. +) +item(tt(%W))( +The date in `var(mm)tt(/)var(dd)tt(/)var(yy)' format. +) +item(tt(%D))( +The date in `var(yy)tt(-)var(mm)tt(-)var(dd)' format. +) +item(tt(%LPAR())var(x)tt(:)var(true-text)tt(:)var(false-text)tt(RPAR()))( +Specifies a ternary expression. +The character following the var(x) is +arbitrary; the same character is used to separate the text +for the "true" result from that for the "false" result. +Both the separator and the right parenthesis may be escaped +with a backslash. +Ternary expressions may be nested. + +The test character var(x) may be any one of `tt(l)', `tt(n)', `tt(m)' +or `tt(M)', which indicate a `true' result if the corresponding +escape sequence would return a non-empty value; or it may be `tt(a)', +which indicates a `true' result if the watched user has logged in, +or `false' if he has logged out. +Other characters evaluate to neither true nor false; the entire +expression is omitted in this case. + +If the result is `true', then the var(true-text) +is formatted according to the rules above and printed, +and the var(false-text) is skipped. +If `false', the var(true-text) is skipped and the var(false-text) +is formatted and printed. +Either or both of the branches may be empty, but +both separators must be present in any case. +) +enditem() +) +vindex(WORDCHARS) +item(tt(WORDCHARS) <S>)( +A list of non-alphanumeric characters considered part of a word +by the line editor. +) +vindex(ZDOTDIR) +item(tt(ZDOTDIR))( +The directory to search for shell startup files (.zshrc, etc), +if not tt($HOME). +) +enditem() diff --git a/Doc/Zsh/prompt.yo b/Doc/Zsh/prompt.yo new file mode 100644 index 000000000..e1628da86 --- /dev/null +++ b/Doc/Zsh/prompt.yo @@ -0,0 +1,209 @@ +texinode(Prompt Expansion)(Restricted Shell)(Compatibility)(Top) +chapter(Prompt Expansion) +ifzman(\ +sect(Prompt Expansion) +)\ +Prompt sequences undergo a special form of expansion. This type of expansion +is also available using the tt(-P) option to the tt(print) builtin. + +pindex(PROMPT_SUBST, use of) +If the tt(PROMPT_SUBST) option is set, the prompt string is first subjected to +em(parameter expansion), +em(command substitution) and +em(arithmetic expansion). +See +ifzman(\ +zmanref(zshexpn). +)\ +ifnzman(\ +noderef(Expansion). +)\ + +Certain escape sequences may be recognised in the prompt string. + +pindex(PROMPT_BANG, use of) +If the tt(PROMPT_BANG) option is set, a `tt(!)' in the prompt is replaced +by the current history event number. A literal `tt(!)' may then be +represented as `tt(!!)'. + +pindex(PROMPT_PERCENT, use of) +If the tt(PROMPT_PERCENT) option is set, certain escape sequences that +start with `tt(%)' are expanded. +Some escapes take an optional integer argument, which +should appear between the `tt(%)' and the next character of the +sequence. The following escape sequences are recognized: + +startitem() +item(tt(%%))( +A `tt(%)'. +) +item(tt(%RPAR()))( +A `tt(RPAR())'. +) +xitem(tt(%d)) +item(tt(%/))( +Present working directory (tt($PWD)). +) +item(tt(%~))( +tt($PWD). +If it has a named directory as its prefix, that part is replaced +by a `tt(~)' followed by the name of the directory. +If it starts with tt($HOME), that part is +replaced by a `tt(~)'. +) +xitem(tt(%c)) +xitem(tt(%.)) +item(tt(%C))( +Trailing component of tt($PWD). +An integer may follow the `tt(%)' to get more than one component. +Unless `tt(%C)' is used, tilde contraction is performed first. +) +xitem(tt(%h)) +item(tt(%!))( +Current history event number. +) +item(tt(%L))( +The current value of tt($SHLVL). +) +item(tt(%M))( +The full machine hostname. +) +item(tt(%m))( +The hostname up to the first `tt(.)'. +An integer may follow the `tt(%)' to specify +how many components of the hostname are desired. +) +item(tt(%S) LPAR()tt(%s)RPAR())( +Start (stop) standout mode. +) +item(tt(%U) LPAR()tt(%u)RPAR())( +Start (stop) underline mode. +) +item(tt(%B) LPAR()tt(%b)RPAR())( +Start (stop) boldface mode. +) +xitem(tt(%t)) +item(tt(%@))( +Current time of day, in 12-hour, am/pm format. +) +item(tt(%T))( +Current time of day, in 24-hour format. +) +item(tt(%*))( +Current time of day in 24-hour format, with seconds. +) +item(tt(%n))( +tt($USERNAME). +) +item(tt(%w))( +The date in var(day)tt(-)var(dd) format. +) +item(tt(%W))( +The date in var(mm)tt(/)var(dd)tt(/)var(yy) format. +) +item(tt(%D))( +The date in var(yy)tt(-)var(mm)tt(-)var(dd) format. +) +item(tt(%D{)var(string)tt(}))( +var(string) is formatted using the tt(strftime) function. +See manref(strftime)(3) for more details. Three additional codes are +available: tt(%f) prints the day of the month, like tt(%e) but +without any preceding space if the day is a single digit, and +tt(%K)/tt(%L) correspond to tt(%k)/tt(%l) for the hour of the day +(24/12 hour clock) in the same way. +) +item(tt(%l))( +The line (tty) the user is logged in on. +) +item(tt(%?))( +The return code of the last command executed just before the prompt. +) +item(tt(%_))( +The status of the parser, i.e. the shell constructs (like `tt(if)' and +`tt(for)') that have been started on the command line. If given an integer +number that many strings will be printed; zero or no integer means +print as many as there are. +) +item(tt(%E))( +Clears to end of line. +) +item(tt(%#))( +A `tt(#)' if the shell is running with privileges, a `tt(%)' if not. +Equivalent to `tt(%(!.#.%%))'. +The definition of `privileged', for these purposes, is that either the +effective user ID is zero, or, if POSIX.1e capabilities are supported, that +at least one capability is raised in either the Effective or Inheritable +capability vectors. +) +item(tt(%v))( +vindex(psvar, use of) +The value of the first element of the tt(psvar) array parameter. Following +the `tt(%)' with an integer gives that element of the array. +) +item(tt(%{)...tt(%}))( +Include a string as a literal escape sequence. +The string within the braces should not change the cursor +position. Brace pairs can nest. +) +item(tt(%LPAR())var(x.true-text.false-text)tt(RPAR()))( +Specifies a ternary expression. The character following the var(x) is +arbitrary; the same character is used to separate the text for the +`true' result from that for the `false' result. +This separator may not appear in the var(true-text), except as part of a +%-escape +sequence. A `tt(RPAR())' may appear in the var(false-text) as `tt(%RPAR())'. +var(true-text) +and var(false-text) may both contain arbitrarily-nested escape +sequences, including further ternary expressions. + +The left +parenthesis may be preceded or followed by a positive integer var(n), +which defaults to zero. The test character var(x) may be any of the +following: + +startsitem() +sxitem(tt(c)) +sxitem(tt(.)) +sitem(tt(~))(True if the current path, with prefix replacement, has at least var(n) elements.) +sxitem(tt(/)) +sitem(tt(C))(True if the current absolute path has at least var(n) elements.) +sitem(tt(t))(True if the time in minutes is equal to var(n).) +sitem(tt(T))(True if the time in hours is equal to var(n).) +sitem(tt(d))(True if the day of the month is equal to var(n).) +sitem(tt(D))(True if the month is equal to var(n) (January = 0).) +sitem(tt(w))(True if the day of the week is equal to var(n) (Sunday = 0).) +sitem(tt(?))(True if the exit status of the last command was var(n).) +sitem(tt(#))(True if the effective uid of the current process is var(n).) +sitem(tt(g))(True if the effective gid of the current process is var(n).) +sitem(tt(L))(True if the tt(SHLVL) parameter is at least var(n).) +sitem(tt(S))(True if the tt(SECONDS) parameter is at least var(n).) +sitem(tt(v))(True if the array tt(psvar) has at least var(n) elements.) +sitem(tt(_))(True if at least var(n) shell constructs were started.) +sitem(tt(!))(True if the shell is running with privileges.) +endsitem() +) +xitem(tt(%<)var(string)tt(<)) +xitem(tt(%>)var(string)tt(>)) +item(tt(%[)var(xstring)tt(]))( +Specifies truncation behaviour. +The third, deprecated, form is equivalent to `tt(%)var(xstringx)', +i.e. var(x) may be `tt(<)' or `tt(>)'. +The numeric argument, which in the third form may appear immediately +after the `tt([)', specifies the maximum permitted length of +the various strings that can be displayed in the prompt. If this +integer is zero, or missing, truncation is disabled. Truncation is +initially disabled. +The var(string) will be displayed in +place of the truncated portion of any string. + +The forms with `tt(<)' truncate at the left of the string, +and the forms with `tt(>)' truncate at the right of the string. +For example, if the current directory is `tt(/home/pike)', +the prompt `tt(%8<..<%/)' will expand to `tt(..e/pike)'. +In this string, the terminating character (`tt(<)', `tt(>)' or `tt(])'), +or in fact any character, may be quoted by a preceding `tt(\)'. +% escapes are em(not) recognised. +If the var(string) is longer than the specified truncation length, +it will appear in full, completely replacing the truncated string. +) +enditem() diff --git a/Doc/Zsh/redirect.yo b/Doc/Zsh/redirect.yo new file mode 100644 index 000000000..8955e67ac --- /dev/null +++ b/Doc/Zsh/redirect.yo @@ -0,0 +1,183 @@ +texinode(Redirection)(Command Execution)(Shell Grammar)(Top) +chapter(Redirection) +cindex(redirection) +ifzman(\ +sect(Redirection) +)\ +cindex(file descriptors) +cindex(descriptors, file) +If a command is followed by tt(&) +and job control is not active, +then the default standard input +for the command is the empty file tt(/dev/null). +Otherwise, the environment for the execution of a command contains the +file descriptors of the invoking shell as modified by +input/output specifications. + +The following may appear anywhere in a simple command +or may precede or follow a complex command. +Substitution occurs before var(word) or var(digit) +is used except as noted below. +If the result of substitution on var(word) +produces more than one filename, +redirection occurs for each +separate filename in turn. + +startitem() +item(tt(<) var(word))( +Open file var(word) for reading as standard input. +) +item(tt(<>) var(word))( +Open file var(word) for reading and writing as standard input. +If the file does not exist then it is created. +) +item(tt(>) var(word))( +Open file var(word) for writing as standard output. +If the file does not exist then it is created. +If the file exists, and the tt(CLOBBER) option is unset, +this causes an error; +otherwise, it is truncated to zero length. +) +xitem(tt(>|) var(word)) +item(tt(>!) var(word))( +Same as tt(>), except that the file is truncated to zero length +if it exists, even if tt(CLOBBER) is unset. +) +item(tt(>>) var(word))( +Open file var(word) for writing in append mode as standard output. +If the file does not exist, and the tt(CLOBBER) +option is unset, this causes an error; +otherwise, the file is created. +) +xitem(tt(>>|) var(word)) +item(tt(>>!) var(word))( +Same as tt(>>), except that the file is created if it does not +exist, even if tt(CLOBBER) is unset. +) +item(tt(<<)[tt(-)] var(word))( +The shell input is read up to a line that is the same as +var(word), or to an end-of-file. +No parameter substitution, command substitution or +filename generation is performed on var(word). +The resulting document, called a +em(here-document), becomes the standard input. + +If any character of var(word) is quoted with +single or double quotes or a `tt(\)', +no interpretation is placed upon the characters of the document. +Otherwise, parameter and command substitution +occurs, `tt(\)' followed by a newline is removed, +and `tt(\)' must be used to quote the characters +`tt(\)', `tt($)', `tt(`)' and the first character of var(word). + +If tt(<<-) is used, then all leading +tabs are stripped from var(word) and from the document. +) +item(tt(<<<) var(word))( +Perform shell expansion on var(word) and pass the result +to standard input. This is known as a em(here-string). +) +xitem(tt(<&) var(digit)) +item(tt(>&) var(digit))( +The standard input/output is duplicated from file descriptor +var(digit) (see manref(dup)(2)). +) +xitem(tt(<& -)) +item(tt(>& -))( +Close the standard input/output. +) +xitem(tt(<& p)) +item(tt(>& p))( +The input/output from/to the coprocess is moved to the standard input/output. +) +item(tt(>&) var(word))( +Same as `tt(>) var(word) tt(2>&1)'. +) +item(tt(>>&) var(word))( +Same as `tt(>>) var(word) tt(2>&1)'. +) +enditem() + +If one of the above is preceded by a digit, then the file +descriptor referred to is that specified by the digit +instead of the default 0 or 1. +The order in which redirections are specified is significant. +The shell evaluates each redirection in terms of the +(em(file descriptor), em(file)) +association at the time of evaluation. +For example: + +nofill(... tt(1>)var(fname) tt(2>&1)) + +first associates file descriptor 1 with file var(fname). +It then associates file descriptor 2 with the file associated with file +descriptor 1 (that is, var(fname)). +If the order of redirections were reversed, +file descriptor 2 would be associated +with the terminal (assuming file descriptor 1 had been) +and then file descriptor 1 would be associated with file var(fname). +sect(Multios) +pindex(MULTIOS, use of) +If the user tries to open a file descriptor for writing more than once, +the shell opens the file descriptor as a pipe to a process that copies +its input to all the specified outputs, similar to bf(tee), +provided the tt(MULTIOS) option is set. Thus: + +nofill(tt(date >foo >bar)) + +writes the date to two files, named `tt(foo)' and `tt(bar)'. +Note that a pipe is an implicit redirection; thus + +nofill(tt(date >foo | cat)) + +writes the date to the file `tt(foo)', and also pipes it to cat. + +If the tt(MULTIOS) +option is set, the word after a redirection operator is also subjected +to filename generation (globbing). Thus + +nofill(tt(: > *)) + +will truncate all files in the current directory, +assuming there's at least one. (Without the tt(MULTIOS) +option, it would create an empty file called `tt(*)'.) +Similarly, you can do + +nofill(tt(echo exit 0 >> *.sh)) + +If the user tries to open a file descriptor for reading more than once, +the shell opens the file descriptor as a pipe to a process that copies +all the specified inputs to its output in the order +specified, similar to bf(cat), +provided the tt(MULTIOS) option is set. Thus + +nofill(tt(sort <foo <fubar)) + +or even + +nofill(tt(sort <f{oo,ubar})) + +is equivalent to `tt(cat foo fubar | sort)'. + +Note that a pipe is an implicit redirection; thus + +nofill(tt(cat bar | sort <foo)) + +is equivalent to `tt(cat bar foo | sort)' (note the order of the inputs). + +If the tt(MULTIOS) option is em(un)set, +each redirection replaces the previous redirection for that file descriptor. +However, all files redirected to are actually opened, so + +nofill(tt(echo foo > bar > baz)) + +when tt(MULTIOS) is unset will truncate bar, and write `tt(foo)' into baz. + +If a simple command consists of one or more redirection operators +and zero or more parameter assignments, but no command name, +the command named in the shell variable tt(READNULLCMD) is assumed. +(If tt(READNULLCMD) is empty or not set, `tt(cat)' is used.) Thus + +nofill(tt(< file)) + +prints the contents of tt(file). diff --git a/Doc/Zsh/restricted.yo b/Doc/Zsh/restricted.yo new file mode 100644 index 000000000..a61fd4955 --- /dev/null +++ b/Doc/Zsh/restricted.yo @@ -0,0 +1,44 @@ +texinode(Restricted Shell)(Expansion)(Prompt Expansion)(Top) +chapter(Restricted Shell) +ifzman(\ +sect(Restricted Shell) +)\ +cindex(restricted shell) +pindex(RESTRICTED) +When the basename of the command used to invoke zsh starts with the letter +`tt(r)' or the `tt(-r)' command line option is supplied at invocation, the +shell becomes restricted. Emulation mode is determined after stripping the +letter `tt(r)' from the invocation name. The following are disabled in +restricted mode: + +startitemize() +itemiz(changing directories with the tt(cd) builtin) +itemiz(changing or unsetting the tt(PATH), tt(path), tt(MODULE_PATH), +tt(module_path), tt(SHELL), tt(HISTFILE), tt(HISTSIZE), tt(GID), tt(EGID), +tt(UID), tt(EUID), tt(USERNAME), tt(LD_LIBRARY_PATH), +tt(LD_AOUT_LIBRARY_PATH), tt(LD_PRELOAD) and tt(LD_AOUT_PRELOAD) +parameters) +itemiz(specifying command names containing tt(/)) +itemiz(specifying command pathnames using tt(hash)) +itemiz(redirecting output to files) +itemiz(using the tt(exec) builtin command to replace the shell with another +command) +itemiz(using tt(jobs -Z) to overwrite the shell process' argument and +environment space) +itemiz(using the tt(ARGV0) parameter to override tt(argv[0]) for external +commands) +itemiz(turning off restricted mode with tt(set +r) or tt(unsetopt +RESTRICTED)) +itemiz(specifying modules to be loaded with an explicitly given +pathname containing slashes) +enditemize() + +These restrictions are enforced after processing the startup files. The +startup files should set up tt(PATH) to point to a directory of commands +which can be safely invoked in the restricted environment. They may also +add further restrictions by disabling selected builtins. + +Restricted mode can also be activated any time by setting the +tt(RESTRICTED) option. This immediately enables all the restrictions +described above even if the shell still have not processed all startup +files. diff --git a/Doc/Zsh/seealso.yo b/Doc/Zsh/seealso.yo new file mode 100644 index 000000000..8289e6628 --- /dev/null +++ b/Doc/Zsh/seealso.yo @@ -0,0 +1,25 @@ +texinode(See Also)()(The Zsh Web Page)(Introduction) +sect(See Also) +manref(sh)(1), +manref(csh)(1), +manref(tcsh)(1), +manref(rc)(1), +manref(bash)(1), +manref(ksh)(1)\ +ifzshone(\ +, +zmanref(zshbuiltins), +zmanref(zshcompctl), +zmanref(zshexpn), +zmanref(zshmisc), +zmanref(zshmodules), +zmanref(zshoptions), +zmanref(zshparam), +zmanref(zshzle)\ +)\ + + +bf(IEEE Standard for information Technology - +Portable Operating System Interface (POSIX) - +Part 2: Shell and Utilities), +IEEE Inc, 1993, ISBN 1-55937-255-9. diff --git a/Doc/Zsh/zle.yo b/Doc/Zsh/zle.yo new file mode 100644 index 000000000..fccf538bd --- /dev/null +++ b/Doc/Zsh/zle.yo @@ -0,0 +1,1076 @@ +texinode(Zsh Line Editor)(Programmable Completion)(Shell Builtin Commands)(Top) +chapter(Zsh Line Editor) +cindex(line editor) +cindex(editor, line) +sect(Description) +pindex(ZLE, use of) +If the tt(ZLE) option is set (it is by default) +and the shell input is attached to the terminal, the user +is allowed to edit command lines. + +There are two display modes. The first, multiline mode, is the +default. It only works if the tt(TERM) parameter is set to a valid +terminal type that can move the cursor up. The second, single line +mode, is used if tt(TERM) is invalid or incapable of moving the +cursor up, or if the tt(SINGLE_LINE_ZLE) option is set. +pindex(SINGLE_LINE_ZLE, use of) +cindex(ksh, editor mode) +cindex(editor ksh style) +This mode +is similar to bf(ksh), and uses no termcap sequences. If tt(TERM) is +"emacs", the tt(ZLE) option will be unset by default. +sect(Keymaps) +cindex(keymaps) +cindex(key bindings) +cindex(bindings, key) +A keymap in ZLE contains a set of bindings between key sequences +and ZLE commands. The empty key sequence cannot be bound. + +There can be any number of keymaps at any time, and each keymap has one +or more names. If all of a keymap's names are deleted, it disappears. +findex(bindkey, use of) +tt(bindkey) can be used to manipulate keymap names. + +Initially, there are four keymaps: + +startsitem() +sitem(tt(emacs))(EMACS emulation) +sitem(tt(viins))(vi emulation - insert mode) +sitem(tt(vicmd))(vi emulation - command mode) +sitem(tt(.safe))(fallback keymap) +endsitem() + +The `tt(.safe)' keymap is special. It can never be altered, and the name +can never be removed. However, it can be linked to other names, which can +be removed. In the future other special keymaps may be added; users should +avoid using names beginning with `tt(.)' for their own keymaps. + +vindex(VISUAL) +vindex(EDITOR) +In addition to these four names, either `tt(emacs)' or `tt(viins)' is +also linked to the name `tt(main)'. If one of the tt(VISUAL) or +tt(EDITOR) environment variables contain the string `tt(vi)' when the shell +starts up then it will be `tt(viins)', otherwise it will be `tt(emacs)'. +tt(bindkey)'s tt(-e) and tt(-v) +options provide a convenient way to override this default choice. + +When the editor starts up, it will select the `tt(main)' keymap. +If that keymap doesn't exist, it will use `tt(.safe)' instead. + +In the `tt(.safe)' keymap, each single key is bound to tt(self-insert), +except for ^J (line feed) and ^M (return) which are bound to tt(accept-line). +This is deliberately not pleasant to use; if you are using it, it +means you deleted the main keymap, and you should put it back. +subsect(Reading Commands) +When ZLE is reading a command from the terminal, it may read a sequence +that is bound to some command and is also a prefix of a longer bound string. +In this case ZLE will wait a certain time to see if more characters +are typed, and if not (or they don't match any longer string) it will +execute the binding. This timeout is defined by the tt(KEYTIMEOUT) parameter; +its default is 0.4 sec. No timeout is done if the prefix string is not bound. + +As well as ZLE commands, key sequences can be bound to other strings, by using +`tt(bindkey -s)'. +When such a sequence is read, the replacement string is pushed back as input, +and the command reading process starts again using these fake keystrokes. +This input can itself invoke further replacement strings, but in order to +detect loops the process will be stopped if there are twenty such replacements +without a real command being read. +sect(Widgets) +cindex(widgets) +All actions in the editor are performed by `widgets'. A widget's job is +simply to perform some small action. The ZLE commands that key sequences +in keymaps are bound to are in fact widgets. Widgets can be user-defined +or built in. + +There are 162 standard widgets built in to ZLE (see sectref(Standard Widgets)). +Other built-in widgets can be defined by other modules (see +ifzman(zmanref(zshmodules))\ +ifnzman(noderef(Zsh Modules))\ +). Each built-in widget has two names: its normal canonical name, and the +same name preceded by a `tt(.)'. The `tt(.)' name is special: it can't be +rebound to a different widget. This makes the widget available even when +its usual name has been redefined. + +User-defined widgets are defined using `tt(zle -N)', and implemented +as shell functions. When the widget is executed, the corresponding +shell function is executed, and can perform editing (or other) actions. +It is recommended that user-defined widgets should not have names +starting with `tt(.)'. +sect(User-Defined Widgets) +cindex(widgets, user-defined) +User-defined widgets, being implemented as shell functions, +can execute any normal shell command. They can also run other widgets +(whether built-in or user-defined) using the tt(zle) builtin command. +Finally, they can examine and edit the ZLE buffer being edited by +reading and setting the special parameters described below. + +cindex(parameters, editor) +cindex(parameters, zle) +These special parameters are always available in widget functions, but +are not in any way special outside ZLE. If they have some normal value +outside ZLE, that value is temporarily inaccessible, but will return +when the widget function exits. These special parameters in fact have +local scope, like parameters created in a function using tt(local). + +startitem() +vindex(BUFFER) +item(tt(BUFFER) (scalar))( +The entire contents of the edit buffer. If it is written to, the +cursor remains at the same offset, unless that would put it outside the +buffer. +) +vindex(CURSOR) +item(tt(CURSOR) (integer))( +The offset of the cursor, within the edit buffer. This is in the range +0 to tt($#BUFFER), and is by definition equal to tt($#LBUFFER). +Attempts to move the cursor outside the buffer will result in the +cursor being moved to the appropriate end of the buffer. +) +vindex(LBUFFER) +item(tt(LBUFFER) (scalar))( +The part of the buffer that lies to the left of the cursor position. +If it is assigned to, only that part of the buffer is replaced, and the +cursor remains between the new tt($LBUFFER) and the old tt($RBUFFER). +) +vindex(RBUFFER) +item(tt(RBUFFER) (scalar))( +The part of the buffer that lies to the right of the cursor position. +If it is assigned to, only that part of the buffer is replaced, and the +cursor remains between the old tt($LBUFFER) and the new tt($RBUFFER). +) +enditem() +sect(Standard Widgets) +cindex(widgets, standard) +The following is a list of all the standard widgets, +and their default bindings in emacs mode, +vi command mode and vi insert mode +(the `tt(emacs)', `tt(vicmd)' and `tt(viins)' keymaps, respectively). +startmenu() +menu(Movement) +menu(History Control) +menu(Modifying Text) +menu(Arguments) +menu(Completion) +menu(Miscellaneous) +endmenu() +texinode(Movement)(History Control)()(Zsh Line Editor) +subsect(Movement) +startitem() +tindex(vi-backward-blank-word) +item(tt(vi-backward-blank-word) (unbound) (B) (unbound))( +Move backward one 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))( +Move backward one character. +) +tindex(vi-backward-char) +item(tt(vi-backward-char) (unbound) (^H h ^?) (unbound))( +Move backward one character, without changing lines. +) +tindex(backward-word) +item(tt(backward-word) (ESC-B ESC-b) (unbound) (unbound))( +Move to the beginning of the previous word. +) +tindex(emacs-backward-word) +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))( +Move to the beginning of the previous word, vi-style. +) +tindex(beginning-of-line) +item(tt(beginning-of-line) (^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. +) +tindex(vi-beginning-of-line) +item(tt(vi-beginning-of-line))( +Move to the beginning of the line, without changing lines. +) +tindex(end-of-line) +item(tt(end-of-line) (^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))( +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))( +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))( +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))( +Move forward one character. +) +tindex(vi-forward-char) +item(tt(vi-forward-char) (unbound) (space l) (unbound))( +Move forward one character. +) +tindex(vi-find-next-char) +item(tt(vi-find-next-char) (^X^F) (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))( +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))( +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))( +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))( +Move to the first non-blank character in the line. +) +tindex(vi-forward-word) +item(tt(vi-forward-word) (unbound) (w) (unbound))( +Move forward one word, vi-style. +) +tindex(forward-word) +item(tt(forward-word) (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. +) +tindex(emacs-forward-word) +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))( +Move to the end of the next word. +) +tindex(vi-goto-column) +item(tt(vi-goto-column) (ESC-|) (|) (unbound))( +Move to the column specified by the numeric argument. +) +tindex(vi-goto-mark) +item(tt(vi-goto-mark) (unbound) (`) (unbound))( +Move to the specified mark. +) +tindex(vi-goto-mark-line) +item(tt(vi-goto-mark-line) (unbound) (') (unbound))( +Move to beginning of the line containing the specified mark. +) +tindex(vi-repeat-find) +item(tt(vi-repeat-find) (unbound) (;) (unbound))( +Repeat the last tt(vi-find) command. +) +tindex(vi-rev-repeat-find) +item(tt(vi-rev-repeat-find) (unbound) (,) (unbound))( +Repeat the last tt(vi-find) command in the opposite direction. +) +enditem() +texinode(History Control)(Modifying Text)(Movement)(Zsh Line Editor) +subsect(History Control) +startitem() +tindex(beginning-of-buffer-or-history) +item(tt(beginning-of-buffer-or-history) (ESC-<) (unbound) (unbound))( +Move to the beginning of the buffer, or if already there, +move to the first event in the history list. +) +tindex(beginning-of-line-hist) +item(tt(beginning-of-line-hist))( +Move to the beginning of the line. If already at the +beginning of the buffer, move to the previous history line. +) +tindex(beginning-of-history) +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) (unbound))( +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))( +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. +) +tindex(down-line-or-search) +item(tt(down-line-or-search))( +Move down a line in the buffer, or if already at the bottom line, +search forward in the history for a line beginning with the first +word in the buffer. +) +tindex(down-history) +item(tt(down-history) (unbound) (^N) (unbound))( +Move to the next event in the history list. +) +tindex(history-beginning-search-backward) +item(tt(history-beginning-search-backward))( +Search backward in the history for a line beginning with the current +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))( +Move to the end of the buffer, or if already there, +move to the last event in the history list. +) +tindex(end-of-line-hist) +item(tt(end-of-line-hist))( +Move to the end of the line. If already at the end of +the buffer, move to the next history line. +) +tindex(end-of-history) +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))( +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))( +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 +search to the beginning of the line. + +A restricted set of editing functions +is available in the mini-buffer. An interrupt signal, as defined by the stty +setting, will stop the search and go back to the original line. An undefined +key will have the same effect. The supported functions are: +tt(backward-delete-char), +tt(vi-backward-delete-char), +tt(clear-screen), +tt(redisplay), +tt(quoted-insert), +tt(vi-quoted-insert), +tt(accept-and-hold), +tt(accept-and-infer-next-history), +tt(accept-line) and +tt(accept-line-and-down-history). + +tt(magic-space) just inserts a space. +tt(vi-cmd-mode) toggles between the `tt(main)' and `tt(vicmd)' keymaps; +the `tt(main)' keymap (insert mode) will be selected initially. +tt(history-incremental-search-backward) will get the +next occurrence of the contents of the mini-buffer. +tt(history-incremental-search-forward) inverts the sense of the search. +tt(vi-repeat-search) and tt(vi-rev-repeat-search) are similarly supported. +The direction of the search is indicated in the mini-buffer. + +Any multi-character string +that is not bound to one of the above functions will beep and interrupt the +search, leaving the last found line in the buffer. Any single character that +is not bound to one of the above functions, or tt(self-insert) or +tt(self-insert-unmeta), will have the same effect but the function will be +executed. +) +tindex(history-incremental-search-forward) +item(tt(history-incremental-search-forward) (^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 +search to the beginning of the line. The functions available in the +mini-buffer are the same as for tt(history-incremental-search-backward). +) +tindex(history-search-backward) +item(tt(history-search-backward) (ESC-P ESC-p) (unbound) (unbound))( +Search backward in the history for a line beginning with the first +word in the buffer. +) +tindex(vi-history-search-backward) +item(tt(vi-history-search-backward) (unbound) (/) (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. + +A restricted set of editing functions is available in +the mini-buffer. An interrupt signal, as defined by the stty setting, will +stop the search. +The functions available in the mini-buffer are: +tt(accept-line), +tt(backward-delete-char), +tt(vi-backward-delete-char), +tt(backward-kill-word), +tt(vi-backward-kill-word), +tt(clear-screen), +tt(redisplay), +tt(quoted-insert) +and +tt(vi-quoted-insert). + +tt(vi-cmd-mode) is treated the same as accept-line, and +tt(magic-space) is treated as a space. +Any other character that is not bound to self-insert or +self-insert-unmeta will beep and be ignored. If the function is called from vi +command mode, the bindings of the current insert mode will be used. +) +tindex(history-search-forward) +item(tt(history-search-forward) (ESC-N ESC-n) (unbound) (unbound))( +Search forward in the history for a line beginning with the first +word in the buffer. +) +tindex(vi-history-search-forward) +item(tt(vi-history-search-forward) (unbound) (?) (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 +as for tt(vi-history-search-backward). +) +tindex(infer-next-history) +item(tt(infer-next-history) (^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))( +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. +If the argument is zero or negative insert that word from the +left (zero inserts the previous command word). +) +tindex(vi-repeat-search) +item(tt(vi-repeat-search) (unbound) (n) (unbound))( +Repeat the last vi history search. +) +tindex(vi-rev-repeat-search) +item(tt(vi-rev-repeat-search) (unbound) (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) (unbound))( +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))( +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. +) +tindex(up-line-or-search) +item(tt(up-line-or-search))( +Move up a line in the buffer, or if already at the top line, +search backward in the history for a line beginning with the +first word in the buffer. +) +tindex(up-history) +item(tt(up-history) (unbound) (^P) (unbound))( +Move to the previous event in the history list. +) +tindex(history-beginning-search-forward) +item(tt(history-beginning-search-forward))( +Search forward in the history for a line beginning with the current +line up to the cursor. +This leaves the cursor in its original position. +) +enditem() +texinode(Modifying Text)(Arguments)(History Control)(Zsh Line Editor) +subsect(Modifying Text) +startitem() +tindex(vi-add-eol) +item(tt(vi-add-eol) (unbound) (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))( +Enter insert mode after the current cursor position, without changing lines. +) +tindex(backward-delete-char) +item(tt(backward-delete-char) (^H ^?) (unbound) (unbound))( +Delete the character behind the cursor. +) +tindex(vi-backward-delete-char) +item(tt(vi-backward-delete-char) (unbound) (X) (^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. +) +tindex(backward-delete-word) +item(tt(backward-delete-word))( +Delete the word behind the cursor. +) +tindex(backward-kill-line) +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))( +Kill the word behind the cursor. +) +tindex(vi-backward-kill-word) +item(tt(vi-backward-kill-word) (unbound) (unbound) (^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))( +Capitalize the current word and move past it. +) +tindex(vi-change) +item(tt(vi-change) (unbound) (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. +If the command is tt(vi-change), change the current line. +) +tindex(vi-change-eol) +item(tt(vi-change-eol) (unbound) (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))( +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))( +Copy the area from the cursor to the mark to the kill buffer. +) +tindex(copy-prev-word) +item(tt(copy-prev-word) (ESC-^_) (unbound) (unbound))( +Duplicate the word behind the cursor. +) +tindex(vi-delete) +item(tt(vi-delete) (unbound) (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. +) +tindex(delete-char) +item(tt(delete-char))( +Delete the character under the cursor. +) +tindex(vi-delete-char) +item(tt(vi-delete-char) (unbound) (x) (unbound))( +Delete the character under the cursor, +without going past the end of the line. +) +tindex(delete-word) +item(tt(delete-word))( +Delete the current word. +) +tindex(down-case-word) +item(tt(down-case-word) (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))( +Kill the current word. +) +tindex(gosmacs-transpose-chars) +item(tt(gosmacs-transpose-chars))( +Exchange the two characters behind the cursor. +) +tindex(vi-indent) +item(tt(vi-indent) (unbound) (>) (unbound))( +Indent a number of lines. +) +tindex(vi-insert) +item(tt(vi-insert) (unbound) (i) (unbound))( +Enter insert mode. +) +tindex(vi-insert-bol) +item(tt(vi-insert-bol) (unbound) (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))( +Join the current line with the next one. +) +tindex(kill-line) +item(tt(kill-line) (^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))( +Kill from the cursor back to wherever insert mode was last entered. +) +tindex(vi-kill-eol) +item(tt(vi-kill-eol) (unbound) (D) (unbound))( +Kill from the cursor to the end of the line. +) +tindex(kill-region) +item(tt(kill-region))( +Kill from the cursor to the mark. +) +tindex(kill-buffer) +item(tt(kill-buffer) (^X^K) (unbound) (unbound))( +Kill the entire buffer. +) +tindex(kill-whole-line) +item(tt(kill-whole-line) (^U) (unbound) (unbound))( +Kill the current line. +) +tindex(vi-match-bracket) +item(tt(vi-match-bracket) (^X^B) (%) (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))( +Open a line above the cursor and enter insert mode. +) +tindex(vi-open-line-below) +item(tt(vi-open-line-below) (unbound) (o) (unbound))( +Open a line below the cursor and enter insert mode. +) +tindex(vi-oper-swap-case) +item(tt(vi-oper-swap-case))( +Read a movement command from the keyboard, and swap +the case of all characters +from the cursor position to the endpoint of the movement. +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))( +Toggle between overwrite mode and insert mode. +) +tindex(vi-put-before) +item(tt(vi-put-before) (unbound) (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))( +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. +) +tindex(quoted-insert) +item(tt(quoted-insert) (^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))( +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))( +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))( +Quote the region from the cursor to the mark. +) +tindex(vi-replace) +item(tt(vi-replace) (unbound) (R) (unbound))( +Enter overwrite mode. +) +tindex(vi-repeat-change) +item(tt(vi-repeat-change) (unbound) (.) (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, +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))( +Replace the character under the cursor with a character +read from the keyboard. +) +tindex(self-insert) +item(tt(self-insert) (printable characters) (unbound) (printable characters and some control characters))( +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))( +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))( +Substitute the next characte+CHAR(r)(s). +) +tindex(vi-swap-case) +item(tt(vi-swap-case) (unbound) (~) (unbound))( +Swap the case of the character under the cursor and move past it. +) +tindex(transpose-chars) +item(tt(transpose-chars) (^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))( +Exchange the current word with the one before it. +) +tindex(vi-unindent) +item(tt(vi-unindent) (unbound) (<) (unbound))( +Unindent a number of lines. +) +tindex(up-case-word) +item(tt(up-case-word) (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))( +Insert the contents of the kill buffer at the cursor position. +) +tindex(yank-pop) +item(tt(yank-pop) (ESC-y) (unbound) (unbound))( +Remove the text just yanked, rotate the kill-ring, +and yank the new top. Only works following +tt(yank) or tt(yank-pop). +) +tindex(vi-yank) +item(tt(vi-yank) (unbound) (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))( +Copy the current line into the kill buffer. +) +tindex(vi-yank-eol) +item(tt(vi-yank-eol))( +Copy the region from the cursor position to the end of the line +into the kill buffer. +Arguably, this is what Y should do in vi, but it isn't what it actually does. +) +enditem() +texinode(Arguments)(Completion)(Modifying Text)(Zsh Line Editor) +subsect(Arguments) +startitem() +tindex(digit-argument) +item(tt(digit-argument) (ESC-0..ESC-9) (1-9) (unbound))( +Start a new numeric argument, or add to the current one. +See also tt(vi-digit-or-beginning-of-line). +) +tindex(neg-argument) +item(tt(neg-argument) (ESC--) (unbound) (unbound))( +Changes the sign of the following argument. +) +tindex(universal-argument) +item(tt(universal-argument))( +Multiply the argument of the next command by 4. Alternatively, if +this command is followed by an integer (positive or negative), use +that as the argument for the next command. Thus digits cannot be +repeated using this command. For example, if this command occurs +twice, followed immediately by tt(forward-char), move forward sixteen +spaces; if instead it is followed by tt(-2), then tt(forward-char), +move backward two spaces. +) +enditem() +texinode(Completion)(Miscellaneous)(Arguments)(Zsh Line Editor) +subsect(Completion) +startitem() +tindex(accept-and-menu-complete) +item(tt(accept-and-menu-complete))( +In a menu completion, insert the current completion into the buffer, +and advance to the next possible completion. +) +tindex(complete-word) +item(tt(complete-word))( +Attempt completion on the current word. +) +tindex(delete-char-or-list) +item(tt(delete-char-or-list) (^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. +) +tindex(expand-cmd-path) +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))( +Attempt shell expansion on the current word. +If that fails, +attempt completion. +) +tindex(expand-or-complete-prefix) +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))( +Perform history expansion on the edit buffer. +) +tindex(expand-word) +item(tt(expand-word) (^X*) (unbound) (unbound))( +Attempt shell expansion on the current word. +) +tindex(list-choices) +item(tt(list-choices) (ESC-^D) (^D =) (^D))( +List possible completions for the current word. +) +tindex(list-expand) +item(tt(list-expand) (^Xg ^XG) (^G) (^G))( +List the expansion of the current word. +) +tindex(magic-space) +item(tt(magic-space))( +Perform history expansion and insert a space into the +buffer. This is intended to be bound to space. +) +tindex(menu-complete) +pindex(MENU_COMPLETE, use of) +item(tt(menu-complete))( +Like tt(complete-word), except that menu completion is used. +See the tt(MENU_COMPLETE) option. +) +tindex(menu-expand-or-complete) +item(tt(menu-expand-or-complete))( +Like tt(expand-or-complete), except that menu completion is used. +) +tindex(reverse-menu-complete) +item(tt(reverse-menu-complete))( +Perform menu completion, like tt(menu-complete), except that if +a menu completion is already in progress, move to the em(previous) +completion rather than the next. +) +enditem() +texinode(Miscellaneous)()(Completion)(Zsh Line Editor) +subsect(Miscellaneous) +startitem() +tindex(accept-and-hold) +item(tt(accept-and-hold) (ESC-A ESC-a) (unbound) (unbound))( +Push the contents of the buffer on the buffer stack +and execute it. +) +tindex(accept-and-infer-next-history) +item(tt(accept-and-infer-next-history))( +Execute the contents of the buffer. +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))( +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))( +Execute the current line, and push the next history +event on the the buffer stack. +) +tindex(vi-cmd-mode) +item(tt(vi-cmd-mode) (^X^V) (unbound) (^[))( +Enter command mode; that is, select the `tt(vicmd)' keymap. +Yes, this is bound by default in emacs mode. +) +tindex(vi-caps-lock-panic) +item(tt(vi-caps-lock-panic))( +Hang until any lowercase key is pressed. +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))( +Clear the screen and redraw the prompt. +) +tindex(describe-key-briefly) +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))( +Exchange the cursor position with the position of the mark. +) +tindex(execute-named-cmd) +item(tt(execute-named-cmd) (ESC-x) (unbound) (unbound))( +Read the name of an editor command and +execute it. A restricted set of editing functions is available in the +mini-buffer. An interrupt signal, as defined by the stty setting, will +abort the function. The allowed functions are: +tt(backward-delete-char), +tt(vi-backward-delete-char), +tt(clear-screen), +tt(redisplay), +tt(quoted-insert), +tt(vi-quoted-insert), +tt(backward-kill-word), +tt(vi-backward-kill-word), +tt(kill-whole-line), +tt(vi-kill-line), +tt(backward-kill-line), +tt(list-choices), +tt(delete-char-or-list), +tt(complete-word), +tt(accept-line), +tt(expand-or-complete) and +tt(expand-or-complete-prefix). + +tt(kill-region) kills the last word, +and vi-cmd-mode is treated the same as accept-line. +The space and tab characters, if not bound to one of +these functions, will complete the name and then list the +possibilities if the tt(AUTO_LIST) option is set. +Any other character that is not bound to tt(self-insert) or +tt(self-insert-unmeta) will beep and be ignored. +The bindings of the current insert mode will be used. +) +tindex(execute-last-named-cmd) +item(tt(execute-last-named-cmd) (ESC-z) (unbound) (unbound))( +Redo the last function executed with tt(execute-named-cmd). +) +tindex(get-line) +item(tt(get-line) (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))( +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. +In either case, accept the current line. +The tt(INTERACTIVE_COMMENTS) option must be set +for this to have any usefulness. +) +tindex(vi-pound-insert) +item(tt(vi-pound-insert))( +If there is no # character at the beginning of the current line, +add one. If there is one, remove it. +The tt(INTERACTIVE_COMMENTS) option must be set +for this to have any usefulness. +) +tindex(push-input) +item(tt(push-input))( +Push the entire current multiline construct onto the buffer stack and +return to the top-level (tt(PS1)) prompt. +If the current parser construct is only a single line, this is exactly +like tt(push-line). +Next time the editor starts up or is popped with tt(get-line), the +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))( +Push the current buffer onto the buffer stack and clear +the buffer. +Next time the editor starts up, the buffer will be popped +off the top of the buffer stack and loaded into the editing +buffer. +) +tindex(push-line-or-edit) +item(tt(push-line-or-edit))( +At the top-level (tt(PS1)) prompt, equivalent to tt(push-line). +At a secondary (tt(PS2)) prompt, move the entire current multiline +construct into the editor buffer. +The latter is equivalent to tt(push-input) followed by tt(get-line). +) +tindex(redisplay) +item(tt(redisplay) (unbound) (^R) (^R))( +Redisplays the edit buffer. +) +tindex(send-break) +item(tt(send-break) (^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. +) +tindex(run-help) +item(tt(run-help) (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 var(man). +) +tindex(vi-set-buffer) +item(tt(vi-set-buffer) (unbound) (") (unbound))( +Specify a buffer to be used in the following command. +There are 35 buffers that can be specified: +the 26 `named' buffers tt("a) to tt("z) +and the nine `queued' buffers tt("1) to tt("9). The named buffers can also +be specified as tt("A) to tt("Z). + +When a buffer is specified for a cut command, the text being cut replaces +the previous contents of the specified buffer. If a named buffer +is specified using a capital, the newly cut text is appended to the buffer +instead of overwriting it. + +If no buffer is specified for a cut 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. +) +tindex(vi-set-mark) +item(tt(vi-set-mark) (unbound) (m) (unbound))( +Set the specified mark at the cursor position. +) +tindex(set-mark-command) +item(tt(set-mark-command) (^@) (unbound) (unbound))( +Set the mark at the cursor position. +) +tindex(spell-word) +item(tt(spell-word) (ESC-$ ESC-S ESC-s) (unbound) (unbound))( +Attempt spelling correction on the current word. +) +tindex(undefined-key) +item(tt(undefined-key))( +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) (unbound) (unbound))( +Incrementally undo the last text modification. +) +tindex(redo) +item(tt(redo))( +Incrementally redo undone text modifications. +) +tindex(vi-undo-change) +item(tt(vi-undo-change) (unbound) (u) (unbound))( +Undo the last text modification. +If repeated, redo the modification. +) +tindex(what-cursor-position) +item(tt(what-cursor-position) (^X=) (unbound) (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. +) +tindex(where-is) +item(tt(where-is))( +Read the name of an editor command and and print the listing of key +sequences that invoke the specified command. +) +tindex(which-command) +item(tt(which-command) (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). +) +tindex(vi-digit-or-beginning-of-line) +item(tt(vi-digit-or-beginning-of-line) (unbound) (0) (unbound))( +If the last command executed was a digit as part of an argument, +continue the argument. Otherwise, execute vi-beginning-of-line. +) +enditem() diff --git a/Doc/intro.ms b/Doc/intro.ms new file mode 100644 index 000000000..5024b9bfd --- /dev/null +++ b/Doc/intro.ms @@ -0,0 +1,2701 @@ +.nr PI 0 +.nr LL 6.5i +.de Ds +.DS I .5i +.ft C +.ps 9 +.vs 11 +.ss 11 +.. +.de De +.DE +.ft R +.ps +.vs +.ss +.. +.de Sh +.SH +\\$1 +.XS +\\$1 +.XE +.. +.nr HM 4i +.ce 99 +.ps 18 +.vs 20 +.ss 20 +\f3An Introduction to the Z Shell\fP + +.ps 14 +.vs 16 +.ss 16 +\f2Paul Falstad +pf@software.com + +Bas de Bakker +bas@phys.uva.nl\fP +.ce 0 +.nr HM 1i +.pn 1 +.bp +.\" This blank page on the reverse of the cover. +.sv |1i +.pn 1 +.bp +.TL +An Introduction to the Z Shell +.AU +Paul Falstad +pf@software.com +.AU +Bas de Bakker +bas@phys.uva.nl +.PP +.Sh "Introduction" +.PP +\fBzsh\fP is a shell designed for interactive use, although it is also +a powerful scripting language. Many of the useful features of bash, +ksh, and tcsh were incorporated into \fBzsh\fP; many original features were +added. This document details some of the unique features of \fBzsh\fP. It +assumes basic knowledge of the standard UNIX shells; the intent is to +show a reader already familiar with one of the other major shells what +makes \fBzsh\fP more useful or more powerful. This document is not at all +comprehensive; read the manual entry for a description of the shell +that is complete and concise, although somewhat overwhelming and +devoid of examples. +.PP +The text will frequently mention options that you can set to change +the behaviour of \fBzsh\fP. You can set these options with the +command +.Ds +%\0setopt\0\fIoptionname\fC +.De +and unset them again with +.Ds +%\0unsetopt\0\fIoptionname\fC +.De +Case is ignored in option names, as are embedded underscores. +.Sh "Filename Generation" +.PP +Otherwise known as \fIglobbing\fP, filename generation +is quite extensive in \fBzsh\fP. Of course, it has all the +basics: +.Ds +%\0ls +Makefile\0\0\0file.pro\0\0\0foo.o\0\0\0\0\0\0main.o\0\0\0\0\0q.c\0\0\0\0\0\0\0\0run234\0\0\0\0\0stuff +bar.o\0\0\0\0\0\0foo\0\0\0\0\0\0\0\0link\0\0\0\0\0\0\0morestuff\0\0run123\0\0\0\0\0run240\0\0\0\0\0sub +file.h\0\0\0\0\0foo.c\0\0\0\0\0\0main.h\0\0\0\0\0pipe\0\0\0\0\0\0\0run2\0\0\0\0\0\0\0run303 +%\0ls\0*.c +foo.c\0\0q.c +%\0ls\0*.[co] +bar.o\0\0\0foo.c\0\0\0foo.o\0\0\0main.o\0\0q.c +%\0ls\0foo.? +foo.c\0\0foo.o +%\0ls\0*.[^c] +bar.o\0\0\0file.h\0\0foo.o\0\0\0main.h\0\0main.o +%\0ls\0*.[^oh] +foo.c\0\0q.c +.De +Also, if the \fIEXTENDEDGLOB\fP option is set, +some new features are activated. +For example, the \fC^\fP character negates the pattern following it: +.Ds +%\0setopt\0extendedglob +%\0ls\0-d\0^*.c +Makefile\0\0\0file.pro\0\0\0link\0\0\0\0\0\0\0morestuff\0\0run2\0\0\0\0\0\0\0run303 +bar.o\0\0\0\0\0\0foo\0\0\0\0\0\0\0\0main.h\0\0\0\0\0pipe\0\0\0\0\0\0\0run234\0\0\0\0\0stuff +file.h\0\0\0\0\0foo.o\0\0\0\0\0\0main.o\0\0\0\0\0run123\0\0\0\0\0run240\0\0\0\0\0sub +%\0ls\0-d\0^*.* +Makefile\0\0\0link\0\0\0\0\0\0\0pipe\0\0\0\0\0\0\0run2\0\0\0\0\0\0\0run240\0\0\0\0\0stuff +foo\0\0\0\0\0\0\0\0morestuff\0\0run123\0\0\0\0\0run234\0\0\0\0\0run303\0\0\0\0\0sub +%\0ls\0-d\0^Makefile +bar.o\0\0\0\0\0\0foo\0\0\0\0\0\0\0\0link\0\0\0\0\0\0\0morestuff\0\0run123\0\0\0\0\0run240\0\0\0\0\0sub +file.h\0\0\0\0\0foo.c\0\0\0\0\0\0main.h\0\0\0\0\0pipe\0\0\0\0\0\0\0run2\0\0\0\0\0\0\0run303 +file.pro\0\0\0foo.o\0\0\0\0\0\0main.o\0\0\0\0\0q.c\0\0\0\0\0\0\0\0run234\0\0\0\0\0stuff +%\0ls\0-d\0*.^c +\&.rhosts\0\0\0bar.o\0\0\0\0\0file.h\0\0\0\0file.pro\0\0foo.o\0\0\0\0\0main.h\0\0\0\0main.o +.De +An expression of the form +\fC<\fIx\fR\-\fIy\fC>\fR +matches a range of integers: +.Ds +%\0ls\0run<200-300> +run234\0\0run240 +%\0ls\0run<300-400> +run303 +%\0ls\0run<-200> +run123\0\0run2 +%\0ls\0run<300-> +run303 +%\0ls\0run<> +run123\0\0run2\0\0\0\0run234\0\0run240\0\0run303 +.De +The \fINUMERICGLOBSORT\fP option will sort files with numbers +according to the number. This will not work with \fCls\fP as it +resorts its arguments: +.Ds +%\0setopt\0numericglobsort +%\0echo\0run<> +run2\0run123\0run234\0run240\0run303 +.De +Grouping is possible: +.Ds +%\0ls\0(foo|bar).* +bar.o\0\0foo.c\0\0foo.o +%\0ls\0*.(c|o|pro) +bar.o\0\0\0\0\0file.pro\0\0foo.c\0\0\0\0\0foo.o\0\0\0\0\0main.o\0\0\0\0q.c +.De +Also, the string \fC**/\fP forces a recursive search of +subdirectories: +.Ds +%\0ls\0-R +Makefile\0\0\0file.pro\0\0\0foo.o\0\0\0\0\0\0main.o\0\0\0\0\0q.c\0\0\0\0\0\0\0\0run234\0\0\0\0\0stuff +bar.o\0\0\0\0\0\0foo\0\0\0\0\0\0\0\0link\0\0\0\0\0\0\0morestuff\0\0run123\0\0\0\0\0run240\0\0\0\0\0sub +file.h\0\0\0\0\0foo.c\0\0\0\0\0\0main.h\0\0\0\0\0pipe\0\0\0\0\0\0\0run2\0\0\0\0\0\0\0run303 + +morestuff: + +stuff: +file\0\0xxx\0\0\0yyy + +stuff/xxx: +foobar + +stuff/yyy: +frobar +%\0ls\0**/*bar +stuff/xxx/foobar\0\0stuff/yyy/frobar +%\0ls\0**/f* +file.h\0\0\0\0\0\0\0\0\0\0\0\0foo\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0foo.o\0\0\0\0\0\0\0\0\0\0\0\0\0stuff/xxx/foobar +file.pro\0\0\0\0\0\0\0\0\0\0foo.c\0\0\0\0\0\0\0\0\0\0\0\0\0stuff/file\0\0\0\0\0\0\0\0stuff/yyy/frobar +%\0ls\0*bar* +bar.o +%\0ls\0**/*bar* +bar.o\0\0\0\0\0\0\0\0\0\0\0\0\0stuff/xxx/foobar\0\0stuff/yyy/frobar +%\0ls\0stuff/**/*bar* +stuff/xxx/foobar\0\0stuff/yyy/frobar +.De +.PP +It is possible to exclude certain files from the patterns using +the ~ character. A pattern of the form \fC*.c~bar.c\fP lists all +files matching \fC*.c\fP, except for the file \fCbar.c\fP. +.Ds +%\0ls\0*.c +foo.c\0\0\0\0foob.c\0\0\0\0bar.c +%\0ls\0*.c~bar.c +foo.c\0\0\0\0foob.c +%\0ls\0*.c~f* +bar.c +.De +.PP +One can add a number of \fIqualifiers\fP to the end of +any of these patterns, to restrict matches to certain +file types. A qualified pattern is of the form +.DS +\fIpattern\fC(\fR...\fC)\fR +.De +with single-character qualifiers inside the parentheses. +.Ds +%\0alias\0l='ls\0-dF' +%\0l\0* +Makefile\0\0\0\0foo*\0\0\0\0\0\0\0\0main.h\0\0\0\0\0\0q.c\0\0\0\0\0\0\0\0\0run240 +bar.o\0\0\0\0\0\0\0foo.c\0\0\0\0\0\0\0main.o\0\0\0\0\0\0run123\0\0\0\0\0\0run303 +file.h\0\0\0\0\0\0foo.o\0\0\0\0\0\0\0morestuff/\0\0run2\0\0\0\0\0\0\0\0stuff/ +file.pro\0\0\0\0link@\0\0\0\0\0\0\0pipe\0\0\0\0\0\0\0\0run234\0\0\0\0\0\0sub +%\0l\0*(/) +morestuff/\0\0stuff/ +%\0l\0*(@) +link@ +%\0l\0*(*) +foo*\0\0\0\0\0\0\0\0link@\0\0\0\0\0\0\0morestuff/\0\0stuff/ +%\0l\0*(x) +foo*\0\0\0\0\0\0\0\0link@\0\0\0\0\0\0\0morestuff/\0\0stuff/ +%\0l\0*(X) +foo*\0\0\0\0\0\0\0\0link@\0\0\0\0\0\0\0morestuff/\0\0stuff/ +%\0l\0*(R) +bar.o\0\0\0\0\0\0\0foo*\0\0\0\0\0\0\0\0link@\0\0\0\0\0\0\0morestuff/\0\0run123\0\0\0\0\0\0run240 +file.h\0\0\0\0\0\0foo.c\0\0\0\0\0\0\0main.h\0\0\0\0\0\0pipe\0\0\0\0\0\0\0\0run2\0\0\0\0\0\0\0\0run303 +file.pro\0\0\0\0foo.o\0\0\0\0\0\0\0main.o\0\0\0\0\0\0q.c\0\0\0\0\0\0\0\0\0run234\0\0\0\0\0\0stuff/ +.De +Note that \fC*(x)\fP and \fC*(*)\fP both match executables. +\fC*(X)\fP matches files executable by others, as opposed to +\fC*(x)\fP, which matches files executable by the owner. +\fC*(R)\fP and \fC*(r)\fP match readable files; +\fC*(W)\fP and \fC*(w)\fP, which checks for writable files. +\fC*(W)\fP is especially important, since it checks for world-writable +files: +.Ds +%\0l\0*(w) +bar.o\0\0\0\0\0\0\0foo*\0\0\0\0\0\0\0\0link@\0\0\0\0\0\0\0morestuff/\0\0run123\0\0\0\0\0\0run240 +file.h\0\0\0\0\0\0foo.c\0\0\0\0\0\0\0main.h\0\0\0\0\0\0pipe\0\0\0\0\0\0\0\0run2\0\0\0\0\0\0\0\0run303 +file.pro\0\0\0\0foo.o\0\0\0\0\0\0\0main.o\0\0\0\0\0\0q.c\0\0\0\0\0\0\0\0\0run234\0\0\0\0\0\0stuff/ +%\0l\0*(W) +link@\0\0\0run240 +%\0l\0-l\0link\0run240 +lrwxrwxrwx\0\01\0pfalstad\0\0\0\0\0\0\010\0May\023\018:12\0link\0->\0/usr/bin/ +-rw-rw-rw-\0\01\0pfalstad\0\0\0\0\0\0\0\00\0May\023\018:12\0run240 +.De +If you want to have all the files of a certain type as well as all +symbolic links pointing to files of that type, prefix the qualifier +with a \fC-\fP: +.Ds +%\0l\0*(-/) +link@\0\0\0\0\0\0\0morestuff/\0\0stuff/ +.De +You can filter out the symbolic links with the \fC^\fP character: +.Ds +%\0l\0*(W^@) +run240 +%\0l\0*(x) +foo*\0\0\0\0\0\0\0\0link@\0\0\0\0\0\0\0morestuff/\0\0stuff/ +%\0l\0*(x^@/) +foo* +.De +To find all plain files, you can use \fC.\fP: +.Ds +%\0l\0*(.) +Makefile\0\0file.h\0\0\0\0foo*\0\0\0\0\0\0foo.o\0\0\0\0\0main.o\0\0\0\0run123\0\0\0\0run234\0\0\0\0run303 +bar.o\0\0\0\0\0file.pro\0\0foo.c\0\0\0\0\0main.h\0\0\0\0q.c\0\0\0\0\0\0\0run2\0\0\0\0\0\0run240\0\0\0\0sub +%\0l\0*(^.) +link@\0\0\0\0\0\0\0morestuff/\0\0pipe\0\0\0\0\0\0\0\0stuff/ +%\0l\0s*(.) +stuff/\0\0\0sub +%\0l\0*(p) +pipe +%\0l\0-l\0*(p) +prw-r--r--\0\01\0pfalstad\0\0\0\0\0\0\0\00\0May\023\018:12\0pipe +.De +\fC*(U)\fP matches all files owned by you. +To search for all files not owned by you, use \fC*(^U)\fP: +.Ds +%\0l\0-l\0*(^U) +-rw-------\0\01\0subbarao\0\0\0\0\0\0\029\0May\023\018:13\0sub +.De +This searches for setuid files: +.Ds +%\0l\0-l\0*(s) +-rwsr-xr-x\0\01\0pfalstad\0\0\0\0\0\0\016\0May\023\018:12\0foo* +.De +This checks for a certain user's files: +.Ds +%\0l\0-l\0*(u[subbarao]) +-rw-------\0\01\0subbarao\0\0\0\0\0\0\029\0May\023\018:13\0sub +.De +.Sh "Startup Files" +.PP +There are five startup files that \fBzsh\fP will read commands from: +.Ds +$ZDOTDIR/.zshenv +$ZDOTDIR/.zprofile +$ZDOTDIR/.zshrc +$ZDOTDIR/.zlogin +$ZDOTDIR/.zlogout +.De +If \fBZDOTDIR\fP is not set, then the value of \fBHOME\fP is used; +this is the usual case. +.\".KE <--- missing .KS or .KF above +.PP +\&\fC.zshenv\fP is sourced on all invocations of the shell, +unless the \fC-f\fP option is set. It should contain commands to set +the command search path, plus other important environment +variables. +\&\fC.zshenv\fP should not contain commands that produce output +or assume the shell is attached to a tty. +.PP +\&\fC.zshrc\fP is sourced in interactive shells. It should contain +commands to set up aliases, functions, options, key bindings, etc. +.PP +\&\fC.zlogin\fP is sourced in login shells. It should contain +commands that should be executed only in login shells. +\&\fC.zlogout\fP is sourced when login shells exit. +\&\fC.zprofile\fP is similar to \fC.zlogin\fP, except that it is sourced before +\&\fC.zshrc\fP. +\&\fC.zprofile\fP is meant as an alternative to \fC.zlogin\fP for +ksh fans; +the two are not intended to be used together, although this +could certainly be done if desired. +\&\fC.zlogin\fP is not the place for alias definitions, options, environment +variable settings, etc.; +as a general rule, it should not change the shell environment +at all. Rather, it should be used to set the terminal type +and run a series of external commands (\fCfortune\fP, \fCmsgs\fP, etc). +.Sh "Shell Functions" +.PP +\fBzsh\fP also allows you to create your own commands by defining shell +functions. For example: +.Ds +%\0yp\0()\0{ +>\0\0\0\0\0\0\0ypmatch\0$1\0passwd.byname +>\0} +%\0yp\0pfalstad +pfalstad:*:3564:35:Paul\0John\0Falstad:/u/pfalstad:/usr/princeton/bin/zsh +.De +This function looks up a user in the NIS password map. +The \fC$1\fP expands to the first argument to \fCyp\fP. +The function could have been equivalently defined in one of the following +ways: +.Ds +%\0function\0yp\0{ +>\0\0\0\0\0\0\0ypmatch\0$1\0passwd.byname +>\0} +%\0function\0yp\0()\0{ +>\0\0\0\0\0\0\0ypmatch\0$1\0passwd.byname +>\0} +%\0function\0yp\0()\0ypmatch\0$1\0passwd.byname +.De +Note that aliases are expanded when the function definition is +parsed, not when the function is executed. For example: +.Ds +%\0alias\0ypmatch=echo +%\0yp\0pfalstad +pfalstad:*:3564:35:Paul\0John\0Falstad:/u/pfalstad:/usr/princeton/bin/zsh +.De +Since the alias was defined after the function was parsed, it has +no effect on the function's execution. +However, if we define the function again with the alias in place: +.Ds +%\0function\0yp\0()\0{\0ypmatch\0$1\0passwd.byname\0} +%\0yp\0pfalstad +pfalstad\0passwd.byname +.De +it is parsed with the new alias definition in place. +Therefore, in general you must define aliases before functions. +.\".KE <--- missing .KS or .KF above +.PP +We can make the function take multiple arguments: +.Ds +%\0unalias\0ypmatch +%\0yp\0()\0{ +>\0\0\0\0\0\0\0for\0i +>\0\0\0\0\0\0\0do\0ypmatch\0$i\0passwd.byname +>\0\0\0\0\0\0\0done +>\0} +%\0yp\0pfalstad\0subbarao\0sukthnkr +pfalstad:*:3564:35:Paul\0John\0Falstad:/u/pfalstad:/usr/princeton/bin/zsh +subbarao:*:3338:35:Kartik\0Subbarao:/u/subbarao:/usr/princeton/bin/zsh +sukthnkr:*:1267:35:Rahul\0Sukthankar:/u/sukthnkr:/usr/princeton/bin/tcsh +.De +The \fCfor i\fP loops through each of the function's arguments, +setting \fCi\fP equal to each of them in turn. +We can also make the function do something sensible +if no arguments are given: +.Ds +%\0yp\0()\0{ +>\0\0\0\0\0\0\0if\0((\0$#\0==\00\0)) +>\0\0\0\0\0\0\0then\0echo\0usage:\0yp\0name\0...;\0fi +>\0\0\0\0\0\0\0for\0i;\0do\0ypmatch\0$i\0passwd.byname;\0done +>\0} +%\0yp +usage:\0yp\0name\0... +%\0yp\0pfalstad\0sukthnkr +pfalstad:*:3564:35:Paul\0John\0Falstad:/u/pfalstad:/usr/princeton/bin/zsh +sukthnkr:*:1267:35:Rahul\0Sukthankar:/u/sukthnkr:/usr/princeton/bin/tcsh +.De +\fC$#\fP is the number of arguments supplied to the function. +If it is equal to zero, we print a usage message; otherwise, +we loop through the arguments, and \fCypmatch\fP all of them. +.\".KE <--- missing .KS or .KF above +.PP +Here's a function that selects a random line from a file: +.Ds +%\0randline\0()\0{ +>\0\0\0\0\0\0\0integer\0z=$(wc\0-l\0<$1) +>\0\0\0\0\0\0\0sed\0-n\0$[RANDOM\0%\0z\0+\01]p\0$1 +>\0} +%\0randline\0/etc/motd +PHOENIX\0WILL\0BE\0DOWN\0briefly\0Friday\0morning,\05/24/91\0from\08\0AM\0to +%\0randline\0/etc/motd +SunOS\0Release\04.1.1\0(PHOENIX)\0#19:\0Tue\0May\014\019:03:15\0EDT\01991 +%\0randline\0/etc/motd +|\0Please\0use\0the\0"msgs"\0command\0to\0read\0announcements.\0\0Refer\0to\0the\0\0\0| +%\0echo\0$z + +% +.De +\fCrandline\fP has a local variable, \fCz\fP, that holds the number of +lines in the file. \fC$[RANDOM % z + 1]\fP expands to a random number +between 1 and \fCz\fP. An expression of the form \fC$[\fR...\fC]\fR +expands to the value of the arithmetic expression within the brackets, +and the \fBRANDOM\fP variable returns a random number each time it +is referenced. \fC%\fP is the modulus operator, as in C. +Therefore, \fCsed -n $[RANDOM%z+1]p\fP picks a random line from its +input, from 1 to \fCz\fP. +.PP +Function definitions can be viewed with the \fCfunctions\fP builtin: +.Ds +%\0functions\0randline +randline\0()\0{ +\0\0\0\0\0\0\0\0integer\0z=$(wc\0-l\0<$1) +\0\0\0\0\0\0\0\0sed\0-n\0$[RANDOM\0%\0z\0+\01]p\0$1 + +} +%\0functions +yp\0()\0{ +\0\0\0\0\0\0\0\0if\0let\0$#\0==\00\0 +\0\0\0\0\0\0\0\0 +\0\0\0\0\0\0\0\0then +\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0echo\0usage:\0yp\0name\0... +\0\0\0\0\0\0\0\0 +\0\0\0\0\0\0\0\0fi +\0\0\0\0\0\0\0\0for\0i +\0\0\0\0\0\0\0\0do +\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0ypmatch\0$i\0passwd.byname +\0\0\0\0\0\0\0\0 +\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0done + +} +randline\0()\0{ +\0\0\0\0\0\0\0\0integer\0z=$(wc\0-l\0<$1) +\0\0\0\0\0\0\0\0sed\0-n\0$[RANDOM\0%\0z\0+\01]p\0$1 + +} +.De +Here's another one: +.Ds +%\0cx\0()\0{\0chmod\0+x\0$*\0} +%\0ls\0-l\0foo\0bar +-rw-r--r--\0\01\0pfalstad\0\0\0\0\0\0\029\0May\024\004:38\0bar +-rw-r--r--\0\01\0pfalstad\0\0\0\0\0\0\029\0May\024\004:38\0foo +%\0cx\0foo\0bar +%\0ls\0-l\0foo\0bar +-rwxr-xr-x\0\01\0pfalstad\0\0\0\0\0\0\029\0May\024\004:38\0bar +-rwxr-xr-x\0\01\0pfalstad\0\0\0\0\0\0\029\0May\024\004:38\0foo +.De +Note that this could also have been implemented as an alias: +.Ds +%\0chmod\0644\0foo\0bar +%\0alias\0cx='chmod\0+x' +%\0cx\0foo\0bar +%\0ls\0-l\0foo\0bar +-rwxr-xr-x\0\01\0pfalstad\0\0\0\0\0\0\029\0May\024\004:38\0bar +-rwxr-xr-x\0\01\0pfalstad\0\0\0\0\0\0\029\0May\024\004:38\0foo +.De +.PP +Instead of defining a lot of functions in your \fC.zshrc\fP, +all of which you may not use, +it is often better to use the \fCautoload\fP builtin. +The idea is, you create a directory where function +definitions are stored, declare the names in +your \fC.zshrc\fP, and tell the shell where to look for them. +Whenever you reference a function, the shell +will automatically load it into memory. +.Ds +%\0mkdir\0/tmp/funs +%\0cat\0>/tmp/funs/yp +ypmatch\0$1\0passwd.byname +^D +%\0cat\0>/tmp/funs/cx +chmod\0+x\0$* +^D +%\0FPATH=/tmp/funs +%\0autoload\0cx\0yp +%\0functions\0cx\0yp +undefined\0cx\0() +undefined\0yp\0() +%\0chmod\0755\0/tmp/funs/{cx,yp} +%\0yp\0egsirer +egsirer:*:3214:35:Emin\0Gun\0Sirer:/u/egsirer:/bin/sh +%\0functions\0yp +yp\0()\0{ +\0\0\0\0\0\0\0\0ypmatch\0$1\0passwd.byname +} +.De +This idea has other benefits. By adding a \fC#!\fP header +to the files, you can make them double as shell scripts. +(Although it is faster to use them as functions, since a +separate process is not created.) +.Ds +%\0ed\0/tmp/funs/yp +25 +i +#!\0/usr/local/bin/zsh +. +w +42 +q +%\0</tmp/funs/yp +#!\0/usr/local/bin/zsh +ypmatch\0$1\0passwd.byname +%\0/tmp/funs/yp\0sukthnkr +sukthnkr:*:1267:35:Rahul\0Sukthankar:/u/sukthnkr:/usr/princeton/bin/tcsh +.De +Now other people, who may not use \fBzsh\fP, or who don't want to +copy all of your \fC.zshrc\fP, may use these functions as shell +scripts. +.Sh "Directories" +.PP +One nice feature of \fBzsh\fP is the way it prints directories. +For example, if we set the prompt like this: +.Ds +phoenix%\0PROMPT='%~>\0' +~>\0cd\0src +~/src> +.De +the shell will print the current directory in the prompt, +using the \fC~\fP character. +However, \fBzsh\fP is smarter than most other shells in this respect: +.Ds +~/src>\0cd\0~subbarao +~subbarao>\0cd\0~maruchck +~maruchck>\0cd\0lib +~maruchck/lib>\0cd\0fun +~maruchck/lib/fun>\0foo=/usr/princeton/common/src +~maruchck/lib/fun>\0cd\0~foo +~foo>\0cd\0.. +/usr/princeton/common>\0cd\0src +~foo>\0cd\0news/nntp +~foo/news/nntp>\0cd\0inews +~foo/news/nntp/inews> +.De +Note that \fBzsh\fP prints \fIother\fP users' directories +in the form \fC~user\fP. Also note that you can +set a parameter and use it as a directory name; +\fBzsh\fP will act as if \fCfoo\fP is a user +with the login directory \fC/usr/princeton/common/src\fP. +This is convenient, especially if you're sick of seeing +prompts like this: +.Ds +phoenix:/usr/princeton/common/src/X.V11R4/contrib/clients/xv/docs> +.De +If you get stuck in this position, you can give the current +directory a short name, like this: +.Ds +/usr/princeton/common/src/news/nntp/inews>\0inews=$PWD +/usr/princeton/common/src/news/nntp/inews>\0echo\0~inews +/usr/princeton/common/src/news/nntp/inews +~inews> +.De +When you reference a directory in the form \fC~inews\fP, +the shell assumes that you want the directory displayed +in this form; thus simply typing \fCecho ~inews\fP or +\fCcd ~inews\fP causes the prompt to be shortened. +You can define a shell function for this purpose: +.Ds +~inews>\0namedir\0()\0{\0$1=$PWD\0;\0\0:\0~$1\0} +~inews>\0cd\0/usr/princeton/bin +/usr/princeton/bin>\0namedir\0pbin +~pbin>\0cd\0/var/spool/mail +/var/spool/mail>\0namedir\0spool +~spool>\0cd\0.msgs +~spool/.msgs> +.De +You may want to add this one-line function to your \fC.zshrc\fP. + +\fBzsh\fP can also put the current directory in your title bar, +if you are using a windowing system. +One way to do this is with the \fCchpwd\fP function, which is +automatically executed by the shell whenever you change +directory. If you are using xterm, this will work: +.Ds +chpwd\0()\0{\0print\0-Pn\0'^[]2;%~^G'\0} +.De +The \fC-P\fP option tells \fCprint\fP to treat its arguments like a prompt +string; otherwise the \fC%~\fP would not be expanded. +The \fC-n\fP option suppresses the terminating newline, as with \fCecho\fP. +.PP +If you are using an IRIS \fCwsh\fP, do this: +.Ds +chpwd\0()\0{\0print\0-Pn\0'\e2201.y%~\e234'\0} +.De +The \fCprint -D\fP command has other uses. For example, to +print the current directory to standard output in short form, +you can do this: +.Ds +%\0print\0-D\0$PWD +~subbarao/src +.De +and to print each component of the path in short form: +.Ds +%\0print\0-D\0$path +/bin\0/usr/bin\0~locbin\0~locbin/X11\0~/bin +.De +.Sh "Directory Stacks" +.PP +If you use csh, you may know about directory stacks. +The \fCpushd\fP command puts the current directory on the +stack, and changes to a new directory; the \fCpopd\fP command +pops a directory off the stack and changes to it. +.Ds +phoenix%\0cd\0 +phoenix%\0PROMPT='Z\0%~>\0' +Z\0~>\0pushd\0/tmp +/tmp\0~ +Z\0/tmp>\0pushd\0/usr/etc +/usr/etc\0/tmp\0~ +Z\0/usr/etc>\0pushd\0/usr/bin +/usr/bin\0/usr/etc\0/tmp\0~ +Z\0/usr/bin>\0popd +/usr/etc\0/tmp\0~ +Z\0/usr/etc>\0popd +/tmp\0~ +Z\0/tmp>\0pushd\0/etc +/etc\0/tmp\0~ +Z\0/etc>\0popd\0 +/tmp\0~ +.De +\fBzsh\fP's directory stack commands work similarly. One +difference is the way \fCpushd\fP is handled if no arguments +are given. As in csh, this exchanges the top two elements +of the directory stack: +.Ds +Z\0/tmp>\0dirs +/tmp\0~ +Z\0/tmp>\0pushd +~\0/tmp +.De +unless the stack only has one entry: +.Ds +Z\0~>\0popd +/tmp +Z\0/tmp>\0dirs +/tmp +Z\0/tmp>\0pushd +~\0/tmp +Z\0~> +.De +or unless the \fIPUSHDTOHOME\fP option is set: +.Ds +Z\0~>\0setopt\0pushdtohome +Z\0~>\0pushd +~\0~\0/tmp +.De +.PP +As an alternative to using directory stacks in this manner, +we can get something like a \fIdirectory history\fP +by setting a few more options and parameters: +.Ds +~>\0DIRSTACKSIZE=8 +~>\0setopt\0autopushd\0pushdminus\0pushdsilent\0pushdtohome +~>\0alias\0dh='dirs\0-v' +~>\0cd\0/tmp +/tmp>\0cd\0/usr +/usr>\0cd\0bin +/usr/bin>\0cd\0../pub +/usr/pub>\0dh +0\0\0\0\0\0\0\0/usr/pub +1\0\0\0\0\0\0\0/usr/bin +2\0\0\0\0\0\0\0/usr +3\0\0\0\0\0\0\0/tmp +4\0\0\0\0\0\0\0~ +/usr/pub>\0cd\0-3 +/tmp>\0dh +0\0\0\0\0\0\0\0/tmp +1\0\0\0\0\0\0\0/usr/pub +2\0\0\0\0\0\0\0/usr/bin +3\0\0\0\0\0\0\0/usr +4\0\0\0\0\0\0\0~ +/tmp>\0ls\0=2/df +/usr/bin/df +/tmp>\0cd\0-4 +~> +.De +Note that \fC=2\fP expanded to the second directory in the +history list, and that \fCcd -3\fP recalled the third +directory in the list. +.PP +You may be wondering what all those options do. +\fIAUTOPUSHD\fP made \fCcd\fP act like \fCpushd\fP. +(\fCalias cd=pushd\fP is not sufficient, for various reasons.) +\fIPUSHDMINUS\fP swapped the meaning of \fCcd +1\fP and +\fCcd -1\fP; we want them to mean the opposite of what they mean in csh, +because it makes more sense in this scheme, and it's easier to type: +.Ds +~>\0dh +0\0\0\0\0\0\0\0~ +1\0\0\0\0\0\0\0/tmp +2\0\0\0\0\0\0\0/usr/pub +3\0\0\0\0\0\0\0/usr/bin +4\0\0\0\0\0\0\0/usr +~>\0unsetopt\0pushdminus +~>\0cd\0+1 +/tmp>\0dh +0\0\0\0\0\0\0\0/tmp +1\0\0\0\0\0\0\0~ +2\0\0\0\0\0\0\0/usr/pub +3\0\0\0\0\0\0\0/usr/bin +4\0\0\0\0\0\0\0/usr +/tmp>\0cd\0+2 +/usr/pub> +.De +\fIPUSHDSILENT\fP keeps the shell from printing +the directory stack each time we do a \fCcd\fP, +and \fIPUSHDTOHOME\fP we mentioned earlier: +.Ds +/usr/pub>\0unsetopt\0pushdsilent +/usr/pub>\0cd\0/etc +/etc\0/usr/pub\0/tmp\0~\0/usr/bin\0/usr +/etc>\0cd +~\0/etc\0/usr/pub\0/tmp\0~\0/usr/bin\0/usr +~>\0unsetopt\0pushdtohome +~>\0cd +/etc\0~\0/usr/pub\0/tmp\0~\0/usr/bin\0/usr +/etc> +.De +\fBDIRSTACKSIZE\fP keeps the directory stack +from getting too large, much like \fIHISTSIZE\fP: +.Ds +/etc>\0setopt\0pushdsilent +/etc>\0cd\0/ +/>\0cd\0/ +/>\0cd\0/ +/>\0cd\0/ +/>\0cd\0/ +/>\0cd\0/ +/>\0cd\0/ +/>\0cd\0/ +/>\0dh +0\0\0\0\0\0\0\0/ +1\0\0\0\0\0\0\0/ +2\0\0\0\0\0\0\0/ +3\0\0\0\0\0\0\0/ +4\0\0\0\0\0\0\0/ +5\0\0\0\0\0\0\0/ +6\0\0\0\0\0\0\0/ +7\0\0\0\0\0\0\0/ +.De +.Sh "Command/Process Substitution" +.PP +Command substitution in \fBzsh\fP can take two forms. +In the traditional form, a command enclosed in +backquotes (\fC`\fP...\fC`\fP) is replaced on the command line with its output. +This is the form used by the older shells. +Newer shells (like \fBzsh\fP) also provide another form, +\fC$(\fR...\fC)\fR. This form is much easier to nest. +.Ds +%\0ls\0-l\0`echo\0/vmunix` +-rwxr-xr-x\0\01\0root\0\0\0\0\0\01209702\0May\014\019:04\0/vmunix +%\0ls\0-l\0$(echo\0/vmunix) +-rwxr-xr-x\0\01\0root\0\0\0\0\0\01209702\0May\014\019:04\0/vmunix +%\0who\0|\0grep\0mad +subbarao\0ttyt7\0\0\0May\023\015:02\0\0\0(mad55sx15.Prince) +pfalstad\0ttyu1\0\0\0May\023\016:25\0\0\0(mad55sx14.Prince) +subbarao\0ttyu6\0\0\0May\023\015:04\0\0\0(mad55sx15.Prince) +pfalstad\0ttyv3\0\0\0May\023\016:25\0\0\0(mad55sx14.Prince) +%\0who\0|\0grep\0mad\0|\0awk\0'{print\0$2}' +ttyt7 +ttyu1 +ttyu6 +ttyv3 +%\0cd\0/dev;\0ls\0-l\0$(who\0| +>\0grep\0$(echo\0mad)\0| +>\0awk\0'{\0print\0$2\0}') +crwx-w----\0\01\0subbarao\0\020,\0\071\0May\023\018:35\0ttyt7 +crw--w----\0\01\0pfalstad\0\020,\0\081\0May\023\018:42\0ttyu1 +crwx-w----\0\01\0subbarao\0\020,\0\086\0May\023\018:38\0ttyu6 +crw--w----\0\01\0pfalstad\0\020,\0\099\0May\023\018:41\0ttyv3 +.De +Many common uses of command substitution, however, are +superseded by other mechanisms of \fBzsh\fP: +.Ds +%\0ls\0-l\0`tty` +crw-rw-rw-\0\01\0root\0\0\0\0\0\020,\0\028\0May\023\018:35\0/dev/ttyqc +%\0ls\0-l\0$TTY +crw-rw-rw-\0\01\0root\0\0\0\0\0\020,\0\028\0May\023\018:35\0/dev/ttyqc +%\0ls\0-l\0`which\0rn` +-rwxr-xr-x\0\01\0root\0\0\0\0\0\0\0172032\0Mar\0\06\018:40\0/usr/princeton/bin/rn +%\0ls\0-l\0=rn +-rwxr-xr-x\0\01\0root\0\0\0\0\0\0\0172032\0Mar\0\06\018:40\0/usr/princeton/bin/rn +.De +A command name with a \fC=\fP prepended is replaced with its full +pathname. This can be very convenient. If it's not convenient +for you, you can turn it off: +.Ds +%\0ls +=foo\0\0\0\0=bar +%\0ls\0=foo\0=bar +zsh:\0foo\0not\0found +%\0setopt\0noequals +%\0ls\0=foo\0=bar +=foo\0\0\0\0=bar +.De +.PP +Another nice feature is process substitution: +.Ds +%\0who\0|\0fgrep\0-f\0=(print\0-l\0root\0lemke\0shgchan\0subbarao) +root\0\0\0\0\0console\0May\019\010:41 +lemke\0\0\0\0ttyq0\0\0\0May\022\010:05\0\0\0(narnia:0.0) +lemke\0\0\0\0ttyr7\0\0\0May\022\010:05\0\0\0(narnia:0.0) +lemke\0\0\0\0ttyrd\0\0\0May\022\010:05\0\0\0(narnia:0.0) +shgchan\0\0ttys1\0\0\0May\023\016:52\0\0\0(gaudi.Princeton.) +subbarao\0ttyt7\0\0\0May\023\015:02\0\0\0(mad55sx15.Prince) +subbarao\0ttyu6\0\0\0May\023\015:04\0\0\0(mad55sx15.Prince) +shgchan\0\0ttyvb\0\0\0May\023\016:51\0\0\0(gaudi.Princeton.) +.De +A command of the form \fC=(\fR...\fC)\fR is replaced with the name of a \fIfile\fP +containing its output. (A command substitution, on the other +hand, is replaced with the output itself.) +\fCprint -l\fP is like \fCecho\fP, excepts that it prints its arguments +one per line, the way \fCfgrep\fP expects them: +.Ds +%\0print\0-l\0foo\0bar +foo +bar +.De +We could also have written: +.Ds +%\0who\0|\0fgrep\0-f\0=(echo\0'root +>\0lemke +>\0shgchan +>\0subbarao') +.De +Using\0process\0substitution, +you\0can\0edit\0the\0output\0of\0a\0command: +.Ds +%\0ed\0=(who\0|\0fgrep\0-f\0~/.friends) +355 +g/lemke/d +w\0/tmp/filbar +226 +q +%\0cat\0/tmp/filbar +root\0\0\0\0\0console\0May\019\010:41 +shgchan\0\0ttys1\0\0\0May\023\016:52\0\0\0(gaudi.Princeton.) +subbarao\0ttyt7\0\0\0May\023\015:02\0\0\0(mad55sx15.Prince) +subbarao\0ttyu6\0\0\0May\023\015:04\0\0\0(mad55sx15.Prince) +shgchan\0\0ttyvb\0\0\0May\023\016:51\0\0\0(gaudi.Princeton.) +.De +or easily read archived mail: +.Ds +%\0mail\0-f\0=(zcat\0~/mail/oldzshmail.Z) +"/tmp/zsha06024":\084\0messages,\00\0new,\043\0unread +>\0\01\0\0U\0\0TO:\0pfalstad,\0zsh\0(10) +\0\0\02\0\0U\0\0nytim!tim@uunet.uu.net,\0Re:\0Zsh\0on\0Sparc1\0/SunOS\04.0.3 +\0\0\03\0\0U\0\0JAM%TPN@utrcgw.utc.com,\0zsh\0fix\0(15) +\0\0\04\0\0U\0\0djm@eng.umd.edu,\0way\0to\0find\0out\0if\0running\0zsh?\0(25) +\0\0\05\0\0U\0\0djm@eng.umd.edu,\0Re:\0way\0to\0find\0out\0if\0running\0zsh?\0(17) +\0\0\06\0\0\0r\0djm@eng.umd.edu,\0Meta\0.\0(18) +\0\0\07\0\0U\0\0jack@cs.glasgow.ac.uk,\0Re:\0problem\0building\0zsh\0(147) +\0\0\08\0\0U\0\0nytim!tim@uunet.uu.net,\0Re:\0Zsh\0on\0Sparc1\0/SunOS\04.0.3 +\0\0\09\0\0\0\0\0ursa!jmd,\0Another\0fix...\0(61) +\0\010\0\0U\0\0pplacewa@bbn.com,\0Re:\0v18i084:\0Zsh\02.00\0-\0A\0small\0complaint\0(36) +\0\011\0\0U\0\0lubkin@cs.rochester.edu,\0POSIX\0job\0control\0(34) +\0\012\0\0U\0\0yale!bronson!tan@uunet.UU.NET +\0\013\0\0U\0\0brett@rpi.edu,\0zsh\0(36) +\0\014\0\0S\0\0subbarao,\0zsh\0sucks!!!!\0(286) +\0\015\0\0U\0\0snibru!d241s008!d241s013!ala@relay.EU.net,\0zsh\0(165) +\0\016\0\0U\0\0nytim!tim@uunet.UU.NET,\0Re:\0Zsh\0on\0Sparc1\0/SunOS\04.0.3 +\0\017\0\0U\0\0subbarao,\0zsh\0is\0a\0junk\0shell\0(43) +\0\018\0\0U\0\0amaranth@vela.acs.oakland.edu,\0zsh\0(33) +43u/84\01:\0x +%\0ls\0-l\0/tmp/zsha06024 +/tmp/zsha06024\0not\0found +.De +Note that the shell creates a temporary file, and deletes it +when the command is finished. +.Ds +%\0diff\0=(ls)\0=(ls\0-F) +3c3 +<\0fortune +--- +>\0fortune* +10c10 +<\0strfile +--- +>\0strfile* +.De +If you read \fBzsh\fP's man page, you may notice that \fC<(\fR...\fC)\fR +is another form of process substitution which is similar to +\fC=(\fR...\fC)\fR. +There is an important difference between the two. +In the \fC<(\fR...\fC)\fR case, the shell creates a named pipe (FIFO) +instead of a file. This is better, since it does not +fill up the file system; but it does not work in all cases. +In fact, if we had replaced \fC=(\fR...\fC)\fR with \fC<(\fR...\fC)\fR in +the examples above, all of them would have stopped working +except for \fCfgrep -f <(\fR...\fC)\fR. +You can not edit a pipe, or open it as a mail folder; +\fCfgrep\fP, however, has no problem with reading +a list of words from a pipe. +You may wonder why \fCdiff <(foo) bar\fP doesn't work, since +\fCfoo | diff - bar\fP works; this is because \fCdiff\fP creates +a temporary file if it notices that one of its arguments +is \fC-\fP, and then copies its standard input to the temporary +file. +.PP +\fC>(\fR...\fC)\fR is just like \fC<(\fR...\fC)\fR except that the +command between the parentheses will get its input from the named +pipe. +.Ds +%\0dvips\0-o\0>(lpr)\0zsh.dvi +.De +.Sh "Redirection" +.PP +Apart from all the regular redirections like the Bourne shell has, +\fBzsh\fP can do more. You can send the output of a command to more +than one file, by specifying more redirections like +.Ds +%\0echo\0Hello\0World\0>file1\0>file2 +.De +and the text will end up in both files. Similarly, you can send the +output to a file and into a pipe: +.Ds +%\0make\0>\0make.log\0|\0grep\0Error +.De +The same goes for input. You can make the input of a command come +from more than one file. +.Ds +%\0sort\0<file1\0<file2\0<file3 +.De +The command will first get the contents of file1 as its standard +input, then those of file2 and finally the contents of file3. This, +too, works with pipes. +.Ds +%\0cut\0-d:\0-f1\0/etc/passwd\0|\0sort\0<newnames +.De +The sort will get as its standard input first the output of \fCcut\fP +and then the contents of \fCnewnames\fP. +.PP +Suppose you would like to watch the standard output of a command on +your terminal, but want to pipe the standard error to another command. +An easy way to do this in \fBzsh\fP is by redirecting the standard +error using \fC2> >(\fR...\fC)\fR. +.Ds +%\0find\0/\0-name\0games\02>\0>(grep\0-v\0'Permission'\0>\0realerrors) +.De +The above redirection will actually be implemented with a regular +pipe, not a temporary named pipe. +.Sh "Aliasing" +.PP +Often-used commands can be abbreviated with an alias: +.Ds +%\0alias\0uc=uncompress +%\0ls +hanoi.Z +%\0uc\0hanoi +%\0ls +hanoi +.De +or commands with certain desired options: +.Ds +%\0alias\0fm='finger\0-m' +%\0fm\0root +Login\0name:\0root\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0In\0real\0life:\0Operator +Directory:\0/\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0Shell:\0/bin/csh +On\0since\0May\019\010:41:15\0on\0console\0\0\0\0\03\0days\05\0hours\0Idle\0Time +No\0unread\0mail +No\0Plan. + +%\0alias\0lock='lock\0-p\0-60000' +%\0lock +lock:\0/dev/ttyr4\0on\0phoenix.\0timeout\0in\060000\0minutes +time\0now\0is\0Fri\0May\024\004:23:18\0EDT\01991 +Key:\0 + +%\0alias\0l='ls\0-AF' +%\0l\0/ +\&.bash_history\0\0\0\0\0\0\0\0\0\0\0\0\0\0kadb* +\&.bashrc\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0lib@ +\&.cshrc\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0licensed/ +\&.exrc\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0lost+found/ +\&.login\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0macsyma +\&\fR... +.De +Aliases can also be used to replace old commands: +.Ds +%\0alias\0grep=egrep\0ps=sps\0make=gmake +%\0alias\0whoami='echo\0root' +%\0whoami +root +.De +or to define new ones: +.Ds +%\0cd\0/ +%\0alias\0sz='ls\0-l\0|\0sort\0-n\0+3\0|\0tail\0-10' +%\0sz +drwxr-sr-x\0\07\0bin\0\0\0\0\0\0\0\0\0\03072\0May\023\011:59\0etc +drwxrwxrwx\026\0root\0\0\0\0\0\0\0\0\05120\0May\024\004:20\0tmp +drwxr-xr-x\0\02\0root\0\0\0\0\0\0\0\0\08192\0Dec\026\019:34\0lost+found +drwxr-sr-x\0\02\0bin\0\0\0\0\0\0\0\0\014848\0May\023\018:48\0dev +-r--r--r--\0\01\0root\0\0\0\0\0\0\0140520\0Dec\026\020:08\0boot +-rwxr-xr-x\0\01\0root\0\0\0\0\0\0\0311172\0Dec\026\020:08\0kadb +-rwxr-xr-x\0\01\0root\0\0\0\0\0\01209695\0Apr\016\015:33\0vmunix.old +-rwxr-xr-x\0\01\0root\0\0\0\0\0\01209702\0May\014\019:04\0vmunix +-rwxr-xr-x\0\01\0root\0\0\0\0\0\01209758\0May\021\012:23\0vmunix.new.kernelmap.old +-rwxr-xr-x\0\01\0root\0\0\0\0\0\01711848\0Dec\026\020:08\0vmunix.org +%\0cd +%\0alias\0rable='ls\0-AFtrd\0*(R)'\0nrable='ls\0-AFtrd\0*(^R)' +%\0rable +README\0\0\0\0\0\0func/\0\0\0\0\0\0\0bin/\0\0\0\0\0\0\0\0pub/\0\0\0\0\0\0\0\0News/\0\0\0\0\0\0\0src/ +nicecolors\0\0etc/\0\0\0\0\0\0\0\0scr/\0\0\0\0\0\0\0\0tmp/\0\0\0\0\0\0\0\0iris/\0\0\0\0\0\0\0zsh* +%\0nrable +Mailboxes/\0\0mail/\0\0\0\0\0\0\0notes +.De +(The pattern \fC*(R)\fP matches all readable files in the current +directory, and \fC*(^R)\fP matches all unreadable files.) +.PP +Most other shells have aliases of this kind (\fIcommand\fP aliases). +However, \fBzsh\fP also has \fIglobal\fP aliases, which are substituted +anywhere on a line. +Global aliases can be used to abbreviate frequently-typed +usernames, hostnames, etc. +.Ds +%\0alias\0-g\0me=pfalstad\0gun=egsirer\0mjm=maruchck +%\0who\0|\0grep\0me +pfalstad\0ttyp0\0\0\0May\024\003:39\0\0\0(mickey.Princeton) +pfalstad\0ttyp5\0\0\0May\024\003:42\0\0\0(mickey.Princeton) +%\0fm\0gun +Login\0name:\0egsirer\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0In\0real\0life:\0Emin\0Gun\0Sirer +Directory:\0/u/egsirer\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0Shell:\0/bin/sh +Last\0login\0Thu\0May\023\019:05\0on\0ttyq3\0from\0bow.Princeton.ED +New\0mail\0received\0Fri\0May\024\002:30:28\01991; +\0\0unread\0since\0Fri\0May\024\002:30:27\01991 +%\0alias\0-g\0phx=phoenix.princeton.edu\0warc=wuarchive.wustl.edu +%\0ftp\0warc +Connected\0to\0wuarchive.wustl.edu. +.De +Here are some more interesting uses. +.Ds +%\0alias\0-g\0M='|\0more'\0GF='|\0fgrep\0-f\0~/.friends' +%\0who\0M\0\0\0#\0\fIpipes\0the\0output\0of\0\fCwho\fI\0through\0\fCmore +%\0who\0GF\0\0#\0\fIsee\0if\0your\0friends\0are\0on\fC +%\0w\0GF\0\0\0\0#\0\fIsee\0what\0your\0friends\0are\0doing +.De +Another example makes use of \fBzsh\fP's process substitution. +If you run NIS, and you miss being able to do this: +.Ds +%\0grep\0pfalstad\0/etc/passwd +.De +you can define an alias that will seem more natural +than \fCypmatch pfalstad passwd\fP: +.Ds +%\0alias\0-g\0PASS='<(ypcat\0passwd)' +%\0grep\0pfalstad\0PASS +pfalstad:*:3564:35:Paul\0John\0Falstad:/u/pfalstad:/usr/princeton/bin/zsh +.De +If you're really crazy, you can even call it \fC/etc/passwd\fP: +.Ds +%\0alias\0-g\0/etc/passwd='<(ypcat\0passwd)' +%\0grep\0pfalstad\0/etc/passwd +pfalstad:*:3564:35:Paul\0John\0Falstad:/u/pfalstad:/usr/princeton/bin/zsh +.De +The last example shows one of the perils of global aliases; +they have a lot of potential to cause confusion. +For example, if you defined a global alias called \fC|\fP (which is +possible), \fBzsh\fP would begin to act very strangely; every pipe +symbol would be replaced with the text of your alias. +To some extent, global aliases are like macros in C; +discretion is advised in using them and in choosing names for them. +Using names in all caps is not a bad idea, especially +for aliases which introduce shell metasyntax (like \fCM\fP and \fCGF\fP +above). +.PP +Note that \fBzsh\fP aliases are not like csh aliases. The syntax for +defining them is different, and they do not have arguments. +All your favorite csh aliases will probably not work under \fBzsh\fP. +For example, if you try: +.Ds +alias\0rm\0mv\0'\e!*\0/tmp/wastebasket' +.De +no aliases will be defined, but \fBzsh\fP will not report an error. +In csh, this line defines an alias that makes \fCrm\fP safe---files +that are \fCrm\fP'd will be moved to a temporary directory instead of +instantly destroyed. In \fBzsh\fP's syntax, however, this line asks +the shell to print any existing alias definitions for \fCrm\fP, +\fCmv\fP, or \fC!*\ /tmp/wastebasket\fP. Since there are none, most +likely, the shell will not print anything, although \fCalias\fP will +return a nonzero exit code. The proper syntax is this: +.Ds +alias\0rm='mv\0\e!*\0/tmp/wastebasket' +.De +However, this won't work either: +.Ds +%\0rm\0foo.dvi +zsh:\0no\0matches\0found:\0!* +.De +While this makes \fCrm\fP safe, it is certainly not what the user +intended. In \fBzsh\fP, you must use a shell function for this: +.Ds +%\0unalias\0rm +%\0rm\0()\0{\0mv\0$*\0/tmp/wastebasket\0} +%\0rm\0foo.dvi +%\0ls\0/tmp/wastebasket +foo.dvi +.De +While this is much cleaner and easier to read (I hope you will +agree), it is not csh-compatible. Therefore, a script to convert +csh aliases and variables has been provided. You should only need to use it +once, to convert all your csh aliases and parameters to \fBzsh\fP format: +.Ds +%\0csh +csh>\0alias +l\0\0\0\0\0\0\0ls\0-AF +more\0\0\0\0less +on\0\0\0\0\0\0last\0-2\0!:1\0;\0who\0|\0grep\0!:1 +csh>\0exit +%\0c2z\0>neat_zsh_aliases +%\0cat\0neat_zsh_aliases +alias\0l='ls\0-AF' +alias\0more='less' +on\0()\0{\0last\0-2\0$1\0;\0who\0|\0grep\0$1\0} +\&... +.De +The first two aliases were converted to regular \fBzsh\fP aliases, while +the third, since it needed to handle arguments, was converted to +a function. \fCc2z\fP can convert most aliases to \fBzsh\fP format without +any problems. However, if you're using some really arcane csh tricks, +or if you have an alias with a name like \fCdo\fP (which is reserved +in \fBzsh\fP), you may have to fix some of the aliases by hand. +.PP +The \fCc2z\fP script checks your csh setup, and produces a list +of \fBzsh\fP commands which replicate your aliases and parameter settings +as closely as possible. You could include its output in your +startup file, \fC.zshrc\fP. +.Sh "History" +.PP +There are several ways to manipulate history in \fBzsh\fP. +One way is to use csh-style \fC!\fP history: +.Ds +%\0/usr/local/bin/!:0\0!-2*:s/foo/bar/\0>>!$ +.De +If you don't want to use this, you can turn it off +by typing \fCsetopt nobanghist\fP. If you are afraid of accidentally +executing the wrong command you can set the \fIHISTVERIFY\fP option. +If this option is set, commands that result from history expansion +will not be executed immediately, but will be put back into the editor +buffer for further consideration. +.PP +If you're not familiar with \fC!\fP history, here follows some +explanation. History substitutions always start with a \fC!\fP, +commonly called \*Qbang\*U. After the \fC!\fP comes an (optional) +designation of which \*Qevent\*U (command) to use, then a colon, and +then a designation of what word of that command to use. For example, +\fC!-\fIn\fR refers to the command \fIn\fP commands ago. +.Ds +%\0ls +foo\0\0bar +%\0cd\0foo +%\0!-2 +ls +baz\0\0bam +.De +No word designator was used, which means that the whole command +referred to was repeated. Note that the shell will echo the result of +the history substitution. The word designator can, among other +things, be a number indicating the argument to use, where \fC0\fP is +the command. +.Ds +%\0/usr/bin/ls\0foo +foo +%\0!:0\0bar +/usr/bin/ls\0bar +bar +.De +In this example, no event designator was used, which tells \fBzsh\fP +to use the previous command. A \fC$\fP specifies the last argument +.Ds +%\0mkdir\0/usr/local/lib/emacs/site-lisp/calc +%\0cd\0!:$ +cd\0/usr/local/lib/emacs/site-lisp/calc +.De +If you use more words of the same command, only the first \fC!\fP +needs an event designator. +.Ds +%\0make\0prig\0>>\0make.log +make:\0***\0No\0rule\0to\0make\0target\0`prig'.\0\0Stop. +%\0cd\0src +%\0!-2:0\0prog\0>>\0!:$ +make\0prog\0>>\0make.log +.De +This is different from csh, where a bang with no event designator +always refers to the previous command. If you actually like this +behaviour, set the \fICSHJUNKIEHISTORY\fP option. +.Ds +%\0setopt\0cshjunkiehistory +%\0!-2:0\0prog2\0>>\0!:$ +make\0prog2\0>>\0cshjunkiehistory +.De +Another way to use history is to use the \fCfc\fP command. For +example, if you type an erroneous command: +.Ds +%\0for\0i\0in\0`cat\0/etc/clients`\0 +\0do\0 +\0rpu\0$i\0 +\0done +zsh:\0command\0not\0found:\0rpu +zsh:\0command\0not\0found:\0rpu +zsh:\0command\0not\0found:\0rpu +\&\fR... +.De +typing \fCfc\fP will execute an editor on this command, allowing +you to fix it. (The default editor is \fCvi\fP, by the way, +not \fCed\fP). +.Ds +%\0fc +49 +/rpu/s//rup/p +\0rup\0$i\0 +w +49 +q +for\0i\0in\0`cat\0/etc/clients`\0 +\0do\0 +\0rup\0$i\0 +\0done +\0\0\0\0\0\0\0\0beam\0\0\0\0up\0\02\0days,\010:17,\0\0\0\0load\0average:\00.86,\00.80,\00.50 +\0\0\0\0\0\0\0\0\0bow\0\0\0\0up\0\04\0days,\0\08:41,\0\0\0\0load\0average:\00.91,\00.80,\00.50 +\0\0\0\0\0\0\0\0burn\0\0\0\0up\0\0\0\0\0\0\0\0\0\017:18,\0\0\0\0load\0average:\00.91,\00.80,\00.50 +\0\0\0\0\0\0\0burst\0\0\0\0up\0\09\0days,\0\01:49,\0\0\0\0load\0average:\00.95,\00.80,\00.50 +\0\0\0\0\0\0\0\0\0tan\0\0\0\0up\0\0\0\0\0\0\0\0\0\011:14,\0\0\0\0load\0average:\00.91,\00.80,\00.50 +\0\0\0\0\0\0\0bathe\0\0\0\0up\0\03\0days,\017:49,\0\0\0\0load\0average:\01.84,\01.79,\01.50 +\0\0\0\0\0\0\0\0bird\0\0\0\0up\0\01\0day,\0\0\09:13,\0\0\0\0load\0average:\01.95,\01.82,\01.51 +\0\0\0\0\0\0bonnet\0\0\0\0up\0\02\0days,\021:18,\0\0\0\0load\0average:\00.93,\00.80,\00.50 +\&\fR... +.De +A variant of the \fCfc\fP command is \fCr\fP, which redoes the last +command, with optional changes: +.Ds +%\0echo\0foo +foo +%\0r +echo\0foo +foo + +%\0echo\0foo +foo +%\0r\0foo=bar +echo\0bar +bar +.De +.Sh "Command Line Editing" +.PP +\fBzsh\fP's command line editor, \fBZLE\fP, is quite powerful. +It is designed to emulate either emacs or vi; the default +is emacs. To set the bindings for vi mode, type \fCbindkey -v\fP. If +your \fBEDITOR\fP or \fBVISUAL\fP environment variable is vi, +\fBzsh\fP will use vi emulation by default. You can then switch to +emacs mode with \fCbindkey -e\fP. +.PP +In addition to basic editing, the shell allows you to +recall previous lines in the history. In emacs mode, +this is done with \fI^P\fP (control-P) or (on many terminals) with the +cursor-up key: +.Ds +%\0ls\0~ +-\0\0\0\0\0\0\0\0\0\0\0README\0\0\0\0\0\0file\0\0\0\0\0\0\0\0mail\0\0\0\0\0\0\0\0pub\0\0\0\0\0\0\0\0\0tmp +Mailboxes\0\0\0bin\0\0\0\0\0\0\0\0\0func\0\0\0\0\0\0\0\0nicecolors\0\0scr\0\0\0\0\0\0\0\0\0zsh +News\0\0\0\0\0\0\0\0etc\0\0\0\0\0\0\0\0\0iris\0\0\0\0\0\0\0\0notes\0\0\0\0\0\0\0src +%\0echo\0foobar +foobar +%\0\fI^P\fC +%\0echo\0foobar\fI^P\fC +%\0ls\0~_ +.De +Pressing \fI^P\fP once brings up the previous line (\fCecho foobar\fP); +pressing it again brings up the line before that (\fCls ~\fP). +The cursor is left at the end of the line, allowing you to +edit the line if desired before executing it. +In many cases, \fBZLE\fP eliminates the need for the \fCfc\fP command, +since it is powerful enough to handle even multiline commands: +.Ds +%\0for\0i\0in\0a\0b\0c\0d\0e +>\0do +>\0echo\0$i +>\0done +a +b +c +d +e +%\0\fI^P\fC +%\0for\0i\0in\0a\0b\0c\0d\0e\0 +\0do\0 +\0echo\0$i\0 +\0done_ +.De +Now you can just move up to the part you want to change... +.Ds +%\0for\0i\0in\0\kxa\l'|\nxu\(ul'\0b\0c\0d\0e +\0do\0 +\0echo\0$i\0 +\0done +.De +change it, and execute the new command. +.Ds +%\0for\0i\0in\0f\0g\0h\0i\0j +\0do\0 +\0echo\0$i\0 +\0done +f +g +h +i +j +.De +Also, you can search the history for a certain command using +\fIESC-P\fP, this will look for the last command that started with the +(part of the) word at the beginning of the current line. Hitting +\fIESC-P\fP another time gets you the command before that, etc. +.Ds +%\0set\0\fIESC-P\fC +%\0setopt\0autolist\0\fIESC-P\fC +%\0setopt\0nocorrect_ +.De +Another way is to do an incremental search, emacs-style: +.Ds +%\0\fI^R\fC +%\0_ +i-search: + +%\0l\kxs\l'|\nxu\(ul'\0/usr/bin +i-search:\0l + +%\0date\0>\0foofile\kx.\l'|\nxu\(ul'c +i-search:\0le +.De +Suppose you have retrieved an old history event in one of these ways +and would like to execute several consecutive old commands starting +with this one. \fC^O\fP will execute the current command and then put +the next command from the history into the editor buffer. Typing +\fC^O\fP several times will therefore reexecute several consecutive +commands from the history. Of course, you can edit some of those +commands in between. +.PP +In addition to completion (see below), \fITAB\fP performs expansion if +possible. +.Ds +%\0ls\0*.c\fITAB\fC +%\0ls\0foofile.c\0fortune.c\0rnd.c\0strfile.c\0unstr.c_ +.De +For example, suppose you have a bunch of weird files in an important +directory: +.Ds +%\0ls +\0\0*\0*\0*\0\0\0\0\0\0\0;\0&\0%\0$??foo\0\0dspfok\0\0\0\0\0\0\0\0foo.c +\0\0!"foo"!\0\0\0\0\0\0\0`\0\e\0`\0\0\0\0\0\0\0\0\0foo\0\0\0\0\0\0\0\0\0\0\0rrr +.De +You want to remove them, but you don't want to damage \fCfoo.c\fP. +Here is one way to do this: +.Ds +%\0rm\0*\fITAB\fC +%\0rm\0\e\0\e\0\e*\e\0\e*\e\0\e*\e\0\e\0\e\0\0\e!\e"foo\e"\e!\0\e;\e\0\e&\e\0%\e\0\e$' +'' +'foo\0\e`\e\0\e\e\e\0\e`\0dspfok\0foo\0foo.c\0rrr_ +.De +When you expand \fC*\fP, \fBzsh\fP inserts the names of all the files +into the editing buffer, with proper shell quoting. +Now, just move back and remove \fCfoo.c\fP from the buffer: +.Ds +%\0rm\0\e\0\e\0\e*\e\0\e*\e\0\e*\e\0\e\0\e\0\0\e!\e"foo\e"\e!\0\e;\e\0\e&\e\0%\e\0\e$' +'' +'foo\0\e`\e\0\e\e\e\0\e`\0dspfok\0foo\0\kxr\l'|\nxu\(ul'rr +.De +and press return. +Everything except \fCfoo.c\fP will be deleted from the directory. If +you do not want to actually expand the current word, but would like to +see what the matches are, type \fC^Xg\fP. +.Ds +%\0rm\0f*\fI^Xg\fP +foo\0\0\0\0foo.c +%\0rm\0f*_ +.De +Here's another trick; let's say you have typed this command in: +.Ds +%\0gcc\0-o\0x.out\0foob.c\0-g\0-Wpointer-arith\0-Wtrigraphs_ +.De +and you forget which library you want. You need to escape +out for a minute and check by typing +\fCls /usr/lib\fP, or some other such command; +but you don't want to retype the whole command again, +and you can't press return now because the current command +is incomplete. +In \fBzsh\fP, you can put the line on the \fIbuffer stack\fP, using +\fIESC-Q\fP, and type some other commands. The next time a prompt is printed, +the \fCgcc\fP line will be popped off the stack and put +in the editing buffer automatically; you can then enter the +proper library name and press return (or, \fIESC-Q\fP again and look +for some other libraries whose names you forgot). +.PP +A similar situation: what if you forget the option to gcc that +finds bugs using AI techniques? You could either use \fIESC-Q\fP +again, and type \fCman gcc\fP, or you could press \fIESC-H\fP, which +essentially does the same thing; it puts the current line on +the buffer stack, and executes the command \fCrun-help gcc\fP, +where \fCrun-help\fP is an alias for \fCman\fP. +.PP +Another interesting command is \fIESC-A\fP. This executes the +current line, but retains it in the buffer, so that it appears +again when the next prompt is printed. +Also, the cursor stays in the same place. +This is useful for executing a series of similar commands: +.Ds +%\0cc\0grok.c\0-g\0-lc\0-lgl\0-lsun\0-lmalloc\0-Bstatic\0-o\0b.out +%\0cc\0fubar.c\0-g\0-lc\0-lgl\0-lsun\0-lmalloc\0-Bstatic\0-o\0b.out +%\0cc\0fooble.c\0-g\0-lc\0-lgl\0-lsun\0-lmalloc\0-Bstatic\0-o\0b.out +.De +.PP +The \fIESC-'\fP command is useful for managing the shell's quoting +conventions. Let's say you want to print this string: +.Ds +don't\0do\0that;\0type\0'rm\0-rf\0\e*',\0with\0a\0\e\0before\0the\0*. +.De +All that is necessary is to type it into the editing buffer: +.Ds +%\0don't\0do\0that;\0type\0'rm\0-rf\0\e*',\0with\0a\0\e\0before\0the\0*. +.De +press \fIESC-'\fP (escape-quote): +.Ds +%\0'don'\e''t\0do\0that;\0type\0'\e''rm\0-rf\0\e*'\e'',\0with\0a\0\e\0before\0the\0*.' +.De +then move to the beginning and add the \fCecho\fP command. +.Ds +%\0echo\0'don'\e''t\0do\0that;\0type\0'\e''rm\0-rf\0\e*'\e'',\0with\0a\0\e\0before\0the\0*.' +don't\0do\0that;\0type\0'rm\0-rf\0\e*',\0with\0a\0\e\0before\0the\0*. +.De +Let's say you want to create an alias to do this \fCecho\fP command. +This can be done by recalling the line with \fI^P\fP and pressing +\fIESC-'\fP again: +.Ds +%\0'echo\0'\e''don'\e''\e'\e'''\e''t\0do\0that;\0type\0'\e''\e'\e'''\e''rm\0-rf +\e*'\e''\e'\e'''\e'',\0with\0a\0\e\0before\0the\0*.'\e''' +.De +and then move to the beginning and add the command to create +an alias. +.Ds +%\0alias\0zoof='echo\0'\e''don'\e''\e'\e'''\e''t\0do\0that;\0type\0'\e''\e'\e'''\e''rm +-rf\0\e*'\e''\e'\e'''\e'',\0with\0a\0\e\0before\0the\0*.'\e''' +%\0zoof +don't\0do\0that;\0type\0'rm\0-rf\0\e*',\0with\0a\0\e\0before\0the\0*. +.De +If one of these fancy editor commands changes your command line in a +way you did not intend, you can undo changes with \fC^_\fP, if you can +get it out of your keyboard, or \fC^X^U\fP, otherwise. +.PP +Another use of the editor is to edit the value of variables. +For example, an easy way to change your path is to use +the \fCvared\fP command: +.Ds +%\0vared\0PATH +>\0/u/pfalstad/scr:/u/pfalstad/bin/sun4:/u/maruchck/scr:/u/subbarao/bin:/u/maruc +hck/bin:/u/subbarao/scripts:/usr/princeton/bin:/usr/ucb:/usr/bin:/bin:/usr/host +s:/usr/princeton/bin/X11:/./usr/lang:/./usr/etc:/./etc +.De +You can now edit the path. When you press return, the contents +of the edit buffer will be assigned to \fBPATH\fP. +.Sh "Completion" +.PP +Another great \fBzsh\fP feature is completion. If you hit \fITAB\fP, \fBzsh\fP +will complete all kinds of stuff. Like commands or filenames: +.Ds +%\0comp\fITAB\fC +%\0compress\0_ + +%\0ls\0nic\fITAB\fC +%\0ls\0nicecolors\0_ + +%\0ls\0/usr/pr\fITAB\fC +%\0ls\0/usr/princeton/_ + +%\0ls\0-l\0=com\fITAB\fC +%\0ls\0-l\0=compress\0_ +.De +If the completion is ambiguous, the editor will beep. If you find +this annoying, you can set the \fINOLISTBEEP\fP option. Completion +can even be done in the middle of words. To use this, you will have +to set the \fICOMPLETEINWORD\fP option: +.Ds +%\0setopt\0completeinword +%\0ls\0/usr/p\kxt\l'|\nxu\(ul'on\fITAB\fC +%\0ls\0/usr/prince\kxt\l'|\nxu\(ul'on/ +%\0setopt\0alwaystoend +%\0ls\0/usr/p\kxt\l'|\nxu\(ul'on\fITAB\fC +%\0ls\0/usr/princeton/_ +.De +You can list possible completions by pressing \fI^D\fP: +.Ds +%\0ls\0/vmu\fITAB\0\(embeep\(em\fC +%\0ls\0/vmunix_ +%\0ls\0/vmunix\fI^D\fC +vmunix\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0vmunix.old\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 +vmunix.new.kernelmap.old\0\0vmunix.org +.De +Or, you could just set the \fIAUTOLIST\fP option: +.Ds +%\0setopt\0autolist +%\0ls\0/vmu\fITAB\0\(embeep\(em\fC +vmunix\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0vmunix.old\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 +vmunix.new.kernelmap.old\0\0vmunix.org +%\0ls\0/vmunix_ +.De +If you like to see the types of the files in these lists, like in +\fCls\ -F\fP, you can set the \fILISTTYPES\fP option. Together with +\fIAUTOLIST\fP you can use \fILISTAMBIGUOUS\fP. This will only list +the possibilities if there is no unambiguous part to add: +.Ds +%\0setopt\0listambiguous +%\0ls\0/vmu\fITAB\0\(embeep\(em\fC +%\0ls\0/vmunix_\fITAB\0\(embeep\(em\fC +vmunix\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0vmunix.old\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 +vmunix.new.kernelmap.old\0\0vmunix.org +.De +If you don't want several of these listings to scroll the screen so +much, the \fIALWAYSLASTPROMPT\fP option is useful. If set, you can +continue to edit the line you were editing, with the completion +listing appearing beneath it. +.PP +Another interesting option is \fIMENUCOMPLETE\fP. This affects the +way \fITAB\fP works. Let's look at the \fC/vmunix\fP example again: +.Ds +%\0setopt\0menucomplete +%\0ls\0/vmu\fITAB\fC +%\0ls\0/vmunix\fITAB\fC +%\0ls\0/vmunix.new.kernelmap.old\fITAB\fC +%\0ls\0/vmunix.old_ +.De +Each time you press \fITAB\fP, it displays the next possible completion. +In this way, you can cycle through the possible completions until +you find the one you want. +.PP +The \fIAUTOMENU\fP option makes a nice compromise between this method +of completion and the regular method. If you set this option, +pressing \fITAB\fP once completes the unambiguous part normally, +pressing the \fITAB\fP key repeatedly after an ambiguous completion +will cycle through the possible completions. +.PP +Another option you could set is \fIRECEXACT\fP, which causes +exact matches to be accepted, even if there are other possible +completions: +.Ds +%\0setopt\0recexact +%\0ls\0/vmu\fITAB\0\(embeep\(em\fC +vmunix\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0vmunix.old\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 +vmunix.new.kernelmap.old\0\0vmunix.org +%\0ls\0/vmunix_\fITAB\fC +%\0ls\0/vmunix\0_ +.De +To facilitate the typing of pathnames, a slash will be added whenever +a directory is completed. Some computers don't like the spurious +slashes at the end of directory names. In that case, the +\fIAUTOREMOVESLASH\fP option comes to rescue. It will remove these +slashes when you type a space or return after them. +.PP +The \fIfignore\fP variable lists suffixes of files to ignore +during completion. +.Ds +%\0ls\0foo\fITAB\0\(embeep\(em\fC +foofile.c\0\0foofile.o +%\0fignore=(\0.o\0\e~\0.bak\0.junk\0) +%\0ls\0foo\fITAB\fP +%\0ls\0foofile.c\0_ +.De +Since \fCfoofile.o\fP has a suffix that is in the \fCfignore\fP list, +it was not considered a possible completion of \fCfoo\fP. +.PP +Username completion is also supported: +.Ds +%\0ls\0~pfal\fITAB\fC +%\0ls\0~pfalstad/_ +.De +and parameter name completion: +.Ds +%\0echo\0$ORG\fITAB\fC +%\0echo\0$ORGANIZATION\0_ +%\0echo\0${ORG\fITAB\fC +%\0echo\0${ORGANIZATION\0_ +.De +Note that in the last example a space is added after the completion as +usual. But if you want to add a colon or closing brace, you probably +don't want this extra space. Setting the \fIAUTOPARAMKEYS\fP option +will automatically remove this space if you type a colon or closing +brace after such a completion. +.PP +There is also option completion: +.Ds +%\0setopt\0nocl\fITAB\fC +%\0setopt\0noclobber\0_ +.De +and binding completion: +.Ds +%\0bindkey\0'^X^X'\0pu\fITAB\fC +%\0bindkey\0'^X^X'\0push-line\0_ +.De +The \fCcompctl\fP command is used to control completion of the +arguments of specific commands. For example, to specify that certain +commands take other commands as arguments, you use \fCcompctl -c\fP: +.Ds +%\0compctl\0-c\0man\0nohup +%\0man\0upt\fITAB\fC +%\0man\0uptime\0_ +.De +To specify that a command should complete filenames, you should use +\fCcompctl -f\fP. This is the default. It can be combined with \fC-c\fP, +as well. +.Ds +%\0compctl\0-cf\0echo +%\0echo\0upt\fITAB\fC +%\0echo\0uptime\0_ + +%\0echo\0fo\fITAB\fC +%\0echo\0foo.c +.De +Similarly, use \fC-o\fP to specify options, \fC-v\fP to specify +variables, and \fC-b\fP to specify bindings. +.Ds +%\0compctl\0-o\0setopt\0unsetopt +%\0compctl\0-v\0typeset\0vared\0unset\0export +%\0compctl\0-b\0bindkey +.De +You can also use \fC-k\fP to specify a custom list of keywords to use +in completion. After the \fC-k\fP comes either the name of an array +or a literal array to take completions from. +.Ds +%\0ftphosts=(ftp.uu.net\0wuarchive.wustl.edu) +%\0compctl\0-k\0ftphosts\0ftp +%\0ftp\0wu\fITAB\fC +%\0ftp\0wuarchive.wustl.edu\0_ + +%\0compctl\0-k\0'(cpirazzi\0subbarao\0sukthnkr)'\0mail\0finger +%\0finger\0cp\fITAB\fC +%\0finger\0cpirazzi\0_ +.De +To better specify the files to complete for a command, use the +\fC-g\fP option which takes any glob pattern as an argument. Be sure +to quote the glob patterns as otherwise they will be expanded when the +\fCcompctl\fP command is run. +.Ds +%\0ls +letter.tex\0\0letter.dvi\0\0letter.aux\0\0letter.log\0\0letter.toc +%\0compctl\0-g\0'*.tex'\0latex +%\0compctl\0-g\0'*.dvi'\0xdvi\0dvips +%\0latex\0l\fITAB\fC +%\0latex\0letter.tex\0_ +%\0xdvi\0l\fITAB\fC +%\0xdvi\0letter.dvi\0_ +.De +Glob patterns can include qualifiers within parentheses. To rmdir +only directories and cd to directories and symbolic links pointing to +them: +.Ds +%\0compctl\0-g\0'*(-/)'\0cd +%\0compctl\0-g\0'*(/)'\0rmdir +.De +RCS users like to run commands on files which are not in the current +directory, but in the RCS subdirectory where they all get \fC,v\fP +suffixes. They might like to use +.Ds +%\0compctl\0-g\0'RCS/*(:t:s/\e,v//)'\0co\0rlog\0rcs +%\0ls\0RCS +builtin.c,v\0\0lex.c,v\0\0\0\0\0\0zle_main.c,v +%\0rlog\0bu\fITAB\fC +%\0rlog\0builtin.c\0_ +.De +The \fC:t\fP modifier keeps only the last part of the pathname and the +\fC:s/\e,v//\fP will replace any \fC,v\fP by nothing. +.PP +The \fC-s\fP flag is similar to \fC-g\fP, but it uses all expansions, +instead of just globbing, like brace expansion, parameter substitution +and command substitution. +.Ds +%\0compctl\0-s\0'$(setopt)'\0unsetopt +.De +will only complete options which are actually set to be arguments to +\fCunsetopt\fP. +.PP +Sometimes a command takes another command as its argument. You can +tell \fBzsh\fP to complete commands as the first argument to such a +command and then use the completion method of the second command. The +\fC-l\fP flag with a null-string argument is used for this. +.Ds +%\0compctl\0-l\0''\0nohup\0exec +%\0nohup\0comp\fITAB\fC +%\0nohup\0compress\0_ +%\0nohup\0compress\0fil\fITAB\fC +%\0nohup\0compress\0filename\0_ +.De +Sometimes you would like to run really complicated commands to find +out what the possible completions are. To do this, you can specify a +shell function to be called that will assign the possible completions +to a variable called reply. Note that this variable must be an array. +Here's another (much slower) way to get the completions for \fCco\fP +and friends: +.Ds +%\0function\0getrcs\0{ +>\0reply=() +>\0for\0i\0in\0RCS/* +>\0\0\0do +>\0\0\0reply=($reply[*]\0$(basename\0$i\0,v)) +>\0\0\0done +>\0} +%\0compctl\0-K\0getrcs\0co\0rlog\0rcs +.De +Some command arguments use a prefix that is not a part of the things +to complete. The kill builtin command takes a signal name after a +\fC-\fP. To make such a prefix be ignored in the completion process, +you can use the \fC-P\fP flag. +.Ds +%\0compctl\0-P\0-\0-k\0signals\0kill +%\0kill\0-H\fITAB\fP +%\0kill\0-HUP\0_ +.De +TeX is usually run on files ending in \fC.tex\fP, but also sometimes +on other files. It is somewhat annoying to specify that the arguments +of TeX should end in \fC.tex\fP and then not be able to complete these +other files. Therefore you can specify things like \*QComplete to +files ending in \fC.tex\fP if available, otherwise complete to any +filename.\*U. This is done with \fIxor\fPed completion: +.Ds +%\0compctl\0-g\0'*.tex'\0+\0-f\0tex +.De +The \fC+\fP tells the editor to only take the next thing into account +if the current one doesn't generate any matches. If you have not +changed the default completion, the above example is in fact +equivalent to +.Ds +%\0compctl\0-g\0'*.tex'\0+\0tex +.De +as a lone \fC+\fP at the end is equivalent to specifying the default +completion after the \fC+\fP. This form of completion is also +frequently used if you want to run some command only on a certain type +of files, but not necessarily in the current directory. In this case +you will want to complete both files of this type and directories. +Depending on your preferences you can use either of +.Ds +%\0compctl\0-g\0'*.ps'\0+\0-g\0'*(-/)'\0ghostview +%\0compctl\0-g\0'*.ps\0*(-/)'\0ghostview +.De +where the first one will only complete directories (and symbolic links +pointing to directories) if no postscript file matches the already +typed part of the argument. +.Sh "Extended completion" +.PP +If you play with completion, you will soon notice that you would like +to specify what to complete, depending on what flags you give to the +command and where you are on the command line. For example, a command +could take any filename argument after a \fC-f\fP flag, a username +after a \fC-u\fP flag and an executable after a \fC-x\fP flag. This +section will introduce you to the ways to specify these things. To +many people it seems rather difficult at first, but taking the trouble +to understand it can save you lots of typing in the end. Even I keep +being surprised when \fBzsh\fP manages to complete a small or even +empty prefix to the right file in a large directory. +.PP +To tell \fBzsh\fP about these kinds of completion, you use \*Qextended +completion\*U by specifying the \fC-x\fP flag to compctl. The +\fC-x\fP flag takes a list of patterns/flags pairs. The patterns +specify when to complete and the flags specify what. The flags are +simply those mentioned above, like \fC-f\fP or \fC-g \fIglob +pattern\fR. +.PP +As an example, the \fCr[\fIstring1\fC,\fIstring2\fC]\fR pattern +matches if the cursor is after something that starts with +\fIstring1\fP and before something that starts with \fIstring2\fP. +The \fIstring2\fP is often something that you do not want to match +anything at all. +.Ds +%\0ls +foo1\0\0\0bar1\0\0\0foo.Z\0\0bar.Z +%\0compctl\0-g\0'^*.Z'\0-x\0'r[-d,---]'\0-g\0'*.Z'\0--\0compress +%\0compress\0f\fITAB\fP +%\0compress\0foo1\0_ +%\0compress\0-d\0f\fITAB\fP +%\0compress\0-d\0foo.Z\0_ +.De +In the above example, if the cursor is after the \fC-d\fP the pattern +will match and therefore \fBzsh\fP uses the \fC-g *.Z\fP flag that will only +complete files ending in \fC.Z\fP. Otherwise, if no pattern matches, +it will use the flags before the \fC-x\fP and in this case complete +every file that does not end in \fC.Z\fP. +.PP +The \fCs[\fIstring\fC]\fR pattern matches if the current word starts +with \fIstring\fP. The \fIstring\fP itself is not considered to be +part of the completion. +.Ds +%\0compctl\0-x\0's[-]'\0-k\0signals\0--\0kill +%\0kill\0-H\fITAB\fP +%\0kill\0-HUP\0_ +.De +The \fCtar\fP command takes a tar file as an argument after the +\fC-f\fP option. The \fCc[\fIoffset\fC,\fIstring\fC]\fR pattern +matches if the word in position \fIoffset\fP relative to the current +word is \fIstring\fP. More in particular, if \fIoffset\fP is -1, it +matches if the previous word is \fIstring\fP. This suggests +.Ds +%\0compctl\0-f\0-x\0'c[-1,-f]'\0-g\0'*.tar'\0--\0tar +.De +But this is not enough. The \fC-f\fP option could be the last of a +longer string of options. \fCC[\fR...\fC,\fR...\fC]\fR is just like +\fCc[\fR...\fC,\fR...\fC]\fR, except that it uses glob-like pattern +matching for \fIstring\fP. So +.Ds +%\0compctl\0-f\0-x\0'C[-1,-*f]'\0-g\0'*.tar'\0--\0tar +.De +will complete tar files after any option string ending in an \fCf\fP. +But we'd like even more. Old versions of tar used all options as the +first argument, but without the minus sign. This might be +inconsistent with option usage in all other commands, but it is still +supported by newer versions of \fCtar\fP. So we would also like to +complete tar files if the first argument ends in an \fCf\fP and we're +right behind it. +.PP +We can `and' patterns by putting them next to each other with a space +between them. We can `or' these sets by putting comma's between them. +We will also need some new patterns. \fCp[\fInum\fC]\fR will match if +the current argument (the one to be completed) is the \fInum\fPth +argument. \fCW[\fIindex\fC,\fIpattern\fC]\fR will match if the +argument in place \fIindex\fP matches the \fIpattern\fP. This gives +us +.Ds +%\0compctl\0-f\0-x\0'C[-1,-*f]\0,\0W[1,*f]\0p[2]'\0-g\0'*.tar'\0--\0tar +.De +In words: If the previous argument is an option string that ends in an +\fCf\fP, or the first argument ended in an \fCf\fP and it is now the +second argument, then complete only filenames ending in \fC.tar\fP. +.PP +All the above examples used only one set of patterns with one +completion flag. You can use several of these pattern/flag pairs +separated by a \fC-\fP. The first matching pattern will be used. +Suppose you have a version of \fCtar\fP that supports compressed files +by using a \fC-Z\fP option. Leaving the old tar syntax aside for a +moment, we would like to complete files ending in \fC.tar.Z\fP if a +\fC-Z\fP option has been used and files ending in \fC.tar\fP +otherwise, all this only after a \fC-f\fP flag. Again, the \fC-Z\fP +can be alone or it can be part of a longer option string, perhaps the +same as that of the \fC-f\fP flag. Here's how to do it; note the +backslash and the secondary prompt which are not part of the +\fCcompctl\fP command. +.Ds +%\0compctl\0-f\0-x\0'C[-1,-*Z*f]\0,\0R[-*Z*,---]\0C[-1,-*f]'\0-g\0'*.tar.Z'\0-\0\e +>\0'C[-1,-*f]'\0-g\0'*.tar'\0--\0tar +.De +The first pattern set tells us to match if either the previous +argument was an option string including a \fCZ\fP and ending in an +\fCf\fP or there was an option string with a \fCZ\fP somewhere and the +previous word was any option string ending in an \fCf\fP. If this is +the case, we need a compressed tar file. Only if this is not the case +the second pattern set will be considered. By the way, +\fCR[\fIpattern1\fC,\fIpattern2\fC]\fR is just like +\fCr[\fR...\fC,\fR...\fC]\fR except that it uses pattern matching with +shell metacharacters instead of just strings. +.PP +You will have noticed the \fC--\fP before the command name. This ends +the list of pattern/flag pairs of \fC-x\fP. It is usually used just +before the command name, but you can also use an extended completion +as one part of a list of xored completions, in which case the \fC--\fP +appears just before one of the \fC+\fP signs. +.PP +Note the difference between using extended completion as part of a +list of xored completions as in +.Ds +%\0ls +foo\0\0bar +%\0compctl\0-x\0'r[-d,---]'\0-g\0'*.Z'\0--\0+\0-g\0'^*.Z'\0compress +%\0compress\0-d\0f\fITAB\fP +%\0compress\0-d\0foo\0_ +.De +and specifying something before the \fC-x\fP as in +.Ds +%\0compctl\0-g\0'^*.Z'\0-x\0'r[-d,---]'\0-g\0'*.Z'\0--\0compress +%\0compress\0-d\0f\fITAB\fP +%\0compress\0-d\0f_ +.De +In the first case, the alternative glob pattern (\fC^*.Z\fP) will be +used if the first part does not generate any possible completions, +while in the second case the alternative glob pattern will only be +used if the \fCr[\fR...\fC]\fR pattern doesn't match. +.Sh "Bindings" +.PP +Each of the editor commands we have seen was actually a function bound +by default to a certain key. The real names of the commands are: +.Ds +\fCexpand-or-complete\0\0\0\fITAB\fR +\fCpush-line\0\0\0\0\0\0\0\0\0\0\0\0\fIESC-Q\fR +\fCrun-help\0\0\0\0\0\0\0\0\0\0\0\0\0\fIESC-H\fR +\fCaccept-and-hold\0\0\0\0\0\0\fIESC-A\fR +\fCquote-line\0\0\0\0\0\0\0\0\0\0\0\fIESC-'\fR +.De +These bindings are arbitrary; you could change them if you want. +For example, to bind \fCaccept-line\fP to \fI^Z\fP: +.Ds +%\0bindkey\0'^Z'\0accept-line +.De +Another idea would be to bind the delete key to \fCdelete-char\fP; +this might be convenient if you use \fI^H\fP for backspace. +.Ds +%\0bindkey\0'^?'\0delete-char +.De +Or, you could bind \fI^X\fP\fI^H\fP to \fCrun-help\fP: +.Ds +%\0bindkey\0'^X^H'\0run-help +.De +Other examples: +.Ds +%\0bindkey\0'^X^Z'\0universal-argument +%\0bindkey\0'\0'\0magic-space +%\0bindkey\0-s\0'^T'\0'uptime +>\0' +%\0bindkey\0'^Q'\0push-line-or-edit +.De +\fCuniversal-argument\fP multiplies the next command by 4. +Thus \fI^X\fP\fI^Z\fP\fI^W\fP might delete the last four words on the line. +If you bind space to \fCmagic-space\fP, then csh-style history +expansion is done on the line whenever you press the space bar. +.PP +Something that often happens is that I am typing a multiline command +and discover an error in one of the previous lines. In this case, +\fCpush-line-or-edit\fP will put the entire multiline construct into +the editor buffer. If there is only a single line, it is equivalent +to \fCpush-line\fP. +.PP +The \fC-s\fP flag to \fCbindkey\fP specifies that you are binding the key +to a string, not a command. Thus \fCbindkey -s '^T' 'uptime\en'\fP +lets you VMS lovers get the load average whenever you press \fI^T\fP. +.PP +If you have a NeXT keyboard, the one with the \fC|\fP and \fC\e\fP keys +very inconveniently placed, the following +bindings may come in handy: +.Ds +%\0bindkey\0-s\0'\ee/'\0'\e\e' +%\0bindkey\0-s\0'\ee='\0'|' +.De +Now you can type \fIALT-/\fP to get a backslash, and \fIALT-=\fP to +get a vertical bar. This only works inside \fBzsh\fP, of course; +\fCbindkey\fP has no effect on the key mappings inside \fCtalk\fP +or \fCmail\fP, etc. +.PP +Some people like to bind \fC^S\fP and \fC^Q\fP to editor commands. +Just binding these has no effect, as the terminal will catch them and +use them for flow control. You could unset them as stop and start +characters, but most people like to use these for external commands. +The solution is to set the \fINOFLOWCONTROL\fP option. This will +allow you to bind the start and stop characters to editor commands, +while retaining their normal use for external commands. +.Sh "Parameter Substitution" +.PP +In \fBzsh\fP, parameters are set like this: +.Ds +%\0foo=bar +%\0echo\0$foo +bar +.De +Spaces before or after the \fC=\fP are frowned upon: +.Ds +%\0foo\0=\0bar +zsh:\0command\0not\0found:\0foo +.De +Also, \fCset\fP doesn't work for setting parameters: +.Ds +%\0set\0foo=bar +%\0set\0foo\0=\0bar +%\0echo\0$foo + +% +.De +Note that no error message was printed. This is because both +of these commands were perfectly valid; the \fCset\fP builtin +assigns its arguments to the \fIpositional parameters\fP +(\fC$1\fP, \fC$2\fP, etc.). +.Ds +%\0set\0foo=bar +%\0echo\0$1 +foo=bar +%\0set\0foo\0=\0bar +%\0echo\0$3\0$2 +bar\0= +.De +If you're really intent on using the csh syntax, define a +function like this: +.Ds +%\0set\0()\0{ +>\0\0\0\0eval\0"$1$2$3" +>\0} +%\0set\0foo\0=\0bar +%\0set\0fuu=brrr +%\0echo\0$foo\0$fuu +bar\0brrr +.De +But then, of course you can't use the form of \fCset\fP with +options, like \fCset -F\fP (which turns off filename generation). +Also, the \fCset\fP command by itself won't list all the parameters +like it should. +To get around that you need a \fCcase\fP statement: +.Ds +%\0set\0()\0{ +>\0\0\0\0case\0$1\0in +>\0\0\0\0-*|+*|'')\0builtin\0set\0$*\0;; +>\0\0\0\0*)\0eval\0"$1$2$3"\0;; +>\0\0\0\0esac +>\0} +.De +For the most part, this should make csh users happy. +.PP +The following sh-style operators are supported in \fBzsh\fP: +.Ds +%\0unset\0null +%\0echo\0${foo-xxx} +bar +%\0echo\0${null-xxx} +xxx +%\0unset\0null +%\0echo\0${null=xxx} +xxx +%\0echo\0$null +xxx +%\0echo\0${foo=xxx} +bar +%\0echo\0$foo +bar +%\0unset\0null +%\0echo\0${null+set} + +%\0echo\0${foo+set} +set +.De +Also, csh-style \fC:\fP modifiers may be appended to a parameter +substitution. +.Ds +%\0echo\0$PWD +/home/learning/pf/zsh/zsh2.00/src +%\0echo\0$PWD:h +/home/learning/pf/zsh/zsh2.00 +%\0echo\0$PWD:h:h +/home/learning/pf/zsh +%\0echo\0$PWD:t +src +%\0name=foo.c +%\0echo\0$name +foo.c +%\0echo\0$name:r +foo +%\0echo\0$name:e +c +.De +The equivalent constructs in ksh (which are also supported in \fBzsh\fP) +are a bit more general and easier to remember. +When the shell expands \fC${foo#\fR\fIpat\fR\fC}\fR, +it checks to see if \fIpat\fP matches a substring at the beginning +of the value +of \fCfoo\fP. If so, it removes that portion of \fCfoo\fP, using the shortest +possible match. +With \fC${foo##\fR\fIpat\fR\fC}\fR, the longest possible match is removed. +\fC${foo%\fR\fIpat\fR\fC}\fR and \fC${foo%%\fR\fIpat\fR\fC}\fR remove the match +from the end. +Here are the ksh equivalents of the \fC:\fP modifiers: +.Ds +%\0echo\0${PWD%/*} +/home/learning/pf/zsh/zsh2.00 +%\0echo\0${PWD%/*/*} +/home/learning/pf/zsh +%\0echo\0${PWD##*/} +src +%\0echo\0${name%.*} +foo +%\0echo\0${name#*.} +c +.De +\fBzsh\fP also has upper/lowercase modifiers: +.Ds +%\0xx=Test +%\0echo\0$xx:u +TEST +%\0echo\0$xx:l +test +.De +and a substitution modifier: +.Ds +%\0echo\0$name:s/foo/bar/ +bar.c +%\0ls +foo.c\0\0\0\0foo.h\0\0\0\0foo.o\0\0\0\0foo.pro +%\0for\0i\0in\0foo.*;\0mv\0$i\0$i:s/foo/bar/ +%\0ls +bar.c\0\0\0\0bar.h\0\0\0\0bar.o\0\0\0\0bar.pro +.De +There is yet another syntax to modify substituted parameters. You can +add certain modifiers in parentheses after the opening brace like: +.Ds +${(\fImodifiers\fC)\fIparameter\fC} +.De +For example, \fCo\fP sorts the words resulting from the expansion: +.Ds +%\0echo\0${path} +/usr/bin\0/usr/bin/X11\0/etc +%\0echo\0${(o)path} +/etc\0/usr/bin\0/usr/bin/X11 +.De +One possible source of confusion is the fact that in \fBzsh\fP, +the result of parameter substitution is \fInot\fP split into +words. Thus, this will not work: +.Ds +%\0srcs='glob.c\0exec.c\0init.c' +%\0ls\0$srcs +glob.c\0exec.c\0init.c\0not\0found +.De +This is considered a feature, not a bug. +If splitting were done by default, as it is in most other shells, +functions like this would not work properly: +.Ds +$\0ll\0()\0{\0ls\0-F\0$*\0} +$\0ll\0'fuu\0bar' +fuu\0not\0found +bar\0not\0found + +%\0ll\0'fuu\0bar' +fuu\0bar\0not\0found +.De +Of course, a hackish workaround is available in sh (and \fBzsh\fP): +.Ds +%\0setopt\0shwordsplit +%\0ll\0()\0{\0ls\0-F\0"$@"\0} +%\0ll\0'fuu\0bar' +fuu\0bar\0not\0found +.De +If you like the sh behaviour, \fBzsh\fP can accomodate you: +.Ds +%\0ls\0${=srcs} +exec.c\0\0glob.c\0\0init.c +%\0setopt\0shwordsplit +%\0ls\0$srcs +exec.c\0\0glob.c\0\0init.c +.De +Another way to get the \fC$srcs\fP trick to work is to use an array: +.Ds +%\0unset\0srcs +%\0srcs=(\0glob.c\0exec.c\0init.c\0)\0\0 +%\0ls\0$srcs +exec.c\0\0glob.c\0\0init.c +.De +or an alias: +.Ds +%\0alias\0-g\0SRCS='exec.c\0glob.c\0init.c' +%\0ls\0SRCS +exec.c\0\0glob.c\0\0init.c +.De +Another option that modifies parameter expansion is +\fIRCEXPANDPARAM\fP: +.Ds +%\0echo\0foo/$srcs +foo/glob.c\0exec.c\0init.c +%\0setopt\0rcexpandparam +%\0echo\0foo/$srcs +foo/glob.c\0foo/exec.c\0foo/init.c +%\0echo\0foo/${^srcs} +foo/glob.c\0foo/exec.c\0foo/init.c +%\0echo\0foo/$^srcs +foo/glob.c\0foo/exec.c\0foo/init.c +.De +.Sh "Shell Parameters" +.PP +The shell has many predefined parameters that may be +accessed. Here are some examples: +.Ds +%\0sleep\010\0& +[1]\03820 +%\0echo\0$! +3820 +%\0set\0a\0b\0c +%\0echo\0$# +3 +%\0echo\0$ARGC +3 +%\0(\0exit\020\0)\0;\0echo\0$? +20 +%\0false;\0echo\0$status +1 +.De +(\fC$?\fP and \fC$status\fP are equivalent.) +.Ds +%\0echo\0$HOST\0$HOSTTYPE +dendrite\0sun4 +%\0echo\0$UID\0$GID +701\060 +%\0cd\0/tmp +%\0cd\0/home +%\0echo\0$PWD\0$OLDPWD +/home\0/tmp +%\0ls\0$OLDPWD/.getwd\0 +/tmp/.getwd +.De +\fC~+\fP and \fC~-\fP are short for \fC$PWD\fP and \fC$OLDPWD\fP, respectively. +.Ds +%\0ls\0~-/.getwd +/tmp/.getwd +%\0ls\0-d\0~+/learning +/home/learning +%\0echo\0$RANDOM +4880 +%\0echo\0$RANDOM +11785 +%\0echo\0$RANDOM +2062 +%\0echo\0$TTY +/dev/ttyp4 +%\0echo\0$VERSION +zsh\0v2.00.03 +%\0echo\0$USERNAME +pf +.De +.PP +The \fCcdpath\fP variable sets the search path for the \fCcd\fP command. +If you do not specify \fC.\fP somewhere in the path, it is assumed to +be the first component. +.Ds +%\0cdpath=(\0/usr\0~\0~/zsh\0) +%\0ls\0/usr +5bin\0\0\0\0\0\0\0\0\0dict\0\0\0\0\0\0\0\0\0lang\0\0\0\0\0\0\0\0\0net\0\0\0\0\0\0\0\0\0\0sccs\0\0\0\0\0\0\0\0\0sys +5include\0\0\0\0\0etc\0\0\0\0\0\0\0\0\0\0lector\0\0\0\0\0\0\0nserve\0\0\0\0\0\0\0services\0\0\0\0\0tmp +5lib\0\0\0\0\0\0\0\0\0export\0\0\0\0\0\0\0lib\0\0\0\0\0\0\0\0\0\0oed\0\0\0\0\0\0\0\0\0\0share\0\0\0\0\0\0\0\0ucb +adm\0\0\0\0\0\0\0\0\0\0games\0\0\0\0\0\0\0\0local\0\0\0\0\0\0\0\0old\0\0\0\0\0\0\0\0\0\0skel\0\0\0\0\0\0\0\0\0ucbinclude +bin\0\0\0\0\0\0\0\0\0\0geac\0\0\0\0\0\0\0\0\0lost+found\0\0\0openwin\0\0\0\0\0\0spool\0\0\0\0\0\0\0\0ucblib +boot\0\0\0\0\0\0\0\0\0hosts\0\0\0\0\0\0\0\0macsyma_417\0\0pat\0\0\0\0\0\0\0\0\0\0src\0\0\0\0\0\0\0\0\0\0xpg2bin +demo\0\0\0\0\0\0\0\0\0include\0\0\0\0\0\0man\0\0\0\0\0\0\0\0\0\0princeton\0\0\0\0stand\0\0\0\0\0\0\0\0xpg2include +diag\0\0\0\0\0\0\0\0\0kvm\0\0\0\0\0\0\0\0\0\0mdec\0\0\0\0\0\0\0\0\0pub\0\0\0\0\0\0\0\0\0\0swap\0\0\0\0\0\0\0\0\0xpg2lib +%\0cd\0spool +/usr/spool +%\0cd\0bin +/usr/bin +%\0cd\0func +~/func +%\0cd\0 +%\0cd\0pub +%\0pwd +/u/pfalstad/pub +%\0ls\0-d\0/usr/pub +/usr/pub +.De +\fBPATH\fP and \fBpath\fP both set the search path for commands. +These two variables are equivalent, except that one is a string +and one is an array. If the user modifies \fBPATH\fP, the shell +changes \fBpath\fP as well, and vice versa. +.Ds +%\0PATH=/bin:/usr/bin:/tmp:. +%\0echo\0$path +/bin\0/usr/bin\0/tmp\0. +%\0path=(\0/usr/bin\0.\0/usr/local/bin\0/usr/ucb\0) +%\0echo\0$PATH +/usr/bin:.:/usr/local/bin:/usr/ucb +.De +The same is true of \fBCDPATH\fP and \fBcdpath\fP: +.Ds +%\0echo\0$CDPATH +/usr:/u/pfalstad:/u/pfalstad/zsh +%\0CDPATH=/u/subbarao:/usr/src:/tmp +%\0echo\0$cdpath +/u/subbarao\0/usr/src\0/tmp +.De +In general, predefined parameters with names in all lowercase are +arrays; assignments to them take the form: +.Ds +\fIname\fR\fC=(\fR\0\fIelem\fR\0...\\0\fC)\fR +.De +Predefined parameters with names in all uppercase are strings. If +there is both an array and a string version of the same parameter, the +string version is a colon-separated list, like \fBPATH\fP. +.PP +\fBHISTFILE\fP is the name of the history file, where the history +is saved when a shell exits. +.Ds +%\0zsh +phoenix%\0HISTFILE=/tmp/history +phoenix%\0SAVEHIST=20 +phoenix%\0echo\0foo +foo +phoenix%\0date +Fri\0May\024\005:39:35\0EDT\01991 +phoenix%\0uptime +\0\05:39am\0\0up\04\0days,\020:02,\0\040\0users,\0\0load\0average:\02.30,\02.20,\02.00 +phoenix%\0exit +%\0cat\0/tmp/history +HISTFILE=/tmp/history +SAVEHIST=20 +echo\0foo +date +uptime +exit +%\0HISTSIZE=3 +%\0history +\0\0\028\0\0rm\0/tmp/history +\0\0\029\0\0HISTSIZE=3 +\0\0\030\0\0history +.De +If you have several incantations of \fBzsh\fP running at the same +time, like when using the X window system, it might be preferable to +append the history of each shell to a file when a shell exits instead +of overwriting the old contents of the file. You can get this +behaviour by setting the \fIAPPENDHISTORY\fP option. +.PP +In \fBzsh\fP, if you say +.Ds +%\0>file +.De +the command \fCcat\fP is normally assumed: +.Ds +%\0>file +foo!\0\0\0\0 +^D +%\0cat\0file +foo! +.De +Thus, you can view a file simply by typing: +.Ds +%\0<file +foo! +.De +However, this is not csh or sh compatible. To correct this, +change the value of the parameter \fBNULLCMD\fP, +which is \fCcat\fP by default. +.Ds +%\0NULLCMD=: +%\0>file +%\0ls\0-l\0file +-rw-r--r--\0\01\0pfalstad\0\0\0\0\0\0\0\00\0May\024\005:41\0file +.De +If \fCNULLCMD\fP is unset, the shell reports an error if no +command is specified (like csh). +.Ds +%\0unset\0NULLCMD +%\0>file +zsh:\0redirection\0with\0no\0command +.De +Actually, \fBREADNULLCMD\fP is used whenever you have a null command +reading input from a single file. Thus, you can set \fBREADNULLCMD\fP +to \fCmore\fP or \fCless\fP rather than \fCcat\fP. Also, if you +set \fBNULLCMD\fP to \fC:\fP for sh compatibility, you can still read +files with \fC< file\fP if you leave \fBREADNULLCMD\fP set to \fCmore\fP. +.Sh "Prompting" +.PP +The default prompt for \fBzsh\fP is: +.Ds +phoenix%\0echo\0$PROMPT +%m%#\0 +.De +The \fC%m\fP stands for the short form of the current hostname, +and the \fC%#\fP stands for a \fC%\fP or a \fC#\fP, depending on whether +the shell is running as root or not. +\fBzsh\fP supports many other control sequences +in the \fBPROMPT\fP variable. +.Ds +%\0PROMPT='%/>\0' +/u/pfalstad/etc/TeX/zsh> + +%\0PROMPT='%~>\0'\0\0\0 +~/etc/TeX/zsh>\0 + +%\0PROMPT='%h\0%~>\0' +6\0~/etc/TeX/zsh>\0 +.De +\fC%h\fP\0represents\0the\0number\0of\0current\0history\0event. +.Ds +%\0PROMPT='%h\0%~\0%M>\0' +10\0~/etc/TeX/zsh\0apple-gunkies.gnu.ai.mit.edu>\0 + +%\0PROMPT='%h\0%~\0%m>\0' +11\0~/etc/TeX/zsh\0apple-gunkies>\0 + +%\0PROMPT='%h\0%t>\0' +12\06:11am>\0 + +%\0PROMPT='%n\0%w\0tty%l>' +pfalstad\0Fri\024\0ttyp0> +.De +\fBPROMPT2\fP is used in multiline commands, like for-loops. The +\fC%_\fP escape sequence was made especially for this prompt. It is +replaced by the kind of command that is being entered. +.Ds +%\0PROMPT2='%_>\0' +%\0for\0i\0in\0foo\0bar +for> + +%\0echo\0'hi +quote> +.De +Also available is the \fBRPROMPT\fP parameter. +If this is set, the shell puts a prompt on the \fIright\fP side +of the screen. +.Ds +%\0RPROMPT='%t' +%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\06:14am + +%\0RPROMPT='%~' +%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0~/etc/TeX/zsh + +%\0PROMPT='%l\0%T\0%m[%h]\0'\0RPROMPT='\0%~' +p0\06:15\0phoenix[5]\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0~/etc/TeX/zsh +.De +These special escape sequences can also be used with the +\fC-P\fP option to \fCprint\fP: +.Ds +%\0print\0-P\0%h\0tty%l +15\0ttyp1 +.De +.PP +The \fBPOSTEDIT\fP parameter is printed whenever the editor exits. +This can be useful for termcap tricks. To highlight the prompt +and command line while leaving command output unhighlighted, try this: +.Ds +%\0POSTEDIT=`echotc\0se` +%\0PROMPT='%S%%\0' +.De +.Sh "Login/logout watching" +.PP +You can specify login or logout events to monitor +by setting the \fBwatch\fP variable. +Normally, this is done by specifying a list of usernames. +.Ds +%\0watch=(\0pfalstad\0subbarao\0sukthnkr\0egsirer\0) +.De +The \fClog\fP command reports all people logged in +that you are watching for. +.Ds +%\0log +pfalstad\0has\0logged\0on\0p0\0from\0mickey. +pfalstad\0has\0logged\0on\0p5\0from\0mickey. +%\0\fR...\fC +subbarao\0has\0logged\0on\0p8\0from\0phoenix. +%\0\fR...\fC +subbarao\0has\0logged\0off\0p8\0from\0phoenix. +%\0\fR...\fC +sukthnkr\0has\0logged\0on\0p8\0from\0dew. +%\0\fR...\fC +sukthnkr\0has\0logged\0off\0p8\0from\0dew. +.De +If you specify hostnames with an \fC@\fP prepended, +the shell will watch for all users logging in from +the specified host. +.Ds +%\0watch=(\0@mickey\0@phoenix\0) +%\0log +djthongs\0has\0logged\0on\0q2\0from\0phoenix. +pfalstad\0has\0logged\0on\0p0\0from\0mickey. +pfalstad\0has\0logged\0on\0p5\0from\0mickey. +.De +If you give a tty name with a \fC%\fP prepended, the shell +will watch for all users logging in on that tty. +.Ds +%\0watch=(\0%ttyp0\0%console\0) +%\0log +root\0has\0logged\0on\0console\0from\0. +pfalstad\0has\0logged\0on\0p0\0from\0mickey. +.De +The format of the reports may also be changed. +.Ds +%\0watch=(\0pfalstad\0gettes\0eps\0djthongs\0jcorr\0bdavis\0) +%\0log +jcorr\0has\0logged\0on\0tf\0from\0128.112.176.3:0. +jcorr\0has\0logged\0on\0r0\0from\0128.112.176.3:0. +gettes\0has\0logged\0on\0p4\0from\0yo:0.0. +djthongs\0has\0logged\0on\0pe\0from\0grumpy:0.0. +djthongs\0has\0logged\0on\0q2\0from\0phoenix. +bdavis\0has\0logged\0on\0qd\0from\0BRUNO. +eps\0has\0logged\0on\0p3\0from\0csx30:0.0. +pfalstad\0has\0logged\0on\0p0\0from\0mickey. +pfalstad\0has\0logged\0on\0p5\0from\0mickey. +%\0WATCHFMT='%n\0on\0tty%l\0from\0%M' +%\0log +jcorr\0on\0ttytf\0from\0128.112.176.3:0. +jcorr\0on\0ttyr0\0from\0128.112.176.3:0. +gettes\0on\0ttyp4\0from\0yo:0.0 +djthongs\0on\0ttype\0from\0grumpy:0.0 +djthongs\0on\0ttyq2\0from\0phoenix.Princeto +bdavis\0on\0ttyqd\0from\0BRUNO.pppl.gov +eps\0on\0ttyp3\0from\0csx30:0.0 +pfalstad\0on\0ttyp0\0from\0mickey.Princeton +pfalstad\0on\0ttyp5\0from\0mickey.Princeton +%\0WATCHFMT='%n\0fm\0%m' +%\0log +jcorr\0fm\0128.112.176.3:0 +jcorr\0fm\0128.112.176.3:0 +gettes\0fm\0yo:0.0 +djthongs\0fm\0grumpy:0.0 +djthongs\0fm\0phoenix +bdavis\0fm\0BRUNO +eps\0fm\0csx30:0.0 +pfalstad\0fm\0mickey +pfalstad\0fm\0mickey +%\0WATCHFMT='%n\0%a\0at\0%t\0%w.' +%\0log +jcorr\0logged\0on\0at\03:15pm\0Mon\020. +jcorr\0logged\0on\0at\03:16pm\0Wed\022. +gettes\0logged\0on\0at\06:54pm\0Wed\022. +djthongs\0logged\0on\0at\07:19am\0Thu\023. +djthongs\0logged\0on\0at\07:20am\0Thu\023. +bdavis\0logged\0on\0at\012:40pm\0Thu\023. +eps\0logged\0on\0at\04:19pm\0Thu\023. +pfalstad\0logged\0on\0at\03:39am\0Fri\024. +pfalstad\0logged\0on\0at\03:42am\0Fri\024. +.De +If you have a \fC.friends\fP file in your home directory, +a convenient way to make \fBzsh\fP watch for all your friends +is to do this: +.Ds +%\0watch=(\0$(<\0~/.friends)\0) +%\0echo\0$watch +subbarao\0maruchck\0root\0sukthnkr\0\fR... +.De +If watch is set to \fCall\fP, then all users logging in or out +will be reported. +.Sh "Options" +.PP +Some options have already been mentioned; here are a few more: +.PP +Using the \fIAUTOCD\fP option, you can simply type the name +of a directory, and it will become the current directory. +.Ds +%\0cd\0/ +%\0setopt\0autocd +%\0bin +%\0pwd +/bin +%\0../etc +%\0pwd +/etc +.De +With \fICDABLEVARS\fP, if the argument to \fCcd\fP is the name of a +parameter whose value is a valid directory, it will become +the current directory. +.Ds +%\0setopt\0cdablevars +%\0foo=/tmp +%\0cd\0foo +/tmp +.De +\fICORRECT\fP turns on spelling correction for commands, +and the \fICORRECTALL\fP option turns on spelling correction +for all arguments. +.Ds +%\0setopt\0correct +%\0sl +zsh:\0correct\0`sl'\0to\0`ls'\0[nyae]?\0y +%\0setopt\0correctall +%\0ls\0x.v11r4 +zsh:\0correct\0`x.v11r4'\0to\0`X.V11R4'\0[nyae]?\0n +/usr/princton/src/x.v11r4\0not\0found +%\0ls\0/etc/paswd +zsh:\0correct\0to\0`/etc/paswd'\0to\0`/etc/passwd'\0[nyae]?\0y +/etc/passwd +.De +If you press \fCy\fP +when the shell asks you if you want to correct a word, it will +be corrected. If you press \fCn\fP, it will be left alone. +Pressing \fCa\fP aborts the command, and pressing \fCe\fP brings the line +up for editing again, in case you agree the word is spelled wrong +but you don't like the correction. +.PP +Normally, a quoted expression may contain a newline: +.Ds +%\0echo\0' +>\0foo +>\0' + +foo + +% +.De +With \fICSHJUNKIEQUOTES\fP set, this is illegal, as it is +in csh. +.Ds +%\0setopt\0cshjunkiequotes +%\0ls\0'foo +zsh:\0unmatched\0' +.De +\fIGLOBDOTS\fP lets files beginning with a \fC.\fP be matched without +explicitly specifying the dot. +.Ds +%\0ls\0-d\0*x* +Mailboxes +%\0setopt\0globdots +%\0ls\0-d\0*x* +\&.exrc\0\0\0\0\0\0\0\0\0.pnewsexpert\0\0.xserverrc +\&.mushexpert\0\0\0.xinitrc\0\0\0\0\0\0Mailboxes +.De +\fIHISTIGNOREDUPS\fP prevents the current line from being +saved in the history if it is the same as the previous one; +\fIHISTIGNORESPACE\fP prevents the current line from being +saved if it begins with a space. +.Ds +%\0PROMPT='%h>\0' +39>\0setopt\0histignoredups +40>\0echo\0foo +foo +41>\0echo\0foo +foo +41>\0echo\0foo +foo +41>\0echo\0bar +bar +42>\0setopt\0histignorespace +43>\0\0echo\0foo +foo +43>\0\0echo\0fubar +fubar +43>\0\0echo\0fubar +fubar +.De +\fIIGNOREBRACES\fP turns off csh-style brace expansion. +.Ds +%\0echo\0x{y{z,a},{b,c}d}e +xyze\0xyae\0xbde\0xcde +%\0setopt\0ignorebraces +%\0echo\0x{y{z,a},{b,c}d}e +x{y{z,a},{b,c}d}e +.De +\fIIGNOREEOF\fP forces the user to type \fCexit\fP or \fClogout\fP, +instead of just pressing \fI^D\fP. +.Ds +%\0setopt\0ignoreeof +%\0^D +zsh:\0use\0'exit'\0to\0exit. +.De +\fIINTERACTIVECOMMENTS\fP turns on interactive comments; +comments begin with a \fC#\fP. +.Ds +%\0setopt\0interactivecomments +%\0date\0#\0this\0is\0a\0comment +Fri\0May\024\006:54:14\0EDT\01991 +.De +\fINOBEEP\fP makes sure the shell never beeps. +.PP +\fINOCLOBBER\fP prevents you from accidentally +overwriting an existing file. +.Ds +%\0setopt\0noclobber +%\0cat\0/dev/null\0>~/.zshrc +zsh:\0file\0exists:\0/u/pfalstad/.zshrc +.De +If you really do want to clobber a file, you can use the +\fC>!\fP operator. +To make things easier in this case, the \fC>\fP is stored in +the history list as a \fC>!\fP: +.Ds +%\0cat\0/dev/null\0>!\0~/.zshrc +%\0cat\0/etc/motd\0>\0~/.zshrc +zsh:\0file\0exists:\0/u/pfalstad/.zshrc +%\0!! +cat\0/etc/motd\0>!\0~/.zshrc +%\0\fR... +.De +\fIRCQUOTES\fP lets you use a more elegant method for including +single quotes in a singly quoted string: +.Ds +%\0echo\0'"don'\e''t\0do\0that."' +"don't\0do\0that." +%\0echo\0'"don''t\0do\0that."' +"dont\0do\0that." +%\0setopt\0rcquotes +%\0echo\0'"don''t\0do\0that."' +"don't\0do\0that." +.De +Finally, +\fISUNKEYBOARDHACK\fP wins the award for the strangest option. +If a line ends with \fC`\fP, and there are an odd number of them +on the line, the shell will ignore the trailing \fC`\fP. This +is provided for keyboards whose RETURN key is too small, +and too close to the \fC`\fP key. +.Ds +%\0setopt\0sunkeyboardhack +%\0date` +Fri\0May\024\006:55:38\0EDT\01991 +.De +.Sh "Closing Comments" +.PP +I (Bas de Bakker) would be happy to receive mail if anyone has any +tricks or ideas to add to this document, or if there are some points +that could be made clearer or covered more thoroughly. Please notify +me of any errors in this document. +.if o \{\ +.bp +.sv 1i +.\} +.pn 1 +.bp +.PX diff --git a/Doc/zmacros.yo b/Doc/zmacros.yo new file mode 100644 index 000000000..c6df3d551 --- /dev/null +++ b/Doc/zmacros.yo @@ -0,0 +1,32 @@ +STARTDEF() + +DEFINEMACRO(includefile)(1)(\ + TYPEOUT(Including file ARG1)\ + comment(Yodl file: ARG1)NL()\ + INCLUDEFILE(ARG1)\ +) + +DEFINEMACRO(def)(3)(\ + DEFINEMACRO(ARG1)(ARG2)(ARG3)\ +) +DEFINEMACRO(undef)(1)(\ + UNDEFINEMACRO(ARG1)\ +) +DEFINEMACRO(redef)(3)(\ + UNDEFINEMACRO(ARG1)\ + DEFINEMACRO(ARG1)(ARG2)(ARG3)\ +) + +DEFINEMACRO(LPAR)(0)(CHAR(40)) +DEFINEMACRO(RPAR)(0)(CHAR(41)) +DEFINEMACRO(PLUS)(0)(CHAR(+)) + +DEFINEMACRO(NL)(0)( +) + +DEFINEMACRO(ifzman)(1)() +DEFINEMACRO(ifnzman)(1)(ARG1) +DEFINEMACRO(ifztexi)(1)() +DEFINEMACRO(ifnztexi)(1)(ARG1) + +ENDDEF() diff --git a/Doc/zman.yo b/Doc/zman.yo new file mode 100644 index 000000000..7d7fc120e --- /dev/null +++ b/Doc/zman.yo @@ -0,0 +1,192 @@ +STARTDEF() + +TYPEOUT(Zsh Yodl-to-man converter) +DEFINESYMBOL(zman) + +INCLUDEFILE(zmacros) +redef(ifzman)(1)(ARG1) +redef(ifnzman)(1)() + +def(CMT)(0)(NOTRANS(.')) + +COMMENT(--- character translation ---) + +DEFINECHARTABLE(standard)( + '' = ".' (avoiding a yodl bug)" + '\\' = "\\e" + '.' = "\\&." + '-' = "\\-" +) +USECHARTABLE(standard) + +def(STDPAR)(0)(\ + redef(PARAGRAPH)(0)(NL()NOTRANS(.PP)NL())\ +) + +COMMENT(--- emphasised text ---) + +def(em)(1)(NOTRANS(\fI)ARG1NOTRANS(\fP)) +def(bf)(1)(NOTRANS(\fB)ARG1NOTRANS(\fP)) +def(tt)(1)(NOTRANS(\fB)ARG1NOTRANS(\fP)) +def(var)(1)(NOTRANS(\fI)ARG1NOTRANS(\fP)) + +COMMENT(--- man page headers ---) + +def(manpage)(4)(\ + NOTRANS(.TH ")ARG1" "ARG2" "ARG3" "ARG4"\ +) +def(manpagename)(2)(\ + sect(NAME)NL()\ + ARG1 - ARG2\ +) + +COMMENT(--- TeXinfo headers and conditionals ---) + +def(texinfo)(2)(CMT()) + +def(texiifinfo)(1)() +def(texiiftex)(1)() + +def(texipage)(0)(CMT()) +def(texititlepage)(0)(CMT()) +def(texiendtitlepage)(0)(CMT()) +def(texititle)(1)(CMT()) +def(texisubtitle)(1)(CMT()) +def(texiauthor)(1)(CMT()) + +def(texinode)(4)(CMT()) +def(texitop)(1)(CMT()) + +COMMENT(--- section divisions ---) + +def(chapter)(1)(CMT()) + +def(sect)(1)(\ + NOTRANS(.SH ")UPPERCASE(ARG1)(0)"NL()\ + STDPAR()\ + CMT()\ +) + +def(subsect)(1)(\ + NOTRANS(.SS ")ARG1"NL()\ + CMT()\ +) + +COMMENT(--- comment output ---) + +DEFINECHARTABLE(roffcomment)( + '\n' = "\n.\\\" " +) +def(comment)(1)(\ + USECHARTABLE(roffcomment)\ + NOTRANS(.\" )ARG1\ + USECHARTABLE(standard)\ +) + +COMMENT(--- cross-references ---) + +def(manref)(2)(\ + NOTRANS(\fI)ARG1NOTRANS(\fP)(ARG2)\ +) +def(zmanref)(1)(manref(ARG1)(1)) +def(noderef)(1)(the section `ARG1') + +COMMENT(--- lists ---) + +def(startitem)(0)(\ + NOTRANS(.PD 0)\ + redef(ITEM)(0)(NOTRANS(.PD)NL())\ +) +def(enditem)(0)(\ + ENDITEM()\ + STDPAR()\ + redef(ENDITEM)(0)(NOTRANS(.RE)STDPAR())\ +) +def(item)(2)(\ + NOTRANS(.TP)NL()\ + ITEM()\ + redef(ITEM)(0)()\ + ARG1\ + redef(ENDITEM)(0)(CMT())\ + redef(PARAGRAPH)(0)(\ + NL()NOTRANS(.RS)NL()NOTRANS(.PP)NL()\ + STDPAR()\ + redef(ENDITEM)(0)(NOTRANS(.RE)STDPAR())\ + )\ + ARG2\ + ENDITEM()\ +) +def(xitem)(1)(\ + NOTRANS(.TP)NL()\ + NOTRANS(.PD 0)NL()\ + redef(ITEM)(0)(NOTRANS(.PD)NL())\ + ARG1\ +) + +def(startsitem)(0)(\ + NOTRANS(.PD 0)\ +) +def(endsitem)(0)(\ + NOTRANS(.PD)\ +) +def(sitem)(2)(\ + NOTRANS(.TP)NL()\ + ARG1NL()\ + ARG2\ +) +def(sxitem)(1)(\ + NOTRANS(.TP)NL()\ + ARG1\ +) + +def(startlist)(0)(\ + NOTRANS(.PD 0)\ +) +def(endlist)(0)(\ + NOTRANS(.PD)\ +) +def(list)(1)(\ + NOTRANS(.TP)NL()\ + ARG1\ +) + +def(startitemize)(0)(\ + startitem()\ +) +def(enditemize)(0)(\ + enditem()\ +) +def(itemiz)(1)(\ + item(NOTRANS(\)LPAR()NOTRANS(bu))(NL()ARG1NL())\ +) + +COMMENT(--- special effects ---) + +def(nofill)(1)(\ + NOTRANS(.nf)NL()\ + ARG1\ + NL()NOTRANS(.fi)\ +) + +def(indent)(1)(\ + NOTRANS(.RS)\ + ARG1\ + NOTRANS(.RE)\ +) + +COMMENT(--- hyperlink menus ---) + +def(startmenu)(0)(CMT()) +def(endmenu)(0)(CMT()) +def(menu)(1)(CMT()) + +COMMENT(--- indices ---) + +def(cindex)(1)(CMT()) +def(findex)(1)(CMT()) +def(kindex)(1)(CMT()) +def(pindex)(1)(CMT()) +def(tindex)(1)(CMT()) +def(vindex)(1)(CMT()) + +ENDDEF()\ diff --git a/Doc/zsh.yo b/Doc/zsh.yo new file mode 100644 index 000000000..a97f023e7 --- /dev/null +++ b/Doc/zsh.yo @@ -0,0 +1,83 @@ +ifzman(\ +IFDEF(ZSHALL)(\ +def(ifzshone)(1)()\ +def(ifzshall)(1)(ARG1)\ +manpage(ZSHALL)(1)(date())(zsh version()) +manpagename(zshall)(the Z shell meta-man page) +)(\ +def(ifzshone)(1)(ARG1)\ +def(ifzshall)(1)()\ +manpage(ZSH)(1)(date())(zsh version()) +manpagename(zsh)(the Z shell) +)\ +)\ +ifnzman(\ +def(ifzshone)(1)()\ +def(ifzshall)(1)()\ +)\ +ifztexi(\ +texinfo(zsh.info)(zsh) +NOTRANS(@setchapternewpage odd +@iftex +@finalout +@afourpaper +@end iftex) +texititlepage() +texititle(The Z Shell Guide) +texisubtitle(Version version()) +texisubtitle(Updated date()) +texiauthor(Original documentation by Paul Falstad) +texipage() +This is a texinfo version of the documentation for the Z Shell, originally by +Paul Falstad. + +Permission is granted to make and distribute verbatim copies of +this manual provided the copyright notice and this permission notice +are preserved on all copies. + +Permission is granted to copy and distribute modified versions of this +manual under the conditions for verbatim copying, provided also that the +entire resulting derived work is distributed under the terms of a +permission notice identical to this one. + +Permission is granted to copy and distribute translations of this manual +into another language, under the above conditions for modified versions. +texiendtitlepage() +)\ +ifnzman(includefile(Zsh/guide.yo)) +includefile(Zsh/intro.yo) +includefile(Zsh/invoke.yo) +includefile(Zsh/files.yo) +ifnzman(includefile(Zsh/grammar.yo)) +ifnzman(includefile(Zsh/redirect.yo)) +ifnzman(includefile(Zsh/exec.yo)) +ifnzman(includefile(Zsh/func.yo)) +ifnzman(includefile(Zsh/jobs.yo)) +ifnzman(includefile(Zsh/arith.yo)) +ifnzman(includefile(Zsh/cond.yo)) +ifnzman(includefile(Zsh/compat.yo)) +ifnzman(includefile(Zsh/prompt.yo)) +ifnzman(includefile(Zsh/restricted.yo)) +ifnzman(includefile(Zsh/expn.yo)) +ifnzman(includefile(Zsh/params.yo)) +ifnzman(includefile(Zsh/options.yo)) +ifnzman(includefile(Zsh/builtins.yo)) +ifnzman(includefile(Zsh/zle.yo)) +ifnzman(includefile(Zsh/compctl.yo)) +ifnzman(includefile(Zsh/modules.yo)) +ifzshall(\ +def(source)(1)(NOTRANS(.so )man1/ARG1NOTRANS(.)1)\ +CMT() +source(zshmisc) +source(zshexpn) +source(zshparam) +source(zshoptions) +source(zshbuiltins) +source(zshzle) +source(zshcompctl) +source(zshmodules) +manpage(ZSHALL)(1)(date())(zsh version()) +)\ +ifzman(includefile(Zsh/filelist.yo)) +ifzman(includefile(Zsh/seealso.yo)) +ifnzman(includefile(Zsh/index.yo)) diff --git a/Doc/zshbuiltins.yo b/Doc/zshbuiltins.yo new file mode 100644 index 000000000..557ba7995 --- /dev/null +++ b/Doc/zshbuiltins.yo @@ -0,0 +1,3 @@ +manpage(ZSHBUILTINS)(1)(date())(zsh version()) +manpagename(zshbuiltins)(zsh built-in commands) +includefile(Zsh/builtins.yo) diff --git a/Doc/zshcompctl.yo b/Doc/zshcompctl.yo new file mode 100644 index 000000000..3e3bedf5a --- /dev/null +++ b/Doc/zshcompctl.yo @@ -0,0 +1,3 @@ +manpage(ZSHCOMPCTL)(1)(date())(zsh version()) +manpagename(zshcompctl)(zsh programmable completion) +includefile(Zsh/compctl.yo) diff --git a/Doc/zshexpn.yo b/Doc/zshexpn.yo new file mode 100644 index 000000000..aa8decebb --- /dev/null +++ b/Doc/zshexpn.yo @@ -0,0 +1,3 @@ +manpage(ZSHEXPN)(1)(date())(zsh version()) +manpagename(zshexpn)(zsh expansion and substitution) +includefile(Zsh/expn.yo) diff --git a/Doc/zshmisc.yo b/Doc/zshmisc.yo new file mode 100644 index 000000000..332df1e25 --- /dev/null +++ b/Doc/zshmisc.yo @@ -0,0 +1,12 @@ +manpage(ZSHMISC)(1)(date())(zsh version()) +manpagename(zshmisc)(everything and then some) +includefile(Zsh/grammar.yo) +includefile(Zsh/redirect.yo) +includefile(Zsh/exec.yo) +includefile(Zsh/func.yo) +includefile(Zsh/jobs.yo) +includefile(Zsh/arith.yo) +includefile(Zsh/cond.yo) +includefile(Zsh/compat.yo) +includefile(Zsh/prompt.yo) +includefile(Zsh/restricted.yo) diff --git a/Doc/zshmodules.yo b/Doc/zshmodules.yo new file mode 100644 index 000000000..9def096ca --- /dev/null +++ b/Doc/zshmodules.yo @@ -0,0 +1,3 @@ +manpage(ZSHMODULES)(1)(date())(zsh version()) +manpagename(zshmodules)(zsh loadable modules) +includefile(Zsh/modules.yo) diff --git a/Doc/zshoptions.yo b/Doc/zshoptions.yo new file mode 100644 index 000000000..266d32ac0 --- /dev/null +++ b/Doc/zshoptions.yo @@ -0,0 +1,3 @@ +manpage(ZSHOPTIONS)(1)(date())(zsh version()) +manpagename(zshoptions)(zsh options) +includefile(Zsh/options.yo) diff --git a/Doc/zshparam.yo b/Doc/zshparam.yo new file mode 100644 index 000000000..ac39e9267 --- /dev/null +++ b/Doc/zshparam.yo @@ -0,0 +1,3 @@ +manpage(ZSHPARAM)(1)(date())(zsh version()) +manpagename(zshparam)(zsh parameters) +includefile(Zsh/params.yo) diff --git a/Doc/zshzle.yo b/Doc/zshzle.yo new file mode 100644 index 000000000..66e1d588f --- /dev/null +++ b/Doc/zshzle.yo @@ -0,0 +1,3 @@ +manpage(ZSHZLE)(1)(date())(zsh version()) +manpagename(zshzle)(zsh command line editor) +includefile(Zsh/zle.yo) diff --git a/Doc/ztexi.yo b/Doc/ztexi.yo new file mode 100644 index 000000000..b8e115ec0 --- /dev/null +++ b/Doc/ztexi.yo @@ -0,0 +1,246 @@ +STARTDEF() + +TYPEOUT(Zsh Yodl-to-TeXinfo converter) +DEFINESYMBOL(ztexi) + +INCLUDEFILE(zmacros) +redef(ifztexi)(1)(ARG1) +redef(ifnztexi)(1)() + +def(CMT)(0)(NOTRANS(@c)) + +ATEXIT(\ + NL()\ + NOTRANS(@setchapternewpage odd)NL()\ + NOTRANS(@contents)NL()\ + NOTRANS(@bye)NL()\ +) + +COMMENT(--- character translation ---) + +DEFINECHARTABLE(standard)( + '' = "@c (avoiding a yodl bug)" + '@' = "@@" + '{' = "@{" + '}' = "@}" +) +USECHARTABLE(standard) +SUBST('')(NOTRANS(@value{dsq})) + +def(STDPAR)(0)(redef(PARAGRAPH)(0)(NL()NL()NOTRANS(@noindent)NL())) + +COMMENT(--- emphasised text ---) + +def(em)(1)(NOTRANS(@emph{)ARG1NOTRANS(})) +def(bf)(1)(NOTRANS(@cite{)ARG1NOTRANS(})) +def(tt)(1)(NOTRANS(@code{)ARG1NOTRANS(})) +def(var)(1)(NOTRANS(@var{)ARG1NOTRANS(})) + +COMMENT(--- man page headers ---) + +def(manpage)(4)(STDPAR()) +def(manpagename)(2)() + +COMMENT(--- TeXinfo headers and conditionals ---) + +def(texinfo)(2)(\ + STDPAR()\ + NOTRANS(\input texinfo.tex)NL()\ + NOTRANS(@c %**start of header)NL()\ + NOTRANS(@setfilename )ARG1NL()\ + NOTRANS(@settitle )ARG2NL()\ + NOTRANS(@c %**end of header)NL()\ + NL()\ + NOTRANS(@ifinfo)NL()\ + NOTRANS(@set dsq @'@')NL()\ + NOTRANS(@end ifinfo)NL()\ + NOTRANS(@iftex)NL()\ + NOTRANS(@set dsq '{}')NL()\ + NOTRANS(@end iftex)NL()\ +) + +def(texiifinfo)(1)(\ + NOTRANS(@ifinfo)NL()\ + ARG1\ + NOTRANS(@end ifinfo)NL()\ +) +def(texiiftex)(1)(\ + NOTRANS(@iftex)NL()\ + ARG1\ + NOTRANS(@end iftex)NL()\ +) + +def(texipage)(0)(\ + NOTRANS(@page)\ +) +def(texititlepage)(0)(\ + NOTRANS(@titlepage)\ +) +def(texiendtitlepage)(0)(\ + NOTRANS(@end titlepage)\ +) +def(texititle)(1)(\ + NOTRANS(@title )ARG1\ +) +def(texisubtitle)(1)(\ + NOTRANS(@subtitle )ARG1\ +) +def(texiauthor)(1)(\ + NOTRANS(@author )ARG1\ +) + +def(texinode)(4)(\ + NOTRANS(@node )ARG1, ARG2, ARG3, ARG4\ +) +def(texitop)(1)(\ + NOTRANS(@top )ARG1\ +) + +COMMENT(--- section divisions ---) + +def(chapter)(1)(\ + NL()\ + NOTRANS(@chapter )ARG1NL()\ + NOTRANS(@noindent)\ +) + +def(sect)(1)(\ + NL()\ + NOTRANS(@section )ARG1NL()\ + NOTRANS(@noindent)\ +) + +def(subsect)(1)(\ + NL()\ + NOTRANS(@subsection )ARG1NL()\ + NOTRANS(@noindent)\ +) + +COMMENT(--- comment output ---) + +DEFINECHARTABLE(texicomment)( + '\n' = "\n@c " +) +def(comment)(1)(\ + USECHARTABLE(texicomment)\ + NOTRANS(@c )ARG1\ + USECHARTABLE(standard)\ +) + +COMMENT(--- cross-references ---) + +def(manref)(2)(man page ARG1LPAR()ARG2RPAR()) +def(zmanref)(1)(manref(ARG1)(1)) +def(noderef)(1)(\ + NOTRANS(@ref{)ARG1NOTRANS(})\ +) + +COMMENT(--- lists ---) + +def(startitem)(0)(\ + NOTRANS(@table @asis)\ + redef(ITEMX)(0)()\ +) +def(enditem)(0)(\ + NOTRANS(@end table)\ +) +def(item)(2)(\ + NOTRANS(@item)ITEMX() ARG1\ + ARG2\ + redef(ITEMX)(0)()\ +) +def(xitem)(1)(\ + NOTRANS(@item)ITEMX() ARG1\ + redef(ITEMX)(0)(x)\ +) + +def(startsitem)(0)(\ + startitem()\ +) +def(endsitem)(0)(\ + enditem()\ +) +def(sitem)(2)(\ + item(ARG1)(NL()ARG2)\ +) +def(sxitem)(1)(\ + xitem(ARG1)\ +) + +def(startlist)(0)(\ + startitem()\ +) +def(endlist)(0)(\ + enditem()\ +) +def(list)(1)(\ + item(ARG1)()\ +) + +def(startitemize)(0)(\ + NOTRANS(@itemize @bullet)NL()\ +) +def(enditemize)(0)(\ + NOTRANS(@end itemize)\ +) +def(itemiz)(1)(\ + sitem()(ARG1)\ +) + +COMMENT(--- special effects ---) + +DEFINECHARTABLE(nofillchars)( + '@' = "@@" + '{' = "@{" + '}' = "@}" + '\n' = "@*\n" +) +def(nofill)(1)(\ + USECHARTABLE(nofillchars)\ + ARG1\ + USECHARTABLE(standard)\ +) + +def(indent)(1)(\ + ARG1\ +) + +COMMENT(--- hyperlink menus ---) + +def(startmenu)(0)(\ + NOTRANS(@menu)\ +) +def(endmenu)(0)(\ + NOTRANS(@end menu)\ +) +def(menu)(1)(\ + * ARG1NOTRANS(::)\ +) + +COMMENT(--- indices ---) + +def(cindex)(1)(\ + NOTRANS(@cindex )ARG1\ +) + +def(findex)(1)(\ + NOTRANS(@findex )ARG1\ +) + +def(kindex)(1)(\ + NOTRANS(@kindex )ARG1\ +) + +def(pindex)(1)(\ + NOTRANS(@pindex )ARG1\ +) + +def(tindex)(1)(\ + NOTRANS(@tindex )ARG1\ +) + +def(vindex)(1)(\ + NOTRANS(@vindex )ARG1\ +) + +ENDDEF()\ |