\documentclass{article}
% Needed for multiple column output:
\usepackage[a4paper,hmargin={2cm,2cm},vmargin={2cm,2cm},landscape]{geometry}
%\usepackage{a4wide}
%% \oddsidemargin 0.05 in
%% \evensidemargin 0.05 in
%% \marginparwidth 0.75 in
%% \voffset -0.6in
%% \hoffset -0.7in
%% \textheight 170 mm
%% \textwidth 280 mm
\usepackage[T2A]{fontenc}
\usepackage[koi8-r]{inputenc}
\usepackage[english,russian]{babel}
\usepackage{multicol}

% Used for easy swapping to landscape:
%\usepackage{portland}
% Needed for easy redefinition of running headings/page style:
\usepackage{fancyheadings}
% Needed for boldsymbol (distinguishes sorts of square brackets):
\usepackage{amsmath}
%% % Needed for complex if-then-else structures as used in Lentry
%% \usepackage{ifthen}
%% \usepackage{calc}

\lhead{Стр. \rm\thepage}
\chead{Справочная карта Zsh}
\rhead{zsh 3.0}
\cfoot{}

% Make the section command a little more manageable.
% This makes it look more like a normal subsection.
\makeatletter
\renewcommand{\section}{\@startsection
  {section}%                          % name
  {1}%                                % level
  {0mm}%                              % indent
  {-\baselineskip}%                   % beforeskip
  {0.1pt}%                 % afterskip
  {\normalfont\normalsize\scshape}} % style
\makeatother


% Command for environment that contains a piece of code.
\newcommand{\codelabel}[1]{\mbox{\textsl{#1}}\hfil}
\newenvironment{code}%
{\begin{list}{}{\renewcommand{\makelabel}{\codelabel}%
    \setlength{\rightmargin}{0pt}%
    \setlength{\leftmargin}{1em}}}%
{\end{list}}


\newcommand\B[1]{\textbf{#1}}
\newcommand\I[1]{\textsl{#1}}
\newcommand\T[1]{\texttt{#1}}

% Left/right square brackets in bold (actual text for syntax
% table, optional arguments in commands etc.)
\newcommand\Lsq{\ensuremath{\boldsymbol{[}}}
\newcommand\Rsq{\ensuremath{\boldsymbol{]}}}
% Left/right square brackets (indicates optional in syntax entries)
\newcommand\Lop{\ensuremath{[}}
\newcommand\Rop{\ensuremath{]}}
% Left/right curly brackets
\newcommand\Lcu{\ensuremath{\mathbf{\{}}}
\newcommand\Rcu{\ensuremath{\mathbf{\}}}}
% Left/right parentheses
\newcommand\Lpa{\textbf{(}}
\newcommand\Rpa{\textbf{)}}

% Dagger for marking things
\newcommand\D{$^\dag$}

\newlength{\codesep}
\setlength{\codesep}{1.5mm}

\parindent = 0pt
\raggedright

\begin{document}

% This is a bit simpler than using the portland package,
% and works with dvips.
\special{landscape}
%\landscape

\pagestyle{fancy}

\raggedcolumns
\setlength{\premulticols}{100pt}
%\setlength{\multicolsep}{20pt plus 6pt minus 4pt}
\begin{multicols}{3}[\section{Конструкции}]

\I{список}~-- это любая последовательность команд, разделенная \B{;} или
\B{newline}, которые всегда взаимозаменяемы.
\medskip

\begin{code}
\item \B{if} \I{список}; \B{then} \I{список} \\
\Lop\ \B{elif} \I{список}; \B{then} \I{список} \Rop\ \dots \\
\Lop\ \B{else} \I{список} \Rop \\
\B{fi} \\ ~

\item \B{for} \I{name} \Lop\ \B{in} \I{word \dots} \Rop \\
\B{do} \I{список} \\
\B{done} \\ ~

\B{for} \I{name} \B{in} \I{word \dots}; \Lcu\ list \Rcu 

\B{foreach} \I{name} \Lpa \I{word \dots}\Rpa \\
\I{список} \\
\B{end} \\

\item \B{while} \I{список}; \B{do} \I{список}; \B{done}

\B{until} \I{список}; \B{do} \I{список}; \B{done}

\item \B{repeat} \I{word}; \B{do} \I{список}; \B{done}

\B{repeat} \I{word} \I{sublist}

\item \B{case} \I{word} \B{in} \\
\Lop\ \I{pattern} \Rpa\ \I{список} ;; \Rop\ \dots \\
\B{esac}

\B{case} \I{word} \Lcu\ \Lop\ \I{pattern} \Rpa\ \I{список} ;; \Rop\ \dots \Rcu

\item \B{select} \I{name}
  \Lop\ \B{in} \I{word} \dots \Rop; \B{do} \I{список};
  done

\item[Порожденный командный процессор:] \Lpa\ \I{список} \Rpa

\item[Текущий командный процессор:] \Lcu\ \I{список} \Rcu

\item \B{function} \I{word} \Lop\ \Lpa\Rpa\ \Rop\ \dots \Lcu\ \I{список}
  \Rcu

\I{word} \dots \Lpa\Rpa\ \Lcu\ list \Rcu

\I{word} \dots \Lpa\Rpa\ \I{sublist}

\item \B{time} \Lop\ \I{pipeline} \Rop

\item[Условие:] \Lsq\Lsq\ \I{exp} \Rsq\Rsq
\end{code}

Другие конструкции зависят от настроек \B{NO\_\-SHORT\_\-LOOPS} and
\B{CSH\_\-JUNKIE\_\-LOOPS} и должны избегаться при использовании в скриптах.

\end{multicols}

%\begin{multicols}{3}[\section{Globbing}]
\section{Подстановки (Globbing)}

Также смотрите опции \B{GLOB}, \B{EXTENDED\_\-GLOB}, \B{KSH\_\-GLOB},
\B{NULL\_\-GLOB}, \B{NOMATCH}, \B{SH\_\-GLOB} \B{GLOB\_\-DOTS}. \texttt{X},
\texttt{Y}, \dots~-- любой образец (pattern). \verb!#! и \verb!##! требуют
группировки предыдущих символов; эти же и \verb!~!, \verb!^! требуют наличия
\B{EXTENDED\_\-GLOB}.

% Due to setting verbatim text, use basic tabbing environment for following.
\begin{multicols}{3}
\begin{tabbing}
\hskip 40pt \= \kill
\verb!*!       \>  Любая строка \\
\verb!?!       \>  Любой символ \\
\verb![...]!   \>  Любой из помещенных в скобки символов \\
\verb![[:X:]]! \>  Классы символов, где X может быть: \\
\verb! alnum!  \>  Цифры и буквы, \\
\verb! alpha!  \>  Буквы, \\
\verb! blank!  \>  Пробелы или табуляция, \\
\verb! cntrl!  \>  Управляющий символ, \\
\verb! digit!  \>  Десятичные цифры, \\
\verb! graph!  \>  Печатный, не пробельный символ, \\
\verb! lower!  \>  Символ в нижнем регистре, \\
\verb! print!  \>  Печатный символ, \\
\verb! punct!  \>  Печатный, не буква, цифра или пробел, \\
\verb! space!  \>  Пробельный символ, \\
\verb! upper!  \>  Символ в верхнем регистре, \\
\verb! xdigit! \>  Шестнадцатеричная цифра. \\
               \>  Вышеприведенные шаблоны используют \\
               \>  локаль, и могут быть скомбинированы \\
               \>  с другими символами, например \\
               \>  \verb![-+[:xdigit:]]! \\
\verb![^...]!  \>  Любой символ, исключая указанные в \\
               \>  скобках \\
\verb!<x-y>!   \>  Любое число между $x$ и $y$ включая: оба \\
               \>  числа необязательны, по умолчанию $0$, $\infty$ \\
\verb!^X!      \>  Все что не соответствует \texttt{X} \\
\verb!(X|Y)!   \>  Либо \texttt{X}, либо \texttt{Y} \\
\verb!X~Y!     \>  Шаблон \texttt{X}, но не \texttt{Y} \\
\verb!(X|Y~Z)! \>  Либо \texttt{X}, либо (\texttt{Y}, но не \texttt{Z}) \\
\verb!X#!      \>  Ноль или более вхождений \texttt{X} \\
\verb!X##!     \>  Одно или больше вхождений \texttt{X} \\
\verb!(X)!     \>  Группировка (частей) сегмента. \\
\verb!**/!     \>  (Как сегмент путевого имени) сокращение  \\
               \>  для \verb!(*/)!: соответствует всем подкаталогам \\
\verb!***/!    \>  Тоже самое, но следуя по символическим \\
               \>  ссылкам \\
\end{tabbing}

Флаги подстановки задаются в форме \verb!(#X)! и требуют наличия опции
\T{EXTENDED\_GLOB}.  Они могут появляться в группах.  \verb!X! может
быть следующими:
\begin{tabbing}
\hskip 40pt \= \kill
\verb!i!       \> Соответствие независимо от регистра \\
\verb!l!       \> Буквы в нижнем регистре соответствуют \\
               \> буквам в верхнем \\
\verb!I!       \> Чувствительность к регистру: отменяет \\
               \> действие \verb!i! и \verb!I! \\
\verb!b!       \> Включает обратные ссылки для скобок. \\
               \> Массивы \verb!$match!, \verb!$mbegin!, \verb!$mend! \\
               \> содержат соответствующие строки, \\
               \> индексы начала/конца \\
\verb!B!       \> Отключает обратные ссылки, отменяя \verb!b! \\
\verb!m!       \> Устанавливает \verb!$MATCH!, \verb!$MBEGIN!, \verb!$MEND! для
                  строк \\
\verb!M!       \> Отключает \verb!m!. \\
\T{a}\I{num}   \> Позволяет \I{num} ошибок в соответствии \\
               \> (для отключения задайте 0) \\
\verb!s!       \> Соответствие только в начале строки \\
               \> (используйте в ????param expn) \\
\verb!e!       \> Соответствие только в конце строки \\
\end{tabbing}

Модификаторы подстановки указываются в скобках после шаблона (обычно с
операцией \I{and}):
\begin{tabbing}
\hskip 40pt \= \kill
\verb!/!       \> каталог \\
\verb!.!       \> обычный файл \\
\verb!@!       \> символьная ссылка \\
\verb!=!       \> сокет \\
\verb!p!       \> именованный канал (FIFO) \\
\verb!*!       \> обычный исполняемый файл (0100) \\
\verb!%!       \> файл устройства \\
               \> (символьного или блочного) \\
\verb!%b!      \> специальное блочное \\
\verb!%c!      \> специальное символьное \\
\verb!r!       \> доступный для чтения (0400) \\
\verb!w!       \> доступный для записи (0200) \\
\verb!x!       \> доступный для выполнения (0200) \\
\verb!A!       \> доступный для чтения группой (0040) \\
\verb!I!       \> доступный для записи группой (0020) \\
\verb!E!       \> доступный для выполнения группой (0010) \\
\verb!R!       \> доступный для чтения всеми (0200) \\
\verb!W!       \> доступный для записи всеми (0200) \\
\verb!X!       \> доступный для выполнения всеми (0200) \\
\verb!s!       \> с установленным битом пользователя \\
               \> (setuid) (04000) \\
\verb!S!       \> с установленным битом группы \\
               \> (setgid) (02000) \\
\verb!t!       \> файлы с битом sticky (01000) \\
\T{f}\I{spec}  \> права доступа в стиле chmod \\
               \> например, \verb!f70?! или \verb!f:u+w,go-w:! \\
\T{e}\I{str}   \> вычислить строку \I{str}, использовать файл  \\
               \> (\verb!$REPLY!) если статус равен 0 или   \\
               \> установить \verb!$reply! для файлового массива \\
\T{d}\I{dev}   \> на номер устройства \I{dev} \\
\T{l}\Lsq\T{-}$\mid$\T{+}\Rsq\I{ct}
               \> количество связей \I{ct} или больше (\T{+}), \\
               \> или меньше (\T{-}) чем \I{ct} \\
\T{U}          \> владельцем является текущий \\
               \> эффективный пользователь \\
\T{G}          \> владельцем является текущая \\
               \> эффективная группа \\
\T{u}\I{uid}   \> владельцем является пользователь \I{uid}; \\
               \> может также принимать формы \T{.}\I{name}\T{.},  \\
               \> \T{!}\I{name}\T{!}, \dots\ или \T{(}\I{name}\T{)}, \\
               \> \verb!{!\I{name}\verb!}!, \dots \\
\T{g}\I{gid}   \> владельцем является группа \I{gid}, \\
               \> также как для \T{u}\I{uid}. \\
\T{a}\Lsq\T{Mwhm}\Rsq\Lsq\T{-}$\mid$\T{+}\Rsq\I{n} \\
               \> доступ производился (менее чем, более чем) \\
               \>  \I{n} дней (месяцев, недель, часов, минут) назад \\
\T{m}\Lsq\T{Mwhm}\Rsq\Lsq\T{-}$\mid$\T{+}\Rsq\I{n} \\
               \> тоже самое для изменений \\
\T{c}\Lsq\T{Mwhm}\Rsq\Lsq\T{-}$\mid$\T{+}\Rsq\I{n} \\
               \> тоже самое для изменений inode \\
\T{L}\Lsq\T{kKmMpP}\Rsq\Lsq\T{-}$\mid$\T{+}\Rsq\I{n} \\
               \> размер в байтах \\
               \> (или kb, mb, blocks) $=$ (или $<$, $>$) \I{n} \\
\verb!^!       \> применить отрицание к следующим \\
               \> квалификаторам \\
\verb!,!       \> применить `\I{or}' к списку квалификаторов \\
\verb!-!       \> отключить следование по ссылкам \\
               \> (отключено по умолчанию) \\
\T{M}          \> установить \B{MARK\_DIRS}, \\
               \> только для данного шаблона \\
\T{T}          \> установить \B{LIST\_TYPES}, \\
               \> только для данного шаблона \\
\T{N}          \> установить \B{NULL\_GLOB}, \\
               \> только для данного шаблона \\
\T{D}          \> установить \B{GLOB\_DOTS}, \\
               \> только для данного шаблона \\
\T{n}          \> установить \B{NUMERIC\_GLOB\_SORT}, \\
               \> только для данного шаблона \\
\T{o}\Lsq\T{nLlamcd}\Rsq \\
               \> порядок сортировки результатов: по имени, \\
               \> размеру, количеству ссылок, времени \\
               \> доступа/изменения/inode, сначала \\
               \> самые глубокие вхождения \\
\T{o}\Lsq\T{nLlamcd}\Rsq \\
               \> тоже самое, но в обратном порядке; \verb!Od! самые \\
               \> глубокие вхождения в конце \\
\verb![!\I{beg}\Lsq\verb!,!\I{end}\Rsq\verb!]! \\
               \> выбираемые индексы полученного списка файлов \\
\verb!:!\dots  \> остальное рассматривается как модификаторы \\
               \> истории (каждый со своим знаком \verb!:!)\\
\end{tabbing}
\end{multicols}

\section{Опции}
\D означает установки по умолчанию: эти опции появляются со словом
\T{no} в начале списка опций; \verb!+!\I{o} отключает однобуквенные
опции (показаны в скобках)

\begin{multicols}{3}
\begin{tabbing}
\hskip 1em \= \T{AUTO\_REMOVE\_SLASH} \= \kill
\T{ALL\_EXPORT}          \>\> Экспортировать все новые \\
                         \>\> параметры процессора (-a) \\
\T{ALWAYS\_LAST\_PROMPT} \>\> Вернуться к приглашению \\
                         \>\> после перечисления \\
\T{ALWAYS\_TO\_END}      \>\> В конец слова после \\
                         \>\> выполнения дополнения \\
\T{APPEND\_HISTORY}      \>\> Добавлять историю в файл \\
\T{AUTO\_CD}             \>\> Выполнять \T{cd} если команда \\
                         \>\> является каталогом (-J) \\
\T{AUTO\_LIST}           \>\> Перечислять неоднозначные \\
                         \>\> дополнения (-9) \\
\T{AUTO\_MENU}           \>\> Показывать меню после \\
                         \>\> второго нажатия на \T{TAB} \\
\T{AUTO\_NAME\_DIRS}     \>\> Параметры с путями, \\
                         \>\> становятся именами \\
\T{AUTO\_PARAM\_KEYS}    \>\> Умное удаления после \\
                         \>\> дополнения параметра \\
\T{AUTO\_PARAM\_SLASH}   \>\> \verb!$path<TAB>! в $\to$ \verb!$path/! \\
\T{AUTO\_PUSHD}          \>\> При выполнении \T{cd} \\
                         \>\> выполнять \T{pushd} (-N) \\
\T{AUTO\_REMOVE\_SLASH}  \>\> Удалять слеш из имени \\
                         \>\> каталога после дополнения \\
\T{AUTO\_RESUME}         \>\> \T{cmd} может вести себя \\
                         \>\> подобно \verb!%cmd! (-W) \\
\T{BAD\_PATTERN}\D       \>\> Выдавать ошибки при \\
                         \>\> неправильном шаблоне \\
                         \>\> подстановки (+2) \\
\T{BANG\_HIST}\D         \>\> Использовать \verb.!hist. \\
                         \>\> в командной строке (+K) \\
\T{BARE\_GLOB\_QUAL}\D   \>\> Использовать скобки как \\
                         \>\> квалификаторы глоббинга \\
\T{BASH\_AUTO\_LIST}\D   \>\> Выдавать список только \\
                         \>\> после второго нажатия \\
                         \>\> на \T{TAB} \\
\T{BEEP}\D               \>\> Выдавать сигнал при \\
                         \>\> ошибках и т.п. (+B) \\
\T{BG\_NICE}\D           \>\> Уменьшать приоритет  \\
                         \>\> фоновых заданий (-6) \\
\T{BRACE\_CCL}           \>\> \verb!foo{ab}! $\to$ \verb!fooa foob! \\
\T{BSD\_ECHO}            \>\> Встроенная команда \T{echo} \\
                         \>\> будет работать аналогично \\
                         \>\> команде в BSD \\
\T{CDABLE\_VARS}         \>\> \T{cd foo} аналогично  \\
                         \>\> \verb!cd ~foo! (-T) \\
\T{CHASE\_DOTS}          \>\> Анализировать ссылки при \\
                         \>\> выполнении \verb!..! в каталогах \\
\T{CHASE\_LINKS}         \>\> Анализировать символьные \\
                         \>\> ссылки в каталогах (-w) \\
\T{CHECK\_JOBS}\D        \>\> Сообщать статус заданий \\
                         \>\> при выполнении \T{exit} \\
\T{CLOBBER}\D            \>\> \verb!>! в существующий \\
                         \>\> файл требует \verb!>|! (+C) \\
\T{COMPLETE\_ALIASES}    \>\> Дополнения используют \\
                         \>\> нераскрытые алиасы \\
\T{COMPLETE\_IN\_WORD}   \>\> Дополнять в точке \\
                         \>\> курсора в слове \\
\T{CORRECT}              \>\> Корректировка имени \\
                         \>\> команд (-0) \\
\T{CORRECT\_ALL}         \>\> Корректировка всех \\
                         \>\> аргументов (-O) \\
\T{CSH\_JUNKIE\_HISTORY} \>\> Одиночный знак \verb.!. \\
                         \>\> означает последнюю команду \\
\T{CSH\_JUNKIE\_LOOPS}   \>\> Списки могут записываться \\
                         \>\> как \verb!list; end! \\
\T{CSH\_JUNKIE\_QUOTES}  \>\> Не допускать  \\
                         \>\> не-маскированных переводов  \\
                         \>\> строк в кавычках \\
\T{CSH\_NULLCMD}         \>\> Не использовать \\
                         \>\> \verb!$NULLCMD!, \verb!$READNULLCMD! \\
\T{CSH\_NULL\_GLOB}      \>\> Только одна подстановка \\
                         \>\> должна соответствовать \\
\T{DVORAK}               \>\> Для корректировки  \\
                         \>\> использовать клавиатуру \\
                         \>\> Дворака \\
\T{EQUALS}\D             \>\> Выполнять раскрытие \verb!=cmd! \\
\T{ERR\_EXIT}            \>\> Выходить из командного \\
                         \>\> процессора при \\
                         \>\> возникновении ошибок (-e) \\
\T{EXEC}\D               \>\> Выполнять команды (+n) \\
\T{EXTENDED\_GLOB}       \>\> использовать \verb!#!, \verb!~! и \\
                         \>\> \verb!^! в шаблонах  \\
\T{EXTENDED\_HISTORY}    \>\> Сохранять временные метки\\
                         \>\>  в файле истории \\
\T{FLOW\_CONTROL}\D      \>\> \verb!^S!, \verb!^Q! производят\\
                         \>\>  контроль выполнения \\
\T{FUNCTION\_ARGZERO}\D  \>\> Устанавливать \verb!$0! \\
                         \>\> для функций и команды \\
                         \>\> source \\
\T{GLOB}\D               \>\> Выполнять подстановки (+F) \\
\T{GLOBAL\_EXPORT}\D     \>\> \verb!typeset -x! применяется \\
                         \>\> глобально \\
\T{GLOBAL\_RCS}\D        \>\> Использовать стартовые \\
                         \>\> файлы из \verb!/etc! \\
\T{GLOB\_ASSIGN}         \>\> \verb!scalar=*! выполняет \\
                         \>\> подстановки справа \\
\T{GLOB\_COMPLETE}       \>\> Дополнять подстановки \\
                         \>\> с помощью меню \\
\T{GLOB\_DOTS}           \>\> Ведущие точки соответствуют\\
                         \>\>  метасимволам (wildcards) (-4) \\
\T{GLOB\_SUBST}          \>\> Текст из параметров может \\
                         \>\> подставляться \\
\T{HASH\_CMDS}\D         \>\> Хешировать команды при \\
                         \>\> запуске \\
\T{HASH\_DIRS}\D         \>\> Хешировать каталоги при\\
                         \>\>  запуске команд \\
\T{HASH\_LIST\_ALL}\D    \>\> Хешировать все команды\\
                         \>\>  при дополнениях \\
\T{HIST\_ALLOW\_CLOBBER} \>\> Допускать разрушающие\\
                         \>\>  перенаправления в истории \\
\T{HIST\_BEEP}\D         \>\> Выдавать сигнал на неправильной \\
                         \>\> \verb.!. истории \\
\T{HIST\_EXPIRE\_DUPS\_FIRST} \\
                         \>   Удалять дублирующиеся строки\\
                         \>\>  для уменьшения истории \\
\T{HIST\_FIND\_NO\_DUPS} \>\> Никогда не показывать\\
                         \>\>  дубликаты в истории \\
\T{HIST\_IGNORE\_ALL\_DUPS} \\
                         \>   Никогда не сохранять дубликат\\
                         \>\>  существующей записи истории \\
\T{HIST\_IGNORE\_DUPS}   \>\> Не допускать смежных \\
                         \>\> повторений в истории (-h) \\
\T{HIST\_IGNORE\_SPACE}  \>\> Не сохранять строки `\verb! cmd!'  (-g) \\
\T{HIST\_NO\_FUNCTIONS}  \>\> Не сохранять определения функций \\
\T{HIST\_NO\_STORE}      \>\> Не сохранять команды \\
                         \>\> работы с историей \\
\T{HIST\_REDUCE\_BLANKS} \>\> Удалять из истории \\
                         \>\> лишние пробелы \\
\T{HIST\_SAVE\_NO\_DUPS} \>\> Удалять дубликаты при\\
                         \>\>  сохранении истории \\
\T{HIST\_VERIFY}         \>\> Продолжать редактирование \\
                         \>\>  после раскрытия \verb.!. \\
\T{HUP}\D                \>\> При выходе посылать заданиям\\
                         \>\>  сигнал SIGHUP \\
\T{IGNORE\_BRACES}       \>\> Не выполнять раскрытие \\
                         \>\> \verb!{!\dots\verb!,!\dots\verb!}! (-I) \\
\T{IGNORE\_EOF}          \>\> Не выполнять выхода при \\
                         \>\> получении первых десяти eof (-7) \\
\T{INC\_APPEND\_HISTORY} \>\> Сохранять историю \\
                         \>\> по мере поступления \\
\T{INTERACTIVE}          \>\> Командный процессор в \\
                         \>\> интерактивном режиме \\
                         \>\> (не устанавливается) (-i) \\
\T{INTERACTIVE\_COMMENTS} \\
                         \>\> Интерактивно использовать \\
                         \>\> комментарии (-k) \\
\T{KSH\_ARRAYS}          \>\> Синтаксис работы с \\
                         \>\> массивами подобный ksh \\
\T{KSH\_AUTOLOAD}        \>\> Эмулировать загрузку\\
                         \>\>  функций ksh \\
\T{KSH\_GLOB}            \>\> Эмулировать шаблоны, \\
                         \>\> \verb!*(...)!  ksh  и~т.п. \\
\T{KSH\_OPTION\_PRINT}   \>\> Выдавать опции \\
                         \>\> как это делает ksh \\
\T{LIST\_AMBIGUOUS}      \>\> Только отображать \\
                         \>\> неоднозначные дополнения \\
\T{LIST\_BEEP}           \>\> Выдавать сигнал при \\
                         \>\> неоднозначных дополнениях \\
\T{LIST\_PACKED}         \>\> Сжимать список дополнений \\
\T{LIST\_ROWS\_FIRST}    \>\> При дополнении первыми \\
                         \>\> отображать строки \\
\T{LIST\_TYPES}          \>\> Показывать типы файлов \\
                         \>\> в списке дополнений (-X) \\
\T{LOCAL\_OPTIONS}       \>\> Опции установленные в \\
                         \>\> функциях являются \\
                         \>\> локальными \\
\T{LOCAL\_TRAPS}         \>\> Сбрасывать ловушки (traps) \\
                         \>\> при выходе из функции \\
\T{LOGIN}                \>\> Командный процессор в \\
                         \>\> режиме login \\
                         \>\> (не устанавливается) (-l) \\
\T{LONG\_LIST\_JOBS}     \>\> Всегда использовать \\
                         \>\> \verb!jobs -l! (-R) \\
\T{MAGIC\_EQUAL\_SUBST}  \>\> Любое выражение \verb!var=expr! \\
                         \>\> раскрывает файлы \T{expr} \\
\T{MAIL\_WARNING}        \>\> Выдавать предупреждение \\
                         \>\> при был доступ к файлу\\
                         \>\>  почты (-U) \\
\T{MARK\_DIRS}           \>\> Добавлять \verb!/! к списку \\
                         \>\> каталогов при раскрытии (-8) \\
\T{MENU\_COMPLETE}       \>\> Прокручивать список \\
                         \>\> дополнений при нажатии \\
                         \>\> на \T{TAB} (-Y) \\
\T{MONITOR}              \>\> Разрешить контроль \\
                         \>\> заданий (-m) \\
\T{MULTIOS}\D            \>\> Неявно выполнять tee/cat \\
                         \>\> для множества \verb!<!, \verb!>! \\
\T{NOMATCH}\D            \>\> Выдавать ошибку для \\
                         \>\> несуществующих \\
                         \>\> раскрытий (+3) \\
\T{NOTIFY}\D             \>\> Сообщать при изменении \\
                         \>\> статуса фонового задания (-5) \\
\T{NULL\_GLOB}           \>\> Удалить несуществующие \\
                         \>\> раскрытия из списка (-G) \\
\T{NUMERIC\_GLOB\_SORT}  \>\> Сортировка чисел при \\
                         \>\> раскрытии \\
\T{OCTAL\_ZEROES}        \>\> В математических \\
                         \>\> выражениях 0 задает \\
                         \>\> восьмеричные числа \\
\T{OVER\_STRIKE}         \>\> Редактор запускается \\
                         \>\> в режиме замены \\
\T{PATH\_DIRS}           \>\> Производить поиск \verb!dir/cmd! \\
                         \>\> в путях поиска (-Q) \\
\T{POSIX\_BUILTINS}      \>\> Встроенная команда \T{builtin} \\
                         \>\> является специальной \\
\T{PRINT\_EIGHT\_BIT}    \>\> Показывать в листинге  \\
                         \>\> символы с установленным \\
                         \>\> восьмым битом \\
\T{PRINT\_EXIT\_VALUE}   \>\> Отображать ненулевые \\
                         \>\> коды возврата (-1) \\
\T{PRIVILEGED}           \>\> Привилегированный режим: \\
                         \>\> в первую очередь \\
                         \>\> безопасность! (-p) \\
\T{PROMPTT\_BANG}        \>\> В приглашении \verb.!. является \\
                         \>\> специальным \\
\T{PROMPT\_CR}\D         \>\> Выдавать CR перед \\
                         \>\> приглашением (+V) \\
\T{PROMPT\_PERCENT}\D    \>\> Выполнять раскрытие \verb!%! \\
                         \>\> в приглашении \\
\T{PROMPT\_SUBST}        \>\> Раскрывать подстановки \\
                         \>\> в приглашении \\
\T{PUSHD\_IGNORE\_DUPS}  \>\> Только одна запись для \\
                         \>\> каталога в стеке \\
\T{PUSHD\_MINUS}         \>\> Поменять местами минус \\
                         \>\> и плюс в pushd \\
\T{PUSHD\_SILENT}        \>\> Не печатать стек \\
                         \>\> каталогов (-E) \\
\T{PUSHD\_TO\_HOME}      \>\> При запуске без аргументов, \\
                         \>\> \T{pushd} переходит в домашний \\
                         \>\> каталог (-D) \\
\T{RC\_EXPAND\_PARAM}    \>\> \verb!A${array}Z!  $\to$ \\
                         \>\> \verb!Aa1Z Aa2Z! \dots (-P) \\
\T{RC\_QUOTES}           \>\> \verb!echo ''''! $\to$ \verb!'! \\
\T{RCS}\D                \>\> \verb!.!-файлы, в противном \\
                         \>\> случае просто \verb!/etc/zshenv! (+f) \\
\T{REC\_EXACT}           \>\> Предпочитать точное  \\
                         \>\> соответствие при дополнении (-S) \\
\T{RESTRICTED}           \>\> Не может вызвать больших \\
                         \>\> повреждений \\
\T{RM\_STAR\_SILENT}     \>\> Не выдавать запрос для \verb!rm *! (-H) \\
\T{RM\_STAR\_WAIT}       \>\> Не верить первому ответу \\
                         \>\> RMSTAR \\
\T{SHARE\_HISTORY}       \>\> Читать/записывать историю \\
                         \>\> по мере надобности \\
\T{SH\_FILE\_EXPANSION}  \>\> Сначала выполнять \verb!~file!, \verb!=cmd! \\
\T{SH\_GLOB}             \>\> Запретить \verb!(!, \verb!|!, \verb!)!, \\
                         \>\> \verb!<! в шаблонах \\
\T{SHIN\_STDIN}          \>\> Читать команды со стандартного \\
                         \>\> ввода (-s) \\
\T{SH\_NULLCMD}          \>\> Пустая команда предполагает \\
                         \>\> поведение \verb!:! \\
\T{SH\_OPTION\_LETTERS}  \>\> Интерпретация однобуквенных \\
                         \>\> опций как в ksh \\
\T{SHORT\_LOOPS}\D       \>\> Короткие версии \verb!for!, \verb!select!, \\
                         \>\> \verb!if!, \verb!function! \\
\T{SH\_WORD\_SPLIT}      \>\> Разбивать слова подобно другим \\
                         \>\> командным процессорам (-y) \\
\T{SINGLE\_COMMAND}      \>\> Считать команду и прекратить \\
                         \>\> работу (-t) \\
\T{SINGLE\_LINE\_ZLE}    \>\> Редактор использует только \\
                         \>\> одну строку (-M) \\
\T{SUN\_KEYBOARD\_HACK}  \>\> Игнорировать несоответствующий, \\
                         \>\> завершающий знак \verb!`! (-L) \\
\T{UNSET}\D              \>\> Неустановленные параметры \\
                         \>\> вызывают ошибку (+u) \\
\T{VERBOSE}              \>\> Печатать введенные строки \\
                         \>\> по мере чтения (-v) \\
\T{XTRACE}               \>\> При запуске печатать \\
                         \>\> команды и аргументы (-x) \\
\T{ZLE}                  \>\> Использовать строковый редактор \\
                         \>\> командного процессора (-Z) \\
\end{tabbing}
\end{multicols}

\begin{multicols}{3}[\section{Раскрытие параметров}]

\begin{tabbing}
\hskip 20pt \= \kill
\verb!$!\I{name} \\
\verb!${!\I{name}\verb!}! \\
                \> Базовая подстановка параметра \\
\verb!${+!\I{name}\verb!}! \\
                \> 1 если \I{name} установлен, 0 в противном случае \\
\verb!${!\I{name}\verb!:-!\I{word}\verb!}! \\
                \> \verb!$!\I{name} если не равен нулю, иначе \I{word} \\
\verb!${!\I{name}\verb!-!\I{word}\verb!}! \\
                \> \verb!$!\I{name} если установлен, иначе \I{word} \\
                \> (Аналогично другим с/без выражениям). \\
\verb!${!\I{name}\verb!:=!\I{word}\verb!}! \\
                \> \verb!$!\I{name} если не равен нулю, иначе использовать \\
                \> \I{word} и установить \I{name} равным ему \\
\verb!${!\I{name}\verb!:==!\I{word}\verb!}! \\
                \> Безусловное присвоение
\verb!${!\I{name}\verb!:?!\I{word}\verb!}! \\
                \> \verb!$!\I{name} если не равен нулю, иначе \\
                \> напечатать \I{word} и выйти \\
\verb!${!\I{name}\verb!:+!\I{word}\verb!}! \\
                \> \I{word} если \verb!$!\I{name} не равен \\
                \> нулю, иначе ничего не делать \\
\verb!${!\I{name}\verb!#!\I{pattern}\verb!}! \\
\verb!${!\I{name}\verb!##!\I{pattern}\verb!}! \\
                \> \verb!$!\I{name} с самым коротким (длинным)  \\
                \> соответствием шаблону \I{pattern} удаляется \\
                \> с головы. Параметры как в подстановке; \\
                \> оригинальный параметр не изменяется \\
\verb!${!\I{name}\verb!%!\I{pattern}\verb!}! \\
\verb!${!\I{name}\verb!%%!\I{pattern}\verb!}! \\
                \> Как для for \verb!#!, но удаляет с конца соответствия \\
\verb!${!\I{name}\verb!/!\I{pattern}\verb!/!\I{repl}\verb!}! \\
                \> Заменить самое длинное соответствие шаблону \\
                \> \I{pattern} на \I{repl} \\
\verb!${(S)!\I{name}\verb!/!\I{pattern}\verb!/!\I{repl}\verb!}! \\
                \> Заменить самое короткое соответствие\\
                \>  шаблону \\
\verb!${!\I{name}\verb!//!\I{pattern}\verb!/!\I{repl}\verb!}! \\
                \> Заменить все непересекающиеся самые \\
                \> длинные соответствия \\
\verb!${!\I{name}\verb!/#!\I{pattern}\verb!/!\I{repl}\verb!}! \\
                \> Подставить, если шаблон \I{pattern} \\
                \> в начале строки \\
\verb!${!\I{name}\verb!/%!\I{pattern}\verb!/!\I{repl}\verb!}! \\
                \> Подставить, если шаблон  \I{pattern} \\
                \> в конце строки \\
\verb!${!\I{name}\verb!:/!\I{pattern}\verb!/!\I{repl}\verb!}! \\
                \> Подставить, если шаблон \I{pattern} \\
                \> соответствует всей строке \\
\verb!${#!\I{spec}\verb!}! \\
                \> Вычислить длину списка слов или скаляров \\
\verb!${^!\I{spec}\verb!}! \\
\verb!${^^!\I{spec}\verb!}! \\
                \> Включает (отключает) \\
                \> \B{RC\_EXPAND\_PARAM} \\
\verb!${=!\I{spec}\verb!}! \\
\verb!${==!\I{spec}\verb!}! \\
                \> Включает (отключает) \B{SH\_WORD\_SPLIT} \\
\verb!${~!\I{spec}\verb!}! \\
\verb!${~~!\I{spec}\verb!}! \\
                \> Включает (отключает) \B{GLOB\_SUBST} \\
\verb!${!\I{spec}\verb!:!\I{mod}\verb!}! \\
                \> Применяет модификатор шаблона \I{mod} \\
\verb!${${name\dots}!\dots\verb!}! \\
                \> Выполняет оба набора изменений над \\
                \> значением, не выполняет дополнительного \\
                \> поиска, смотрите \verb!(P)! \\
\end{tabbing}

Флаги:  использование \verb!${(o)!\I{name}\verb!}! и т.п.
\begin{tabbing}
\hskip 20pt \= \kill
\T{A}           \> \verb!${...:=...}! создает массив \\
\T{AA}          \> \dots создает ассоциативный массив \\
\verb!@!        \> Разбивает на слова в двойных кавычках \\
\T{e}           \> Использовать раскрытия в результате \\
\T{P}           \> Заставить заново использовать \verb!$!\I{name} \\
                \> в качестве имени \\
\T{o}           \> Сортировать слова в порядке возрастания \\
\T{O}           \> Сортировать слова в порядке убывания \\
\T{i}           \> Независимость от регистра при использовании \\
                \> \T{o} или \T{O} \\
\T{L}           \> Все буквы в нижнем регистре \\
\T{U}           \> Все буквы в верхнем регистре \\
\T{C}           \> Сделать первую букву заглавной \\
\T{V}           \> Отображать специальные символы \\
\T{q}           \> Маскировать результаты символом \verb!\! \\
\T{qq}          \> Маскировать результаты символом \verb!'! \\
\T{qqq}         \> Маскировать результаты символом \verb!"! \\
\T{qqqq}        \\
                \> Маскировать результаты символами  \verb!$'!\dots\verb!'! \\
\T{Q}           \> Удалить один уровень маскирования \\
                \> командного процессора \\
\verb!%!        \> Раскрыть маски приглашения \\
\verb!%%!       \> Раскрыть как приглашение с текущими настройками \\
\T{X}           \> Выдать ошибки разбора масок, шаблонов \\
\T{c}           \> \verb!${#!\I{name}\verb!}! подсчитывает символы \\
\T{w}           \> \verb!${#!\I{name}\verb!}! подсчитывает слова \\
\T{W}           \> Как \T{w}, но считает пустые слова \\
\T{k}           \> В ассоциативном массиве включать ключи \\
\T{v}           \> В ассоциативном массиве включать значения \\
\T{p}           \> Использовать маски печати в аргументах \\
\T{F}           \> Соединить слова с переводами строк \\
\T{f}           \> Разбить по границе строк \\
\T{z}           \> Разбить обычным способом \\
\T{t}           \> Подставленное описание, не значение \\
\end{tabbing}

Флаги с разделителями; используйте любую пару символов вместо двоеточий,
также можно использовать \verb!<>!, \verb!()!, \verb!{}!, \verb![]!
\begin{tabbing}
\hskip 20pt \= \kill
\T{l:}\I{expr}\T{::}\I{string1}\T{::}\I{string2}\T{:} \\
                \> Заполнить слова слева до \I{expr} символов  \\
                \> используя повторение \I{string1} (по умолчанию \\
                \> пробел), \I{string2} вставляется только раз \\
\T{r:}\I{expr}\T{::}\I{string1}\T{::}\I{string2}\T{:} \\
                \> Тоже самое только заполняя справа \\
\T{j:}\I{string}\T{:} \\
                \> Соединить слова используя \I{string} \\
                \> (происходит до разбиения) \\
\T{s:}\I{string}\T{:} \\
                \> Разбить слова по \I{string}
\end{tabbing}

Флаги применяемые с \verb!${...#...}! или \verb!${...%...}!
\begin{tabbing}
\hskip 20pt \= \kill
\T{S}           \> также искать в подстроках \\
\T{I:}\I{expr}\T{:} \\
                \> Искать/подставлять \I{expr\/}-е совпадение \\
\T{M}           \> Включить совпадение \\
\T{R}           \> Включить не совпавшую часть (остаток) \\
\T{B}           \> Включить индекс начала \\
\T{E}           \> Включить индекс конца \\
\T{N}           \> Включить длину совпавшей части \\
\end{tabbing}

Сводная таблица правил подстановки
\begin{tabbing}
\hskip 20pt \= \kill
1              \> Вложенная подстановка, \verb!${${!\dots\verb!}}! \\
2              \> Индексирование параметров по имени, \\
               \> \verb!${!\I{name}\verb![!\I{i}\verb!]}! \\
3              \> Флаг \verb!(P)! \\
4              \> Соединение \verb!"${!\dots\verb!}"! \\
5              \> Вложенный индекс, \verb!${${!\dots\verb!}[!\I{i}\verb!]}! \\
6              \> \verb!#!, \verb!%!, \verb!/!. модификации \verb!:!  \\
7              \> флаг \verb!(j)! или соединение пробелами \\
8              \> разбиение \verb!(s)!, \verb!(f)!, \verb!(z)! или \verb!=! \\
9              \> Разбиение слов командного процессора \\
               \> (без флагов) \\
10             \> Флаг \verb!(e)! \\
11             \> Заполнение \verb!(l)! или \verb!(r)! \\
\end{tabbing}

Флаги в индексировании: использование \verb!$!\I{name}\verb![(i)!\I{index}\verb!]! и т.п.
\begin{tabbing}
\hskip 20pt \= \kill
\T{e}           \> Только для обратной совместимости \\
\T{w}           \> Индексировать по словам скаляра \\
\T{s:string:} \\
                \> Разделять слова с помощью \T{string} \\
\T{p}           \> В следующем выражении использовать \\
                \> печатные маски \T{s} \\
\T{f}           \> Индексировать по строкам: то же самое как \verb!pws:\n:! \\
\T{r}           \> Обратное индексирование массива/подстроки/слова \\
                \> Для ассоциативных массивов, соответствие \\
                \> для значений \\
\T{R}           \> Как \T{r}, но последнее совпадение (все \\
                \> для ассоциативных массивов) \\
\T{k}           \> В ассоциативных массивах, ключи являются \\
                \> шаблонами; получить первый \\
\T{K}           \> В ассоциативных массивах, ключи являются \\
                \> шаблонами; получить все \\
\T{i}           \> Как \T{r}, но вернуть индекс. Для ассоциативных \\
                \> массивов, соответствие для ключей \\
\T{I}           \> Как \T{i}, но последнее совпадение (все \\
                \> для ассоциативных массивов) \\
\verb!n:!\I{expr}\verb!:! \\
                \> Использовать \T{expr}-е первое/последнее совпадение \\
\verb!b:!\I{expr}\verb!:! \\
                \> \T{r}, \T{R}, \T{i}, \T{I} начинают поиск с \I{expr}-й элемента.
\end{tabbing}
\end{multicols}

\goodbreak
\section{История}
Также смотрите параметры \B{histchars}, \B{HISTFILE}, \B{HISTSIZE},
\B{SAVEHIST} и опции \B{APPEND\_\-HISTORY},
\B{CSH\_\-JUNKIE\_\-HISTORY}, \B{EXTENDED\_\-HISTORY},
\B{HIST\_\-ALLOW\_\-CLOBBER}, \B{HIST\_\-IGNORE\_\-DUPS},
\B{HIST\_\-IGNORE\_\-SPACE}, \B{HIST\_\-NO\_\-STORE},
\B{HIST\_\-VERIFY}, \B{BANG\_\-HIST}, \B{HIST\_\-BEEP},
\B{HIST\_\-EXPIRE\_\-DUPS\_\-FIRST}, \B{HIST\_\-FIND\_\_NO\_\-DUPS},
\B{HIST\_\-IGNORE\_\-ALL\_\-DUPS}, \B{HIST\_\-NO\_\-FUNCTIONS},
\B{HIST\_\-REDUCE\_\-BLANKS}, \B{HIST\_\-SAVE\_\-NO\_\-DUPS},
\B{INC\_\-APPEND\_\-HISTORY}, \B{SHARE\_\-HISTORY}.

\begin{multicols}{3}[\mbox{События:}]
\begin{tabbing}
\hskip 60pt \= \kill
\verb.!.        \> начать подстановку истории, если не \\
                \> после пробела, новой строки, \verb!=!, \verb!(! \\
\verb.!!.       \> предыдущая команда \\
\verb.!.\I{n}   \> командная строка \I{n} \\
\verb.!-.\I{n}  \> строка \I{n} до текущей \\
\verb.!.\I{str} \> последняя строка начинавшаяся с \I{str} \\
\verb.!.\I{?str}\Lsq\verb.?.\Rsq
                \> последняя строка содержавшая \I{str} \\
\verb.!#.       \> текущая команда \\
\verb?!{...}?   \> изолировать ссылку на историю \\
\verb.!".       \> не выполнять подстановок на этой строке \\
\end{tabbing}
\end{multicols}

\begin{multicols}{3}[\mbox{Слова: отделенные от события символом `:'}]
\begin{tabbing}
\hskip 60pt \= \kill
\T{0}           \> первое слово в строке (команда) \\
\I{n}           \> \I{n\/}-й аргумент команды \\
\verb!^!        \> первый аргумент команды  \\
\verb!$!        \> последний аргумент команды  \\
\verb!%!        \> слово соответствующее \verb!?s! \\
\I{x}\verb!-!\I{y} \> диапазон слов \\
\verb!-!\I{y}   \> то же самое, что и \verb!0-!\I{y} \\
\verb!*!        \> все аргументы \\
\I{x}\verb!*!   \> то же самое, что и \I{x}\verb!-$! \\
\I{x}\verb!-!   \> то же самое, но пропустить слово \verb!$! \\
\end{tabbing}
\end{multicols}

\begin{multicols}{3}[\mbox{Модификаторы: также с подстановками (globbing) и параметрами}]
\begin{tabbing}
\hskip 60pt \= \kill
\T{h}           \> (голова) удалить последний \\
                \> компонент пути \\
\T{r}           \> удалить суффикс \verb!.!\I{suf} \\
\T{e}           \> оставить только суффикс \I{suf} \\
\T{t}           \> (хвост) оставить только последний \\
                \> компонент пути \\
\verb!&!        \> повторить последнюю подстановку \\
\T{p}           \> не выполнять новую команду \\
\T{q}           \> замаскировать слова от дальнейших \\
                \> подстановок \\
\T{Q}           \> удалить один уровень маскирования \\
\T{x}           \> то же самое, но разбить слова \\
                \> по пробелам \\
\T{l}           \> все буквы в нижний регистр \\
\T{u}           \> все буквы в верхний регистр \\
\verb!s/!\I{old}\verb!/!\I{new}\Lsq\verb!/!\Rsq \\
                \> заменить \I{old} на \I{new} (строки) \\
\T{g}           \> (до s) заменить каждое вхождение \\
\T{f}           \> повторять пока не останется вхождений \\
\verb!F:!\I{expr}\verb!:! \> то же самое, но максимум \I{expr} изменений \\
\T{w}           \> (как префикс) применять к каждому слову \\
\verb!W:!\I{sep}\verb!:! \> то же самое, но разделять слова с \\
                \> помощью \I{sep} \\
\end{tabbing}
\end{multicols}

\begin{multicols}{3}[\section{Параметры}]

Специальные параметры: массивы именуются в нижнем регистре, за исключением
\T{status}; те, что помечены как \D\ могут присваиваться:
\begin{tabbing}
\hskip 1em \= USERNAME \= \kill
\T{!}             \>\> PID последнего фонового задания \\
\T{ARGC} \\
\verb!#!          \>\> кол-во позиционных параметров \\
\verb!$!          \>\> текущий PID \\
\T{-}             \>\> набор флагов командного \\
                  \>\> процессора \\
\T{argv}\D \\
\verb!*!\D        \>\> массив позиционных параметров \\
\verb!@!          \>\> то же самое, что и \verb!argv[@]! \\
\T{status} \\
\T{?}             \>\> статус последней программы \\
\T{pipestatus}    \>\> массив статусов при конвейерной \\
                  \>\> обработке \\
\verb!_!          \>\> последний аргумент предыдущей \\
                  \>\> команды \\
\T{CPUTYPE}       \>\> тип CPU определенный во время \\
                  \>\> работы \\
\T{EGID}\D        \>\> эффективный GID \\
\T{EUID}\D        \>\> эффективный UID \\
\T{ERRNO}         \>\> номер системной ошибки \\
\T{GID}\D         \>\> текущий GID \\
\T{HOST}          \>\> имя машины \\
\T{LINENO}        \>\> номер вводимой строки \\
\T{LOGNAME}       \>\> имя пользователя \\
\T{MACHTYPE}      \>\> тип машины \\
\T{OLDPWD}        \>\> предыдущий рабочий каталог \\
\T{OPTARG} \\
\T{OPTIND}        \>\> значение и индекс последней \\
                  \>\> опции \B{getopts} \\
\T{OSTYPE}        \>\> тип OS \\
\T{PPID}          \>\> PID родительского процесса \\
\T{PWD}           \>\> текущий рабочий каталог \\
\T{RANDOM}\D      \>\> произвольное целое число: \\
                  \>\> присвойте для генерации \\
\T{SECONDS}\D     \>\> кол-во секунд прошедших с момента \\
                  \>\> запуска командного процессора \\
\T{SHLVL}         \>\> увеличивается для каждого zsh \\
\T{signals}       \>\> имена сигналов \\
\T{TTY}           \>\> имя терминала командного процессора \\
\T{TTYIDLE}       \>\> время ожидания терминала (сек.) или -1 \\
\T{UID}\D         \>\> UID \\
\T{USERNAME}\D    \>\> имя пользователя \\
\T{VENDOR}        \>\> производитель компьютера \\
\verb!ZSH_NAME!   \>\> имя запуска командного процессора \\
\verb!ZSH_VERSION! \>\> ID версии zsh \\
\end{tabbing}

Другие параметры используемые командного процессора (\D~--- путь
разделенный двоеточием)
\begin{tabbing}
\hskip 2em \= USERNAME \= \kill
\T{ARGV0}         \>\> экспортируйте для изменения \verb!argv[0]! \\
\T{BAUD}          \>\> скорость линии (0 для игнорирования) \\
\T{cdpath}, \T{CDPATH}\D \>\> поиск в каталогах для команды \B{cd} \\
\T{COUMNS}        \>\> No.\ колонок на терминале \\
\T{DIRSTACKSIZE}  \>\> максимальный размер стека каталогов \\
\T{FCEDIT}        \>\> редактор по умолчанию для команды \B{fc} \\
\T{fignore}, \T{FIGNORE}\D \>\>\quad суффиксы, пропускаемые \\
                  \>\> при дополнении \\
\T{fpath}, \T{FPATH}\D \>\> пути поиска автозагружаемых функций \\
\T{histchars} \>\> три символа: 1) начало истории (\verb.!.), \\
                  \> 2) быстрая подстановка истории (\verb!^!), \\
                  \> 3) комментарий (\verb!#!) \\
\T{HISTCHARS}     \>\> то же самое, что и \T{histchars} \\
\T{HISTFILE}      \>\> где сохранять историю командного \\
                  \>\> процессора \\
\T{HISTSIZE}      \>\> максимальное кол-во команд в \\
                  \>\> истории (внутреннее хранение) \\
\T{HOME}          \>\> значение по умолчанию для \\
                  \>\> команды \B{cd} \\
\T{IFS}           \>\> разделитель слов при вводе \\
\T{KEYTIMEOUT}    \>\> время ожидания клавиши \\
                  \>\> в последовательности \\
\T{LANG}          \>\> основное значение региональных \\
                  \>\> настроек \\
\verb!LC_ALL!     \>\> переопределяет \T{LANG} \\
                  \>\> и другие \verb!LC_*! \\
\verb!LC_COLLATE! \>\> определяет порядок символов \\
\verb!LC_CTYPE!   \>\> определяет классы символов \\
\verb!LC_MESSAGES!\>\> для сообщений: \\
                  \>\> не используется zsh \\
\verb!LC_NUMERIC! \>\> для вывода десятичной точки \\
                  \>\> и разделителя чисел \\
\verb!LC_TIME!    \>\> формат времени и даты \\
\T{LINES}         \>\> No.\ строк на терминале \\
\T{LISTMAX}       \>\> No.\ файлов для перечисления \\
                  \>\> без запроса \\
\T{LOGCHECK}      \>\> как часто проверять \T{watch} (сек.) \\
\T{MAIL}          \>\> файл проверяемый \\
                  \>\> на наличие почты \\
\T{MAILCHECK}     \>\> как часто проверять \T{MAIL} (сек.) \\
\T{mailpath}, \T{MAILPATH}\D \\
   \> список файлов проверяемых на наличие  \\
   \> новой почты. За каждым может указываться \\
   \> \verb!?'выдаваемое сообщение'! \\
\T{manpath}, \T{MANPATH}\D \\
   \> не используется командным процессором, \\
   \> вероятно используется командой \B{man} \\
\T{module\_path}, \T{MODULE\_PATH}\D \\
   \> пути для динамических модулей; \\
   \> не импортируется \\
\T{NULLCMD}       \>\> используется для \\
                  \>\> перенаправлений без команды \\
\T{path}, \T{PATH}\D \>\> пути поиска команд \\
\T{POSTEDIT}      \>\> сообщение после выхода из \\
                  \>\> строкового редактора \\
\T{PROMPT}, \T{prompt} \\
\T{PS1}           \>\> приглашение, используемое \\
                  \>\> редактором \\
\T{PROMPT2}, \T{PS2} \>\> приглашение при продолжении \\
                  \>\> редактирования \\
\T{PROMPT3}, \T{PS3} \>\> приглашение используемое \\
                  \>\> командой \B{select} \\
\T{PROMPT4}  \T{PS4} \>\> приглашение трассировщика \\
                  \>\> выполнения \\
\T{psvar}, \T{PSVAR}\D \>\> заменить \verb!%v! в приглашениях \\
\T{READNULLCMD} \>\> команда используемая при \\
                  \>\> использовании перенаправления \\
                  \>\> ввода без команды \\
\T{REPORTTIME} \>\> для длительных команд выдавать \\
                  \>\> занятое время (сек.) \\
\T{RPROMPT} \\
\T{RPS1}           \>\> приглашение выдаваемое \\
                  \>\> в правой части строки \\
\T{SAVEHIST}       \>\> макс. число строк в файле истории \\
\T{SPROMPT}        \>\> приглашение используемое \\
                  \>\> при проверке ошибок \\
\T{STTY}           \>\> аргументы для для команды \B{stty}, \\
                  \>\> экспортируйте эту переменную для  \\
                  \>\> запуска до выполнения внешней \\
                  \>\> команды \\
\T{TERM}           \>\> тип терминала \\
\T{TIMEFMT}        \>\> формат отчетов о времени выполнения \\
\T{TMOUT}          \>\> SIGALRM при долгом ожидании (сек.) \\
\T{TMPPREFIX}      \>\> путь к временным файлам (\B{/tmp/zsh}) \\
\T{watch}, \T{WATCH}\D \>\> список пользователей для наблюдения \\
                  \>\> за их входом/выходом (также значения \\
              \>\> \B{all}, \B{notme}, \verb!%! tty, \verb!@! host) \\
\T{WATCHFMT}       \>\> формат отчетов \T{watch} \\
\T{WORDCHARS}      \>\> не-цифро-буквенные символы  \\
                  \>\>  используемые редактором как часть \\
                  \>\> слова \\
\T{ZBEEP}          \>\> последовательность для вывода \\
                  \>\> вместо выдачи сигнала \\
\T{ZDOTDIR}        \>\> где искать \verb!.zshrc! и~т.п. \\
\end{tabbing}
\end{multicols}

управляющие последовательности строки приглашения: помеченные как \D
могут использовать целые числа \I{n}, которые должны сразу следовать
за \verb!%!. По умолчанию число равно 1, за исключением \verb!%_!.
\begin{multicols}{3}
\begin{tabbing}
\hskip 50pt \= \kill
\verb!%%!          \> A `\%' \\
\verb!%)!          \> A `)' \\
\verb!%d! \verb!%/!\D
                   \> \verb!$PWD! \\
\verb!%~!\D        \> \verb!$PWD!, но использует сокращение \verb!~! \\
\verb!%h! \verb.%!.
                   \> текущий номер события истории\\
\verb!%L!          \> текущее значение \verb!$SHLVL! \\
\verb!%M!          \> полное имя машины \\
\verb!%m!\D        \> имя машины до \I{n}-й точки \\
\verb!%S! \verb!%B! \verb!%U!
                   \> начать standout, жирный, подчеркивание \\
\verb!%s! \verb!%b! \verb!%u!
                   \> остановить соответствующий режим \\
\verb!%t! \verb!%@!
                   \> время в 12-часовом формате \\
\verb!%T!          \> время в 24-часовом формате  \\
\verb!%*!          \> то же самое, с секундами \\
\verb!%n!          \> \verb!$USERNAME! \\
\verb!%N!          \> имя скрипта, функции \\
\verb!%i!          \> номер строки внутри \verb!%N! \\
\verb!%w!          \> дата в виде \verb!day-dd! \\
\verb!%W!          \> дата в виде \verb!mm/dd/yy! \\
\verb!%D!          \> дата в виде \verb!yy-mm-dd! \\
\verb!%D{!\I{string}\verb!}! \\
                   \> использовать \T{strftime} для \\
                   \> форматирования \I{string} \\
\verb!%l!          \> текущий терминал \\
\verb!%?!          \> код возврата последней команды \\
\verb!%_!\D        \> состояние парсера, \I{n} для \\
                   \> указания максимального уровня\\
\verb!%E!          \> очистить до конца строки \\
\verb!%#!          \> \verb!#! если root, иначе \verb!%! \\
\verb!%v!\D        \> \I{n}-й элемент \verb!$psvar! \\
\verb!%{...%}!     \> строка, которая не перемещает курсор \\
\verb!%<string<! \verb!%>string>! \verb!%[<string]! \verb!%[>string]! \\
                   \> обрезает \T{string} слева или справа, \\
                   \> \I{n} задает максимальную длину \\
\verb!%c!\D\ \verb!%.!\D 
                   \> компонент \verb!$PWD! (устаревшее) \\
\verb!%C!          \> то же самое, но без раскрытия \verb!~! \\
\end{tabbing}

Коды для трехэлементных выражений в строке приглашения, формат
\verb!%(!\I{char}\verb!.!\I{true-text}\verb!.!\I{false-text}\verb!)!,
целое число \I{n} может предшествовать или следовать за
`\verb!(!'. тест истинен, если:
\begin{tabbing}
\hskip 40pt \= \kill
\T{c} \verb!.! \verb!~! \> путь \verb!~! содержит $>=n$ элементов \\
\verb!/! \T{C}     \> то же самое, но для абсолютного пути \\
\T{t}              \> текущая минута равна \I{n} \\
\T{T}              \> текущий час равен \I{n} \\
\T{d}              \> текущий день равен \I{n} \\
\T{D}              \> месяц равен \I{n} (Jan${}=0$) \\
\T{w}              \> день недели равен \I{n} (Sun${}=0$) \\
\verb!?!           \> код возврата последней команды был равен \I{n} \\
\verb!#!           \> запущен с uid \I{n} \\
\T{g}              \> запущен с gid \I{n} \\
\T{L}              \> \verb!$SHLVL!${}>=n$ \\
\T{S}              \> \verb!$SECONDS!${}>=n$ \\
\T{v}              \> \verb!${#psvar}!${}>=n$ \\
\verb!_!           \> по крайней мере \I{n} конструкций \\
                   \> командного процессора \\
\verb.!.           \> истина, если привилегированный \\
                   \> командный процессор \\
\end{tabbing}

управляющие последовательности в \verb!$WATCHFMT!:
\begin{tabbing}
\hskip 50pt \= \kill
\verb!%n!          \> имя пользователя \\
\verb!%a!          \> `logged on' или `logged off' \\
\verb!%l!          \> терминал пользователя \\
\verb!%M!          \> полное имя удаленного компьютера \\
\verb!%m!          \> имя компьютера до первой `.' \\
\verb!%S! \verb!%U! \verb!%B!
                   \> начать режимы standout, \\
                   \> жирный, подчеркивание  \\
\verb!%s! \verb!%u! \verb!%b!
                   \> остановить соответствующий режим \\
\verb!%t! \verb!%@!
                   \> время в 12-часовом формате \\
\verb!%T!          \> время в 24-часовом формате  \\
\verb!%i!          \> номер строки внутри \verb!%N! \\
\verb!%w!          \> дата в виде \verb!day-dd! \\
\verb!%W!          \> дата в виде \verb!mm/dd/yy! \\
\verb!%D!          \> дата в виде \verb!yy-mm-dd! \\
\end{tabbing}

% end multicols here because at presnt the next bit goes over the page
% and looks odd
\end{multicols}

Трехоперандные выражения в \verb!$WATCHFMT!, формат
\verb!%(!\I{char}\verb!.!\I{true-text}\verb!.!\I{false-text}\verb!)!,
может быть использован с \T{l}, \T{n}, \T{m} or \T{M} (истина, если
не пустое значение для соответствующего \verb!%!), или \T{a} (истина для
подключения (login), ложь для отключения (logout)).

\begin{multicols}{3}[\section{Условия}][10cm]

Проверки файлов: за ними следует имя файла
\begin{tabbing}
\hskip 20pt \= \kill
\B{Cond} \\
                \> \B{истина если файл} \\
\T{-a}          \> существует \\
\T{-b}          \> специальный блоковый \\
\T{-c}          \> специальный символьный \\
\T{-d}          \> каталог \\
\T{-e}          \> существует \\
\T{-f}          \> обычный файл \\
\T{-g}          \> с установленным битом setgid \\
\T{-h}          \> символьная ссылка \\
\T{-k}          \> с установленным битом закрепления (sticky bit) \\
\T{-p}          \> FIFO/pipe \\
\T{-r}          \> доступный для чтения \\
\T{-s}          \> имеет размер  $>0$ \\
\T{-u}          \> с установленным битом setuid \\
\T{-w}          \> доступный для чтения \\
\T{-x}          \> исполняемый/каталог доступный для чтения \\
\T{-L}          \> символьная ссылка \\
\T{-O}          \> владеет UID \\
\T{-G}          \> владеет GID \\
\T{-S}          \> сокет \\
\T{-N}          \> время доступа не позже чем \\
                \> время модификации \\
\end{tabbing}

Другие тесты с одним аргументом:
\begin{tabbing}
\hskip 20pt \= \kill
\T{-n}          \> строка, длина $>0$ \\
\T{-o}          \> опция, установлена \\
\T{-t}          \> файловый дескриптор (fd), открыт на терминал \\
\T{-z}          \> строка, нулевой длины \\
\end{tabbing}

Проверки с двумя аргументами (\Lsq\Lsq \I{a} \T{test} \I{b} \Rsq\Rsq):
\begin{tabbing}
\hskip 20pt \= \kill
\T{-nt}         \> файл \I{a} моложе \I{b} \\
\T{-ot}         \> файл \I{a} старше \I{b} \\
\T{-ef}         \> имена ссылаются на один и тот же файл \\
\T{=} \\
\T{==}          \> \I{строка} соответствует \I{шаблону} \\
\T{!=}          \> \dots не соответствует \\
\T{<}           \> ASCII до \\
\T{>}           \> ASCII после \\
\T{-eq}         \> числа равны \\
\T{-ne}         \> числа не равны \\
\T{-lt}         \> числовое $a<b$ \\
\T{-gt}         \> числовое $a>b$ \\
\T{-le}         \> числовое $a\leq b$ \\
\T{-ge}         \> числовое $a\geq b$ \\
\end{tabbing}

А также группировка \Lpa\dots\Rpa, отрицание \T{!}, и \verb!&&!, или
\verb!||!; специальная обработка \B{/dev/fd}.

\vfill
\end{multicols}

\end{document}
