// AUTO-GENERATED. DO NOT EDIT BY HAND.
//
// Source: zsh upstream `/Users/wizard/forkedRepos/zsh/Doc/Zsh/options.yo`.
// Regen: ./scripts/gen_option_docs.py --source options /Users/wizard/forkedRepos/zsh/Doc/Zsh/options.yo > <this file>
// Generated: 2026-05-23
/// Canonical option name → markdown documentation body.
/// Pulled verbatim from every `item(tt(NAME))(...)` block in
/// the upstream yodl source. Use [`lookup_option_doc`] to resolve
/// case-insensitive lookups and any negated/compact aliases.
pub const OPTION_DOCS: &[(&str, &str)] = &[
("AUTO_CD", "If a command is issued that can't be executed as a normal command,\nand the command is the name of a directory, perform the `cd`\ncommand to that directory.\nThis option is only applicable if the option `SHIN_STDIN` is set,\ni.e. if commands are being read from standard input. The option\nis designed for interactive use; it is recommended that `cd`\nbe used explicitly in scripts to avoid ambiguity."),
("AUTO_PUSHD", "Make `cd` push the old directory onto the directory stack."),
("CDABLE_VARS", "If the argument to a `cd` command (or an implied `cd` with the\n`AUTO_CD` option set) is not a directory, and does not begin with a\nslash, try to expand the expression as if it were preceded by a \"~\" (see\n_Filename Expansion_ (zshexpn))."),
("CD_SILENT", "Never print the working directory after a `cd` (whether explicit or\nimplied with the `AUTO_CD` option set). `cd` normally prints the\nworking directory when the argument given to it was `-`, a stack entry, or\nthe name of a directory found under `CDPATH`. Note that this is distinct\nfrom `pushd`'s stack-printing behaviour, which is controlled by\n`PUSHD_SILENT`. This option overrides the printing-related effects of\n`POSIX_CD`."),
("CHASE_DOTS", "When changing to a directory containing a path segment \"..\" which would\notherwise be treated as canceling the previous segment in the path (in\nother words, \"foo/..\" would be removed from the path, or if \"..\" is\nthe first part of the path, the last part of the current working directory\nwould be removed), instead resolve the path to the physical directory.\nThis option is overridden by `CHASE_LINKS`.\n\nFor example, suppose `/foo/bar` is a link to the directory `/alt/rod`.\nWithout this option set, \"cd /foo/bar/..\" changes to `/foo`; with it\nset, it changes to `/alt`. The same applies if the current directory\nis `/foo/bar` and \"cd ..\" is used. Note that all other symbolic\nlinks in the path will also be resolved."),
("CHASE_LINKS", "Resolve symbolic links to their true values when changing directory.\nThis also has the effect of `CHASE_DOTS`, i.e. a \"..\" path segment\nwill be treated as referring to the physical parent, even if the preceding\npath segment is a symbolic link."),
("POSIX_CD", "Modifies the behaviour of `cd`, `chdir` and `pushd` commands\nto make them more compatible with the POSIX standard. The behaviour with\nthe option unset is described in the documentation for the `cd`\nbuiltin in nmref(Shell Builtin Commands)(zshbuiltins).\nIf the option is set, the shell does not test for directories beneath\nthe local directory (\".\") until after all directories in `cdpath`\nhave been tested, and the `cd` and `chdir` commands do not recognise\narguments of the form `{`+`|`-\"}_n_\" as directory stack entries.\n\nAlso, if the option is set, the conditions under which the shell\nprints the new directory after changing to it are modified. It is\nno longer restricted to interactive shells (although printing of\nthe directory stack with `pushd` is still limited to interactive\nshells); and any use of a component of `CDPATH`, including a \".\" but\nexcluding an empty component that is otherwise treated as \".\", causes\nthe directory to be printed."),
("PUSHD_IGNORE_DUPS", "Don't push multiple copies of the same directory onto the directory stack."),
("PUSHD_MINUS", "Exchanges the meanings of \"+\" and \"-\"\nwhen used with a number to specify a directory in the stack."),
("PUSHD_SILENT", "Do not print the directory stack after `pushd` or `popd`."),
("PUSHD_TO_HOME", "Have `pushd` with no arguments act like \"pushd $HOME\"."),
("ALWAYS_LAST_PROMPT", "If unset, key functions that list completions try to return to the last\nprompt if given a numeric argument. If set these functions try to\nreturn to the last prompt if given _no_ numeric argument."),
("ALWAYS_TO_END", "If a completion is performed with the cursor within a word, and a\nfull completion is inserted, the cursor is moved to the end of the\nword. That is, the cursor is moved to the end of the word if either\na single match is inserted or menu completion is performed."),
("AUTO_LIST", "Automatically list choices on an ambiguous completion."),
("AUTO_MENU", "Automatically use menu completion after the second consecutive request for\ncompletion, for example by pressing the tab key repeatedly. This option\nis overridden by `MENU_COMPLETE`."),
("AUTO_NAME_DIRS", "Any parameter that is set to the absolute name of a directory\nimmediately becomes a name for that directory, that will be used\nby the \"%~\"\nand related prompt sequences, and will be available when completion\nis performed on a word starting with \"~\".\n(Otherwise, the parameter must be used in the form ``~\"_param_\" first.)"),
("AUTO_PARAM_KEYS", "If a parameter name was completed and a following character\n(normally a space) automatically\ninserted, and the next character typed is one\nof those that have to come directly after the name (like \"}\", \":\",\netc.), the automatically added character is deleted, so that the character\ntyped comes immediately after the parameter name.\nCompletion in a brace expansion is affected similarly: the added character\nis a \",\", which will be removed if \"}\" is typed next."),
("AUTO_PARAM_SLASH", "If a parameter is completed whose content is the name of a directory,\nthen add a trailing slash instead of a space."),
("AUTO_REMOVE_SLASH", "When the last character resulting from a completion is a slash and the next\ncharacter typed is a word delimiter, a slash, or a character that ends\na command (such as a semicolon or an ampersand), remove the slash."),
("BASH_AUTO_LIST", "On an ambiguous completion, automatically list choices when the\ncompletion function is called twice in succession. This takes\nprecedence over `AUTO_LIST`. The setting of `LIST_AMBIGUOUS` is\nrespected. If `AUTO_MENU` is set, the menu behaviour will then start\nwith the third press. Note that this will not work with\n`MENU_COMPLETE`, since repeated completion calls immediately cycle\nthrough the list in that case."),
("COMPLETE_ALIASES", "Prevents aliases on the command line from being internally substituted\nbefore completion is attempted. The effect is to make the alias a\ndistinct command for completion purposes."),
("COMPLETE_IN_WORD", "If unset, the cursor is set to the end of the word if completion is\nstarted. Otherwise it stays there and completion is done from both ends."),
("GLOB_COMPLETE", "When the current word has a glob pattern, do not insert all the words\nresulting from the expansion but generate matches as for completion and\ncycle through them like `MENU_COMPLETE`. The matches are generated as if\na \"*\" was added to the end of the word, or inserted at the cursor when\n`COMPLETE_IN_WORD` is set. This actually uses pattern matching, not\nglobbing, so it works not only for files but for any completion, such as\noptions, user names, etc.\n\nNote that when the pattern matcher is used, matching control (for example,\ncase-insensitive or anchored matching) cannot be used. This limitation\nonly applies when the current word contains a pattern; simply turning\non the `GLOB_COMPLETE` option does not have this effect."),
("HASH_LIST_ALL", "Whenever a command completion or spelling correction is attempted, make\nsure the entire command path is hashed first. This makes the first\ncompletion slower but avoids false reports of spelling errors."),
("LIST_AMBIGUOUS", "This option works when `AUTO_LIST` or `BASH_AUTO_LIST` is also\nset. If there is an unambiguous prefix to insert on the command line,\nthat is done without a completion list being displayed; in other\nwords, auto-listing behaviour only takes place when nothing would be\ninserted. In the case of `BASH_AUTO_LIST`, this means that the list\nwill be delayed to the third call of the function."),
("LIST_BEEP", "Beep on an ambiguous completion. More accurately, this forces the\ncompletion widgets to return status 1 on an ambiguous completion, which\ncauses the shell to beep if the option `BEEP` is also set; this may\nbe modified if completion is called from a user-defined widget."),
("LIST_PACKED", "Try to make the completion list smaller (occupying less lines) by\nprinting the matches in columns with different widths."),
("LIST_ROWS_FIRST", "Lay out the matches in completion lists sorted horizontally, that is,\nthe second match is to the right of the first one, not under it as\nusual."),
("LIST_TYPES", "When listing files that are possible completions, show the\ntype of each file with a trailing identifying mark."),
("MENU_COMPLETE", "On an ambiguous completion, instead of listing possibilities or beeping,\ninsert the first match immediately. Then when completion is requested\nagain, remove the first match and insert the second match, etc.\nWhen there are no more matches, go back to the first one again.\n`reverse-menu-complete` may be used to loop through the list\nin the other direction. This option overrides `AUTO_MENU`."),
("REC_EXACT", "If the string on the command line exactly matches one of the possible\ncompletions, it is accepted, even if there is another completion (i.e. that\nstring with something else added) that also matches."),
("BAD_PATTERN", "If a pattern for filename generation is badly formed, print an error message.\n(If this option is unset, the pattern will be left unchanged.)"),
("BARE_GLOB_QUAL", "In a glob pattern, treat a trailing set of parentheses as a qualifier\nlist, if it contains no unquoted \"|\", \"tt(()\" or (if special) \"~\"\ncharacters. See _Filename Generation_ (zshexpn)."),
("BRACE_CCL", "Expand expressions in braces which would not otherwise undergo brace\nexpansion to a lexically ordered list of all the characters. See\n_Brace Expansion_ (zshexpn)."),
("CASE_GLOB", "Make globbing (filename generation) sensitive to case. Note that other\nuses of patterns are always sensitive to case. If the option is unset,\nthe presence of any character which is special to filename generation\nwill cause case-insensitive matching. For example, tt(cvs+(/+))\ncan match the directory `CVS` owing to the presence of the globbing flag\n(unless the option `BARE_GLOB_QUAL` is unset)."),
("CASE_MATCH", "Make regular expressions using the `zsh/regex` module (including\nmatches with `=~`) sensitive to case."),
("CASE_PATHS", "If `CASE_PATHS` is not set (the default), `CASE_GLOB` affects the\ninterpretation of _every_ path component, whenever a special\ncharacter appears in _any_ component. When `CASE_PATHS` is set,\nfile path components that do _not_ contain special filename\ngeneration characters are always sensitive to case, thus restricting\n`NO_CASE_GLOB` to components that contain globbing characters.\n\nNote that if the filesystem itself is not sensitive to case, then\n`CASE_PATHS` has no effect."),
("CSH_NULL_GLOB", "If a pattern for filename generation has no matches,\ndelete the pattern from the argument list;\ndo not report an error unless all the patterns\nin a command have no matches.\nOverrides `NOMATCH`."),
("EQUALS", "Perform `=` filename expansion.\n(See _Filename Expansion_ (zshexpn).)"),
("EXTENDED_GLOB", "Treat the \"#\", \"~\" and \"^\" characters as part of patterns\nfor filename generation, etc. (An initial unquoted \"~\"\nalways produces named directory expansion.)"),
("FORCE_FLOAT", "Constants in arithmetic evaluation will be treated as\nfloating point even without the use of a decimal point; the\nvalues of integer variables will be converted to floating point when\nused in arithmetic expressions. Integers in any base will be converted."),
("GLOB", "Perform filename generation (globbing).\n(See _Filename Generation_ (zshexpn).)"),
("GLOB_ASSIGN", "If this option is set, filename generation (globbing) is\nperformed on the right hand side of scalar parameter assignments of\nthe form `_name_`=`_pattern_ (e.g. \"foo=*\").\nIf the result has more than one word the parameter will become an array\nwith those words as arguments. This option is provided for backwards\ncompatibility only: globbing is always performed on the right hand side\nof array assignments of the form `_name_tt(=()_value_`\")\"\n(e.g. \"tt(foo=(*))\") and this form is recommended for clarity;\nwith this option set, it is not possible to predict whether the result\nwill be an array or a scalar."),
("GLOB_DOTS", "Do not require a leading \".\" in a filename to be matched explicitly."),
("GLOB_STAR_SHORT", "When this option is set and the default zsh-style globbing is in\neffect, the pattern \"**/*\" can be abbreviated to \"**\" and the\npattern \"***/*\" can be abbreviated to `***`. Hence \"**.c\"\nfinds a file ending in `.c` in any subdirectory, and \"***.c\" does\nthe same while also following symbolic links. A `/` immediately\nafter the \"**\" or \"***\" forces the pattern to be treated as the\nunabbreviated form."),
("GLOB_SUBST", "Treat any characters resulting from parameter expansion as being\neligible for filename expansion and filename generation, and any\ncharacters resulting from command substitution as being eligible for\nfilename generation. Braces (and commas in between) do not become eligible\nfor expansion."),
("HIST_SUBST_PATTERN", "Substitutions using the `:s` and `:&` history modifiers are performed\nwith pattern matching instead of string matching. This occurs wherever\nhistory modifiers are valid, including glob qualifiers and parameters.\nSee subref(Modifiers)(zshexpn)."),
("IGNORE_BRACES", "Do not perform brace expansion. For historical reasons this\nalso includes the effect of the `IGNORE_CLOSE_BRACES` option."),
("IGNORE_CLOSE_BRACES", "When neither this option nor `IGNORE_BRACES` is set, a sole\nclose brace character \"}\" is syntactically significant at any\npoint on a command line. This has the effect that no semicolon\nor newline is necessary before the brace terminating a function\nor current shell construct. When either option is set, a closing brace\nis syntactically significant only in command position. Unlike\n`IGNORE_BRACES`, this option does not disable brace expansion.\n\nFor example, with both options unset a function may be defined\nin the following fashion:\n\nexample(args+() { echo $# })\n\nwhile if either option is set, this does not work and something\nequivalent to the following is required:\n\nexample(args+() { echo $#; })"),
("KSH_GLOB", "In pattern matching, the interpretation of parentheses is affected by\na preceding \"@\", \"*\", \"+\", \"?\" or \"!\".\nSee _Filename Generation_ (zshexpn)."),
("MAGIC_EQUAL_SUBST", "All unquoted arguments of the form `_anything_`=\"_expression_\"\nappearing after the command name have filename expansion (that is,\nwhere _expression_ has a leading \"~\" or \"=\") performed on\n_expression_ as if it were a parameter assignment. The argument is\nnot otherwise treated specially; it is passed to the command as a single\nargument, and not used as an actual parameter assignment. For example, in\n`echo foo=~/bar:~/rod`, both occurrences of `~` would be replaced.\nNote that this happens anyway with `typeset` and similar statements.\n\nThis option respects the setting of the `KSH_TYPESET` option. In other\nwords, if both options are in effect, arguments looking like\nassignments will not undergo word splitting."),
("MARK_DIRS", "Append a trailing \"/\" to all directory\nnames resulting from filename generation (globbing)."),
("MULTIBYTE", "Respect multibyte characters when found in strings.\nWhen this option is set, strings are examined using the\nsystem library to determine how many bytes form a character, depending\non the current locale. This affects the way characters are counted in\npattern matching, parameter values and various delimiters.\n\nThe option is on by default if the shell was compiled with\n`MULTIBYTE_SUPPORT`; otherwise it is off by default and has no effect\nif turned on.\n\nIf the option is off a single byte is always treated as a single\ncharacter. This setting is designed purely for examining strings\nknown to contain raw bytes or other values that may not be characters\nin the current locale. It is not necessary to unset the option merely\nbecause the character set for the current locale does not contain multibyte\ncharacters.\n\nThe option does not affect the shell's editor, which always uses the\nlocale to determine multibyte characters. This is because\nthe character set displayed by the terminal emulator is independent of\nshell settings."),
("NOMATCH", "If a pattern for filename generation has no matches,\nprint an error, instead of\nleaving it unchanged in the argument list.\nThis also applies to file expansion\nof an initial \"~\" or \"=\"."),
("NULL_GLOB", "If a pattern for filename generation has no matches,\ndelete the pattern from the argument list instead\nof reporting an error. Overrides `NOMATCH`."),
("NUMERIC_GLOB_SORT", "If numeric filenames are matched by a filename generation pattern,\nsort the filenames numerically rather than lexicographically."),
("RC_EXPAND_PARAM", "Array expansions of the form\n`_foo_`${`_xx_`}\"_bar_\", where the parameter\n_xx_ is set to tt(()_a b c_``), are substituted with\n\"_fooabar foobbar foocbar_\" instead of the default\n\"_fooa b cbar_\". Note that an empty array will therefore cause\nall arguments to be removed."),
("REMATCH_PCRE", "If set, regular expression matching with the `=~` operator will use\nPerl-Compatible Regular Expressions from the PCRE library.\n(The `zsh/pcre` module must be available.)\nIf not set, regular expressions will use the extended regexp syntax\nprovided by the system libraries."),
("SH_GLOB", "Disables the special meaning of \"tt(()\", \"|\", ``\")\"\nand '`<`' for globbing the result of parameter and command substitutions,\nand in some other places where\nthe shell accepts patterns. If `SH_GLOB` is set but `KSH_GLOB` is\nnot, the shell allows the interpretation of\nsubshell expressions enclosed in parentheses in some cases where there\nis no space before the opening parenthesis, e.g. tt(!(true+))\nis interpreted as if there were a space after the `!`. This option is\nset by default if zsh is invoked as `sh` or `ksh`."),
("UNSET", "Treat unset parameters as if they were empty when substituting, and as if\nthey were zero when reading their values in arithmetic expansion and\narithmetic commands.\nOtherwise they are treated as an error."),
("WARN_CREATE_GLOBAL", "Print a warning message when a global parameter is created in a function\nby an assignment or in math context.\nThis often indicates that a parameter has not been\ndeclared local when it should have been. Parameters explicitly declared\nglobal from within a function using `typeset -g` do not cause a warning.\nNote that there is no warning when a local parameter is assigned to in\na nested function, which may also indicate an error."),
("WARN_NESTED_VAR", "Print a warning message when an existing parameter from an\nenclosing function scope, or global, is set in a function\nby an assignment or in math context. Assignment to shell\nspecial parameters does not cause a warning. This is the companion\nto `WARN_CREATE_GLOBAL` as in this case the warning is only\nprinted when a parameter is _not_ created. Where possible,\nuse of `typeset -g` to set the parameter suppresses the error,\nbut note that this needs to be used every time the parameter is set.\nTo restrict the effect of this option to a single function scope,\nuse \"functions -W\".\n\nFor example, the following code produces a warning for the assignment\ninside the function `nested` as that overrides the value within\n`toplevel`\n\nexample(toplevel+() {\n local foo=\"in fn\"\n nested\n}\nnested+() {\n foo=\"in nested\"\n}\nsetopt warn_nested_var\ntoplevel)"),
("APPEND_HISTORY", "If this is set, zsh sessions will append their history list to\nthe history file, rather than replace it. Thus, multiple parallel\nzsh sessions will all have the new entries from their history lists\nadded to the history file, in the order that they exit.\nThe file will still be periodically re-written to trim it when the\nnumber of lines grows 20% beyond the value specified by\n`$SAVEHIST` (see also the `HIST_SAVE_BY_COPY` option)."),
("BANG_HIST", "Perform textual history expansion, **csh**-style,\ntreating the character \"!\" specially."),
("EXTENDED_HISTORY", "Save each command's beginning timestamp (in seconds since the epoch)\nand the duration (in seconds) to the history file. The format of\nthis prefixed data is:\n\n``: `_<beginning time>_`:`_<elapsed seconds>_`;\"_<command>_\"."),
("HIST_ALLOW_CLOBBER", "Add \"|\" to output redirections in the history. This allows history\nreferences to clobber files even when `CLOBBER` is unset."),
("HIST_BEEP", "Beep in ZLE when a widget attempts to access a history entry which\nisn't there."),
("HIST_EXPIRE_DUPS_FIRST", "If the internal history needs to be trimmed to add the current command line,\nsetting this option will cause the oldest history event that has a duplicate\nto be lost before losing a unique event from the list.\nYou should be sure to set the value of `HISTSIZE` to a larger number\nthan `SAVEHIST` in order to give you some room for the duplicated\nevents, otherwise this option will behave just like\n`HIST_IGNORE_ALL_DUPS` once the history fills up with unique events."),
("HIST_FCNTL_LOCK", "When writing out the history file, by default zsh uses ad-hoc file locking\nto avoid known problems with locking on some operating systems. With this\noption locking is done by means of the system's `fcntl` call, where\nthis method is available. On recent operating systems this may\nprovide better performance, in particular avoiding history corruption when\nfiles are stored on NFS."),
("HIST_FIND_NO_DUPS", "When searching for history entries in the line editor, do not display\nduplicates of a line previously found, even if the duplicates are not\ncontiguous."),
("HIST_IGNORE_ALL_DUPS", "If a new command line being added to the history list duplicates an\nolder one, the older command is removed from the list (even if it is\nnot the previous event)."),
("HIST_IGNORE_DUPS", "Do not enter command lines into the history list\nif they are duplicates of the previous event."),
("HIST_IGNORE_SPACE", "Remove command lines from the history list when the first character on\nthe line is a space, or when one of the expanded aliases contains a\nleading space. Only normal aliases (not global or suffix aliases)\nhave this behaviour.\nNote that the command lingers in the internal history until the next\ncommand is entered before it vanishes, allowing you to briefly reuse\nor edit the line. If you want to make it vanish right away without\nentering another command, type a space and press return."),
("HIST_LEX_WORDS", "By default, shell history that is read in from files is split into\nwords on all white space. This means that arguments with quoted\nwhitespace are not correctly handled, with the consequence that\nreferences to words in history lines that have been read from a file\nmay be inaccurate. When this option is set, words read in from a\nhistory file are divided up in a similar fashion to normal shell\ncommand line handling. Although this produces more accurately delimited\nwords, if the size of the history file is large this can be slow. Trial\nand error is necessary to decide."),
("HIST_NO_FUNCTIONS", "Remove function definitions from the history list.\nNote that the function lingers in the internal history until the next\ncommand is entered before it vanishes, allowing you to briefly reuse\nor edit the definition."),
("HIST_NO_STORE", "Remove the `history` (`fc -l`) command from the history list\nwhen invoked.\nNote that the command lingers in the internal history until the next\ncommand is entered before it vanishes, allowing you to briefly reuse\nor edit the line."),
("HIST_REDUCE_BLANKS", "Remove superfluous blanks from each command line\nbeing added to the history list."),
("HIST_SAVE_BY_COPY", "When the history file is re-written, we normally write out a copy of\nthe file named `$HISTFILE.new` and then rename it over the old one.\nHowever, if this option is unset, we instead truncate the old\nhistory file and write out the new version in-place. If one of the\nhistory-appending options is enabled, this option only has an effect\nwhen the enlarged history file needs to be re-written to trim it\ndown to size. Disable this only if you have special needs, as doing\nso makes it possible to lose history entries if zsh gets interrupted\nduring the save.\n\nWhen writing out a copy of the history file, zsh preserves the old\nfile's permissions and group information, but will refuse to write\nout a new file if it would change the history file's owner."),
("HIST_SAVE_NO_DUPS", "When writing out the history file, older commands that duplicate\nnewer ones are omitted."),
("HIST_VERIFY", "Whenever the user enters a line with history expansion,\ndon't execute the line directly; instead, perform\nhistory expansion and reload the line into the editing buffer."),
("INC_APPEND_HISTORY", "This option works like `APPEND_HISTORY` except that new history lines\nare added to the `$HISTFILE` incrementally (as soon as they are\nentered), rather than waiting until the shell exits.\nThe file will still be periodically re-written to trim it when the\nnumber of lines grows 20% beyond the value specified by\n`$SAVEHIST` (see also the `HIST_SAVE_BY_COPY` option)."),
("INC_APPEND_HISTORY_TIME", "This option is a variant of `INC_APPEND_HISTORY` in which, where\npossible, the history entry is written out to the file after the\ncommand is finished, so that the time taken by the command is recorded\ncorrectly in the history file in `EXTENDED_HISTORY` format. This\nmeans that the history entry will not be available immediately from\nother instances of the shell that are using the same history file.\n\nThis option is only useful if `INC_APPEND_HISTORY` and\n`SHARE_HISTORY` are turned off. The three options should be\nconsidered mutually exclusive."),
("SHARE_HISTORY", "This option both imports new commands from the history file, and also\ncauses your typed commands to be appended to the history file (the\nlatter is like specifying `INC_APPEND_HISTORY`, which should be turned\noff if this option is in effect). The history lines are also output\nwith timestamps ala `EXTENDED_HISTORY` (which makes it easier to find\nthe spot where we left off reading the file after it gets re-written).\n\nBy default, history movement commands visit the imported lines as\nwell as the local lines, but you can toggle this on and off with the\nset-local-history zle binding. It is also possible to create a zle\nwidget that will make some commands ignore imported commands, and\nsome include them.\n\nIf you find that you want more control over when commands\nget imported, you may wish to turn `SHARE_HISTORY` off,\n`INC_APPEND_HISTORY` or `INC_APPEND_HISTORY_TIME` (see above) on,\nand then manually import commands whenever you need them using ``fc\n-RI`'."),
("ALL_EXPORT", "All parameters subsequently defined are automatically exported."),
("GLOBAL_EXPORT", "If this option is set, passing the `-x` flag to the builtins `declare`,\n`float`, `integer`, `readonly` and `typeset` (but not `local`)\nwill also set the `-g` flag; hence parameters exported to\nthe environment will not be made local to the enclosing function, unless\nthey were already or the flag `+g` is given explicitly. If the option is\nunset, exported parameters will be made local in just the same way as any\nother parameter.\n\nThis option is set by default for backward compatibility; it is not\nrecommended that its behaviour be relied upon. Note that the builtin\n`export` always sets both the `-x` and `-g` flags, and hence its\neffect extends beyond the scope of the enclosing function; this is the\nmost portable way to achieve this behaviour."),
("GLOBAL_RCS", "If this option is unset, the startup files tt(zprofile()),\ntt(zshrc()), tt(zlogin()) and tt(zlogout()) will not be run. It\ncan be disabled and re-enabled at any time, including inside local startup\nfiles (`.zshrc`, etc.)."),
("RCS", "After tt(zshenv()) is sourced on startup, source the\n`.zshenv`, tt(zprofile()), `.zprofile`,\ntt(zshrc()), `.zshrc`, tt(zlogin()), `.zlogin`, and `.zlogout`\nfiles, as described in _Startup/Shutdown Files_ (zsh).\nIf this option is unset, the tt(zshenv()) file is still sourced, but any\nof the others will not be; it can be set at any time to prevent the\nremaining startup files after the currently executing one from\nbeing sourced."),
("ALIASES", "Expand aliases."),
("CLOBBER", "Allows \">\" redirection to truncate existing files.\nOtherwise \">!\" or \">|\" must be used to truncate a file.\n\nIf the option is not set, and the option `APPEND_CREATE` is also\nnot set, \">>!\" or \">>|\" must be used to create a file.\nIf either option is set, \">>\" may be used."),
("CLOBBER_EMPTY", "This option is only used if the option `CLOBBER` is not set: note that\nit is set by default.\n\nIf this option is set, then regular files of zero length may be\novewritten (\"clobbered\"). Note that it is possible another process\nhas written to the file between this test and use of the file by\nthe current process. This option should therefore not be used in\ncases where files to be clobbered may be written to asynchronously."),
("CORRECT", "Try to correct the spelling of commands.\nNote that, when the `HASH_LIST_ALL` option is not set or when some\ndirectories in the path are not readable, this may falsely report spelling\nerrors the first time some commands are used.\n\nRefer to the shell variable `SPROMPT` for an explanation of the\n\"[nyae]\" (no/yes/abort/edit) prompt that is offered.\n\nThe shell variable `CORRECT_IGNORE` may be set to a pattern to\nmatch words that will never be offered as corrections."),
("CORRECT_ALL", "Try to correct the spelling of all arguments in a line, in order from\nleft to right, treating each as a file name. Answering \"a\" or\n\"e\" at any prompt stops all corrections, otherwise every correction\nis prompted for.\n\nThe shell variable `CORRECT_IGNORE_FILE` may be set to a pattern to\nmatch file names that will never be offered as corrections."),
("DVORAK", "Use the Dvorak keyboard instead of the standard qwerty keyboard as a basis\nfor examining spelling mistakes for the `CORRECT` and `CORRECT_ALL`\noptions and the `spell-word` editor command."),
("FLOW_CONTROL", "If this option is unset,\noutput flow control via start/stop characters (usually assigned to\n^S/^Q) is disabled in the shell's editor."),
("IGNORE_EOF", "Do not exit on end-of-file. Require the use\nof `exit` or `logout` instead.\nHowever, ten consecutive EOFs will cause the shell to exit anyway,\nto avoid the shell hanging if its tty goes away.\n\nAlso, if this option is set and the Zsh Line Editor is used, widgets\nimplemented by shell functions can be bound to EOF (normally\nControl-D) without printing the normal warning message. This works\nonly for normal widgets, not for completion widgets."),
("INTERACTIVE_COMMENTS", "Allow comments even in interactive shells."),
("HASH_CMDS", "Note the location of each command the first time it is executed.\nSubsequent invocations of the same command will use the\nsaved location, avoiding a path search.\nIf this option is unset, no path hashing is done at all.\nHowever, when `CORRECT` is set, commands whose names do not appear in\nthe functions or aliases hash tables are hashed in order to avoid\nreporting them as spelling errors."),
("HASH_DIRS", "Whenever a command name is hashed, hash the directory containing it,\nas well as all directories that occur earlier in the path.\nHas no effect if neither `HASH_CMDS` nor `CORRECT` is set."),
("HASH_EXECUTABLES_ONLY", "When hashing commands because of `HASH_CMDS`, check that the\nfile to be hashed is actually an executable. This option\nis unset by default as if the path contains a large number of commands,\nor consists of many remote files, the additional tests can take\na long time. Trial and error is needed to show if this option is\nbeneficial."),
("MAIL_WARNING", "Print a warning message if a mail file has been\naccessed since the shell last checked."),
("PATH_DIRS", "Perform a path search even on command names with slashes in them.\nThus if \"/usr/local/bin\" is in the user's path, and he or she types\n\"X11/xinit\", the command \"/usr/local/bin/X11/xinit\" will be executed\n(assuming it exists).\nCommands explicitly beginning with \"/\", \"./\" or \"../\"\nare not subject to the path search.\nThis also applies to the \".\" and `source` builtins.\n\nNote that subdirectories of the current directory are always searched for\nexecutables specified in this form. This takes place before any search\nindicated by this option, and regardless of whether \".\" or the current\ndirectory appear in the command search path."),
("PATH_SCRIPT", "If this option is not set, a script passed as the first non-option argument\nto the shell must contain the name of the file to open. If this\noption is set, and the script does not specify a directory path,\nthe script is looked for first in the current directory, then in the\ncommand path. See _Invocation_ (zsh)."),
("PRINT_EIGHT_BIT", "Print eight bit characters literally in completion lists, etc.\nThis option is not necessary if your system correctly returns the\nprintability of eight bit characters (see manref(ctype)(3))."),
("PRINT_EXIT_VALUE", "Print the exit value of programs with non-zero exit status.\nThis is only available at the command line in interactive shells."),
("RC_QUOTES", "Allow the character sequence ``''`' to signify a single quote\nwithin singly quoted strings. Note this does not apply in quoted strings\nusing the format \"$\"`_..._`'`, where a backslashed single quote can\nbe used."),
("RM_STAR_SILENT", "Do not query the user before executing \"rm *\" or \"rm path/*\"."),
("RM_STAR_WAIT", "If querying the user before executing \"rm *\" or \"rm path/*\",\nfirst wait ten seconds and ignore anything typed in that time.\nThis avoids the problem of reflexively answering \"yes\" to the query\nwhen one didn't really mean it. The wait and query can always be\navoided by expanding the \"*\" in ZLE (with tab)."),
("SHORT_LOOPS", "Allow the short forms of `for`, `repeat`, `select`,\n`if`, and `function` constructs."),
("SHORT_REPEAT", "Allow the short form `repeat` as `SHORT_LOOPS` but without enabling\nit for the other constructs."),
("SUN_KEYBOARD_HACK", "If a line ends with a backquote, and there are an odd number\nof backquotes on the line, ignore the trailing backquote.\nThis is useful on some keyboards where the return key is\ntoo small, and the backquote key lies annoyingly close to it.\nAs an alternative the variable `KEYBOARD_HACK` lets you choose the\ncharacter to be removed."),
("AUTO_CONTINUE", "With this option set, stopped jobs that are removed from the job table\nwith the `disown` builtin command are automatically sent a `CONT`\nsignal to make them running."),
("AUTO_RESUME", "Treat single word simple commands without redirection\nas candidates for resumption of an existing job."),
("BG_NICE", "Run all background jobs at a lower priority. This option\nis set by default."),
("CHECK_JOBS", "Report the status of background and suspended jobs before exiting a shell\nwith job control; a second attempt to exit the shell will succeed.\n`NO_CHECK_JOBS` is best used only in combination with `NO_HUP`, else\nsuch jobs will be killed automatically.\n\nThe check is omitted if the commands run from the previous command line\nincluded a \"jobs\" command, since it is assumed the user is aware that\nthere are background or suspended jobs. A \"jobs\" command run from one\nof the hook functions defined in _Special Functions_ (zshmisc)\nis not counted for this purpose."),
("CHECK_RUNNING_JOBS", "Check for both running and suspended jobs when `CHECK_JOBS` is enabled.\nWhen this option is disabled, zsh checks only for suspended jobs, which\nmatches the default behavior of bash.\n\nThis option has no effect unless `CHECK_JOBS` is set."),
("HUP", "Send the `HUP` signal to running jobs when the\nshell exits."),
("LONG_LIST_JOBS", "Print job notifications in the long format by default."),
("MONITOR", "Allow job control. Set by default in interactive shells."),
("NOTIFY", "Report the status of background jobs immediately, rather than\nwaiting until just before printing a prompt."),
("POSIX_JOBS", "This option makes job control more compliant with the POSIX standard.\n\nWhen the option is not set, the `MONITOR` option is unset on entry to\nsubshells, so that job control is no longer active. When the option is\nset, the `MONITOR` option and job control remain active in the\nsubshell, but note that the subshell has no access to jobs in the parent\nshell.\n\nWhen the option is not set, jobs put in the background or foreground\nwith `bg` or `fg` are displayed with the same information that would\nbe reported by `jobs`. When the option is set, only the text is\nprinted. The output from `jobs` itself is not affected by the option.\n\nWhen the option is not set, job information from the parent\nshell is saved for output within a subshell (for example, within a\npipeline). When the option is set, the output of `jobs` is empty\nuntil a job is started within the subshell.\n\nIn previous versions of the shell, it was necessary to enable\n`POSIX_JOBS` in order for the builtin command `wait` to return the\nstatus of background jobs that had already exited. This is no longer\nthe case."),
("PROMPT_BANG", "If set, \"!\" is treated specially in prompt expansion.\nSee _Expansion of Prompt Sequences_ (zshmisc)."),
("PROMPT_CR", "Print a carriage return just before printing\na prompt in the line editor. This is on by default as multi-line editing\nis only possible if the editor knows where the start of the line appears."),
("PROMPT_SP", "Attempt to preserve a partial line (i.e. a line that did not end with a\nnewline) that would otherwise be covered up by the command prompt due to\nthe `PROMPT_CR` option. This works by outputting some cursor-control\ncharacters, including a series of spaces, that should make the terminal\nwrap to the next line when a partial line is present (note that this is\nonly successful if your terminal has automatic margins, which is typical).\n\nWhen a partial line is preserved, by default you will see an inverse+bold\ncharacter at the end of the partial line: a \"%\" for a normal user or\na \"#\" for root. If set, the shell parameter `PROMPT_EOL_MARK` can be\nused to customize how the end of partial lines are shown.\n\nNOTE: if the `PROMPT_CR` option is not set, enabling this option will\nhave no effect. This option is on by default."),
("PROMPT_PERCENT", "If set, \"%\" is treated specially in prompt expansion.\nSee _Expansion of Prompt Sequences_ (zshmisc)."),
("PROMPT_SUBST", "If set, _parameter expansion_, _command substitution_ and\n_arithmetic expansion_ are performed in prompts. Substitutions\nwithin prompts do not affect the command status."),
("TRANSIENT_RPROMPT", "Remove any right prompt from display when accepting a command\nline. This may be useful with terminals with other cut/paste methods."),
("ALIAS_FUNC_DEF", "By default, zsh does not allow the definition of functions using\nthe \"_name_ tt(())\" syntax if _name_ was expanded as an\nalias: this causes an error. This is usually the desired behaviour, as\notherwise the combination of an alias and a function based on the same\ndefinition can easily cause problems.\n\nWhen this option is set, aliases can be used for defining functions.\n\nFor example, consider the following definitions as they might\noccur in a startup file.\n\nexample(alias foo=bar\nfoo+() {\n print This probably does not do what you expect.\n})\n\nHere, `foo` is expanded as an alias to `bar` before the\ntt(()) is encountered, so the function defined would be named\n`bar`. By default this is instead an error in native mode. Note that\nquoting any part of the function name, or using the keyword\n`function`, avoids the problem, so is recommended when the function\nname can also be an alias."),
("C_BASES", "Output hexadecimal numbers in the standard C format, for example \"0xFF\"\ninstead of the usual \"16#FF\". If the option `OCTAL_ZEROES` is also\nset (it is not by default), octal numbers will be treated similarly and\nhence appear as \"077\" instead of \"8#77\". This option has no effect\non the choice of the output base, nor on the output of bases other than\nhexadecimal and octal. Note that these formats will be understood on input\nirrespective of the setting of `C_BASES`."),
("C_PRECEDENCES", "This alters the precedence of arithmetic operators to be more\nlike C and other programming languages;\n_Arithmetic Evaluation_ (zshmisc)\nhas an explicit list."),
("DEBUG_BEFORE_CMD", "Run the `DEBUG` trap before each command; otherwise it is run after\neach command. Setting this option mimics the behaviour of ksh 93; with\nthe option unset the behaviour is that of ksh 88."),
("ERR_EXIT", "If a command has a non-zero exit status, execute the `ZERR`\ntrap, if set, and exit.\n\nThe option is ignored when executing the commands following `while`,\n`until`, `if`, or `elif`, a pipeline beginning with `!`, or\nany command other than the last in command list containing `&&` or\n`||`. Hence neither \"if foo; then true; fi\", nor ``foo &&\ntrue`' trigger exit when `foo` returns with a non-zero exit status.\nNote that if `foo` is a function, the option is also ignored during\nits whole execution.\n\nThe option is also ignored when executing a complex command (`if`,\n`for`, `while`, `until`, `repeat`, `case`, `select`,\n`always`, or a list in braces) if its exit status comes from a\ncommand executed while the option is ignored. Hence, the `if`\ncommand in \"if true; then false && true; fi\" does not trigger\nexit.\n\nFinally, the option is also ignored while running initialization\nscripts and inside `DEBUG` traps. In the latter case, the option is\nhandled specially: it is unset on entry to the trap. If the option\n`DEBUG_BEFORE_CMD` is set, as it is by default, and the option\n`ERR_EXIT` is found to have been set on exit, then the command for\nwhich the `DEBUG` trap is being executed is skipped. The option is\nrestored after the trap exits.\n\nExiting due to `ERR_EXIT` has certain interactions with asynchronous\njobs noted in _Signals_ (zshmisc).\n\nNote this behaviour is not disabled in interactive shells ---\na non-zero status on the command line causes the shell to exit."),
("ERR_RETURN", "If a command has a non-zero exit status, return immediately from the\nenclosing function. Except as explained below, an implicit `return`\nstatement is executed following the same logic described for\n`ERR_EXIT`. This will trigger an exit at the outermost level of a\nnon-interactive script. At the top level of an interactive shell, it\nwill trigger a return to the command prompt; in other words, the\nsequence of commands typed by the user may be thought of as a function\nfor this purpose.\n\nUnlike for `ERR_EXIT`, when a function is called while the option is\nbeing ignored, the option is NOT ignored during the execution of the\nfunction. Hence, if `foo` in \"foo && true\" is a function, code\ninside it is considered separately: it may force a return from `foo`\n(assuming the option remains set within `foo`).\n\nLike for `ERR_EXIT`, the option is ignored inside `DEBUG` traps\nbut it's not unset on entry to the trap and setting or unsetting it\ninside the trap has no special effect.\n\nIf `ERR_RETURN` and `ERR_EXIT` are both set, it may happen that\nboth exit and return should be triggered. In that case only exit is\ntriggered."),
("EVAL_LINENO", "If set, line numbers of expressions evaluated using the builtin `eval`\nare tracked separately of the enclosing environment. This applies both\nto the parameter `LINENO` and the line number output by the prompt\nescape `%i`. If the option is set, the prompt escape `%N` will output\nthe string \"tt((eval))\" instead of the script or function name as an\nindication. (The two prompt escapes are typically used in the parameter\n`PS4` to be output when the option `XTRACE` is set.) If\n`EVAL_LINENO` is unset, the line number of the surrounding script or\nfunction is retained during the evaluation."),
("EXEC", "Do execute commands. Without this option, commands are\nread and checked for syntax errors, but not executed.\nThis option cannot be turned off in an interactive shell,\nexcept when \"-n\" is supplied to the shell at startup."),
("FUNCTION_ARGZERO", "When executing a shell function or sourcing a script, set `$0`\ntemporarily to the name of the function/script. Note that toggling\n`FUNCTION_ARGZERO` from on to off (or off to on) does not change the\ncurrent value of `$0`. Only the state upon entry to the function or\nscript has an effect. Compare `POSIX_ARGZERO`."),
("LOCAL_LOOPS", "When this option is not set, the effect of `break` and `continue`\ncommands may propagate outside function scope, affecting loops in\ncalling functions. When the option is set in a calling function, a\n`break` or a `continue` that is not caught within a called function\n(regardless of the setting of the option within that function)\nproduces a warning and the effect is cancelled."),
("LOCAL_OPTIONS", "If this option is set at the point of return from a shell function,\nmost options (including this one) which were in force upon entry to\nthe function are restored; the `PRIVILEGED` option is not restored.\nOtherwise, only this option,\nand the `LOCAL_LOOPS`, `XTRACE` and `PRINT_EXIT_VALUE` options are\nrestored. Hence if this is explicitly unset by a shell function the\nother options in force at the point of return will remain so.\nA shell function can also guarantee itself a known shell configuration\nwith a formulation like \"emulate -L zsh\"; the `-L` activates\n`LOCAL_OPTIONS`."),
("LOCAL_PATTERNS", "If this option is set at the point of return from a shell function,\nthe state of pattern disables, as set with the builtin command\n\"disable -p\", is restored to what it was when the function was\nentered. The behaviour of this option is similar to the effect\nof `LOCAL_OPTIONS` on options; hence \"emulate -L sh\" (or\nindeed any other emulation with the `-L` option) activates\n`LOCAL_PATTERNS`."),
("LOCAL_TRAPS", "If this option is set when a signal trap is set inside a function, then the\nprevious status of the trap for that signal will be restored when the\nfunction exits. Note that this option must be set _prior_ to altering the\ntrap behaviour in a function; unlike `LOCAL_OPTIONS`, the value on exit\nfrom the function is irrelevant. However, it does not need to be set\nbefore any global trap for that to be correctly restored by a function.\nFor example,\n\nexample(unsetopt localtraps\ntrap - INT\nfn+() { setopt localtraps; trap '' INT; sleep 3; })\n\nwill restore normal handling of `SIGINT` after the function exits."),
("MULTI_FUNC_DEF", "Allow definitions of multiple functions at once in the form ``fn1\nfn2\"_..._tt(())\"; if the option is not set, this causes\na parse error. Definition of multiple functions with the `function`\nkeyword is always allowed. Multiple function definitions are not often\nused and can cause obscure errors.\n\nNote that no error is raised if multiple functions are defined as a\nresult of a set of names that were originally read as a single word on\nthe command line, for example \"TRAP{INT,QUIT}\". Although there are\nno plans to change this behaviour at present, it is not guaranteed."),
("MULTIOS", "Perform implicit **tee**s or **cat**s when multiple\nredirections are attempted (see _Redirection_ (zshmisc))."),
("OCTAL_ZEROES", "Interpret any integer constant beginning with a 0 as octal, per IEEE Std\n1003.2-1992 (ISO 9945-2:1993). This is not enabled by default as it\ncauses problems with parsing of, for example, date and time strings with\nleading zeroes.\n\nSequences of digits indicating a numeric base such as the \"08\"\ncomponent in \"08#77\" are always interpreted as decimal, regardless\nof leading zeroes."),
("PIPE_FAIL", "By default, when a pipeline exits the exit status recorded by the shell\nand returned by the shell variable `$?` reflects that of the\nrightmost element of a pipeline. If this option is set, the exit status\ninstead reflects the status of the rightmost element of the pipeline\nthat was non-zero, or zero if all elements exited with zero status."),
("SOURCE_TRACE", "If set, zsh will print an informational message announcing the name of\neach file it loads. The format of the output is similar to that\nfor the `XTRACE` option, with the message `<sourcetrace>`.\nA file may be loaded by the shell itself when it\nstarts up and shuts down (`Startup/Shutdown Files`) or by the use of\nthe \"source\" and \"dot\" builtin commands."),
("TYPESET_SILENT", "If this is unset, executing any of the \"typeset\" family of\ncommands with no options and a list of parameters that have no values\nto be assigned but already exist will display the value of the parameter.\nIf the option is set, they will only be shown when parameters are selected\nwith the \"-m\" option. The option \"-p\" is available whether or not\nthe option is set."),
("TYPESET_TO_UNSET", "When declaring a new parameter with any of the \"typeset\" family of\nrelated commands, the parameter remains unset unless and until a\nvalue is explicitly assigned to it, either in the \"typeset\" command\nitself or as a later assignment statement."),
("VERBOSE", "Print shell input lines as they are read."),
("XTRACE", "Print commands and their arguments as they are executed. The\noutput is preceded by the value of `$PS4`, formatted as described\nin _Expansion of Prompt Sequences_ (zshmisc)."),
("APPEND_CREATE", "This option only applies when `NO_CLOBBER` (-`C`) is in effect.\n\nIf this option is not set, the shell will report an error when a\nappend redirection (`>>`) is used on a file that does not already\nexists (the traditional zsh behaviour of `NO_CLOBBER`). If the option\nis set, no error is reported (POSIX behaviour)."),
("BASH_REMATCH", "When set, matches performed with the `=~` operator will set the\n`BASH_REMATCH` array variable, instead of the default `MATCH` and\n`match` variables. The first element of the `BASH_REMATCH` array\nwill contain the entire matched text and subsequent elements will contain\nextracted substrings. This option makes more sense when `KSH_ARRAYS` is\nalso set, so that the entire matched portion is stored at index 0 and the\nfirst substring is at index 1. Without this option, the `MATCH` variable\ncontains the entire matched text and the `match` array variable contains\nsubstrings."),
("BSD_ECHO", "Make the `echo` builtin compatible with the BSD manref(echo)(1) command.\nThis disables backslashed escape sequences in echo strings unless the\n`-e` option is specified."),
("CONTINUE_ON_ERROR", "If a fatal error is encountered (see _Errors_ (zshmisc)),\nand the code is running\nin a script, the shell will resume execution at the next statement\nin the script at the top level, in other words outside all functions\nor shell constructs such as loops and conditions. This mimics the\nbehaviour of interactive shells, where the shell returns to the\nline editor to read a new command; it was the normal behaviour in versions\nof zsh before 5.0.1."),
("CSH_JUNKIE_HISTORY", "A history reference without an event specifier will always refer to the\nprevious command. Without this option, such a history reference refers\nto the same event as the previous history reference on the current\ncommand line, defaulting to the previous command."),
("CSH_JUNKIE_LOOPS", "Allow loop bodies to take the form `_list_`; end`' instead of\n``do `_list_`; done`'."),
("CSH_JUNKIE_QUOTES", "Changes the rules for single- and double-quoted text to match that of\n**csh**. These require that embedded newlines be preceded by a backslash;\nunescaped newlines will cause an error message.\nIn double-quoted strings, it is made impossible to escape \"$\", ````'\nor \"\"\" (and \"\\\" itself no longer needs escaping).\nCommand substitutions are only expanded once, and cannot be nested."),
("CSH_NULLCMD", "Do not use the values of `NULLCMD` and `READNULLCMD`\nwhen running redirections with no command. This make\nsuch redirections fail (see _Redirection_ (zshmisc))."),
("KSH_ARRAYS", "Emulate **ksh** array handling as closely as possible. If this option\nis set, array elements are numbered from zero, an array parameter\nwithout subscript refers to the first element instead of the whole array,\nand braces are required to delimit a subscript (\"${path[2]}\" rather\nthan just \"$path[2]\") or to apply modifiers to any parameter\n(\"${PWD:h}\" rather than \"$PWD:h\")."),
("KSH_AUTOLOAD", "Emulate **ksh** function autoloading. This means that when a function is\nautoloaded, the corresponding file is merely executed, and must define\nthe function itself. (By default, the function is defined to the contents\nof the file. However, the most common **ksh**-style case - of the file\ncontaining only a simple definition of the function - is always handled\nin the **ksh**-compatible manner.)"),
("KSH_OPTION_PRINT", "Alters the way options settings are printed: instead of separate lists of\nset and unset options, all options are shown, marked \"on\" if\nthey are in the non-default state, \"off\" otherwise."),
("KSH_TYPESET", "This option is now obsolete: a better approximation to the behaviour of\nother shells is obtained with the reserved word interface to\n`declare`, `export`, `float`, `integer`, `local`, `readonly`\nand `typeset`. Note that the option is only applied when the reserved\nword interface is _not_ in use.\n\nAlters the way arguments to the `typeset` family of commands, including\n`declare`, `export`, `float`, `integer`, `local` and\n`readonly`, are processed. Without this option, zsh will perform normal\nword splitting after command and parameter expansion in arguments of an\nassignment; with it, word splitting does not take place in those cases."),
("KSH_ZERO_SUBSCRIPT", "Treat use of a subscript of value zero in array or string expressions as a\nreference to the first element, i.e. the element that usually has the\nsubscript 1. Ignored if `KSH_ARRAYS` is also set.\n\nIf neither this option nor `KSH_ARRAYS` is set, accesses to an element of\nan array or string with subscript zero return an empty element or string,\nwhile attempts to set element zero of an array or string are treated as an\nerror. However, attempts to set an otherwise valid subscript range that\nincludes zero will succeed. For example, if `KSH_ZERO_SUBSCRIPT` is not\nset,\n\nexample(array[0]=(element))\n\nis an error, while\n\nexample(array[0,1]=(element))\n\nis not and will replace the first element of the array.\n\nThis option is for compatibility with older versions of the shell and\nis not recommended in new code."),
("POSIX_ALIASES", "When this option is set, reserved words are not candidates for\nalias expansion: it is still possible to declare any of them as an alias,\nbut the alias will never be expanded. Reserved words are described in\n_Reserved Words_ (zshmisc).\n\nAlias expansion takes place while text is being read; hence when this\noption is set it does not take effect until the end of any function or\nother piece of shell code parsed as one unit. Note this may\ncause differences from other shells even when the option is in\neffect. For example, when running a command with \"zsh -c\",\nor even \"zsh -o posixaliases -c\", the entire command argument is parsed\nas one unit, so aliases defined within the argument are not available even\nin later lines. If in doubt, avoid use of aliases in non-interactive\ncode."),
("POSIX_ARGZERO", "This option may be used to temporarily disable `FUNCTION_ARGZERO` and\nthereby restore the value of `$0` to the name used to invoke the shell\n(or as set by the `-c` command line option). For compatibility with\nprevious versions of the shell, emulations use `NO_FUNCTION_ARGZERO`\ninstead of `POSIX_ARGZERO`, which may result in unexpected scoping of\n`$0` if the emulation mode is changed inside a function or script.\nTo avoid this, explicitly enable `POSIX_ARGZERO` in the `emulate`\ncommand:\n\n emulate sh -o POSIX_ARGZERO\n\nNote that `NO_POSIX_ARGZERO` has no effect unless `FUNCTION_ARGZERO`\nwas already enabled upon entry to the function or script."),
("POSIX_BUILTINS", "When this option is set the `command` builtin can be used to execute\nshell builtin commands. Parameter assignments specified before shell\nfunctions and special builtins are kept after the command completes unless\nthe special builtin is prefixed with the `command` builtin. Special\nbuiltins are\n`.`,\n`:`,\n`break`,\n`continue`,\n`declare`,\n`eval`,\n`exit`,\n`export`,\n`integer`,\n`local`,\n`readonly`,\n`return`,\n`set`,\n`shift`,\n`source`,\n`times`,\n`trap` and\n`unset`.\n\nIn addition, various error conditions associated with the above builtins\nor `exec` cause a non-interactive shell to exit and an interactive\nshell to return to its top-level processing.\n\nFurthermore, functions and shell builtins are not executed after\nan `exec` prefix; the command to be executed must be an external\ncommand found in the path.\n\nFurthermore, the `getopts` builtin behaves in a POSIX-compatible\nfashion in that the associated variable `OPTIND` is not made\nlocal to functions, and its value is calculated differently to match\nother shells.\n\nMoreover, the warning and special exit code from\n`[[ -o `_non_existent_option_` ]]` are suppressed."),
("POSIX_IDENTIFIERS", "When this option is set, only the ASCII characters `a` to `z`, `A` to\n`Z`, `0` to `9` and `_` may be used in identifiers (names\nof shell parameters and modules).\n\nIn addition, setting this option limits the effect of parameter\nsubstitution with no braces, so that the expression `$#` is treated as\nthe parameter `$#` even if followed by a valid parameter name.\nWhen it is unset, zsh allows expressions of the form `$#`_name_\nto refer to the length of `$`_name_, even for special variables,\nfor example in expressions such as `$#-` and `$#*`.\n\nAnother difference is that with the option set assignment to an\nunset variable in arithmetic context causes the variable to be created\nas a scalar rather than a numeric type. So after `tt(unset t; (( t = 3\n)))', without `POSIX_IDENTIFIERS` set `t` has integer type, while with\nit set it has scalar type.\n\nWhen the option is unset and multibyte character support is enabled (i.e. it\nis compiled in and the option `MULTIBYTE` is set), then additionally any\nalphanumeric characters in the local character set may be used in\nidentifiers. Note that scripts and functions written with this feature are\nnot portable, and also that both options must be set before the script\nor function is parsed; setting them during execution is not sufficient\nas the syntax _variable_`=`_value_ has already been parsed as\na command rather than an assignment.\n\nIf multibyte character support is not compiled into the shell this option is\nignored; all octets with the top bit set may be used in identifiers.\nThis is non-standard but is the traditional zsh behaviour."),
("POSIX_STRINGS", "This option affects processing of quoted strings. Currently it only\naffects the behaviour of null characters, i.e. character 0 in the\nportable character set corresponding to US ASCII.\n\nWhen this option is not set, null characters embedded within strings\nof the form \"$\"`_..._`'` are treated as ordinary characters. The\nentire string is maintained within the shell and output to files where\nnecessary, although owing to restrictions of the library interface\nthe string is truncated at the null character in file names, environment\nvariables, or in arguments to external programs.\n\nWhen this option is set, the \"$\"`_..._`'` expression is truncated at\nthe null character. Note that remaining parts of the same string\nbeyond the termination of the quotes are not truncated.\n\nFor example, the command line argument \"a$\"b\\0c'd` is treated with\nthe option off as the characters `a`, `b`, null, `c`, `d`,\nand with the option on as the characters `a`, `b`, `d`."),
("POSIX_TRAPS", "When this option is set, the usual zsh behaviour of executing\ntraps for `EXIT` on exit from shell functions is suppressed.\nIn that case, manipulating `EXIT` traps always alters the global\ntrap for exiting the shell; the `LOCAL_TRAPS` option is\nignored for the `EXIT` trap.\n\nAlso, a `return` statement executed in a trap with no argument passes\nback from the function the value from the surrounding context, not from\ncode executed within the trap.\n\nFurthermore, if a trap is set to be ignored, this state persists when\na subshell is entered. Without the option, the trap would be reset to\nits default state at this point."),
("SH_FILE_EXPANSION", "Perform filename expansion (e.g., `~` expansion) _before_\nparameter expansion, command substitution, arithmetic expansion\nand brace expansion.\nIf this option is unset, it is performed _after_\nbrace expansion, so things like \"~$USERNAME\" and\n\"~{pfalstad,rc}\" will work."),
("SH_NULLCMD", "Do not use the values of `NULLCMD` and `READNULLCMD`\nwhen doing redirections, use \":\" instead (see _Redirection_ (zshmisc))."),
("SH_OPTION_LETTERS", "If this option is set the shell tries to interpret single letter options\n(which are used with `set` and `setopt`) like **ksh** does.\nThis also affects the value of the `-` special parameter."),
("SH_WORD_SPLIT", "Causes field splitting to be performed on unquoted parameter expansions.\nNote that this option has nothing to do with word splitting.\n(See _Parameter Expansion_ (zshexpn).)"),
("TRAPS_ASYNC", "While waiting for a program to exit, handle signals and run traps\nimmediately. Otherwise the trap is run after a child process has exited.\nNote this does not affect the point at which traps are run for any case\nother than when the shell is waiting for a child process."),
("INTERACTIVE", "This is an interactive shell. This option is set upon initialisation if\nthe standard input is a tty and commands are being read from standard input.\n(See the discussion of `SHIN_STDIN`.)\nThis heuristic may be overridden by specifying a state for this option\non the command line.\nThe value of this option can only be changed via flags supplied at\ninvocation of the shell.\nIt cannot be changed once zsh is running."),
("LOGIN", "This is a login shell.\nIf this option is not explicitly set, the shell becomes a login shell if\nthe first character of the `argv[0]` passed to the shell is a \"-\"."),
("PRIVILEGED", "Turn on privileged mode. Typically this is used when script is to be run\nwith elevated privileges. This should be done as follows directly with\nthe `-p` option to zsh so that it takes effect during startup.\n\n #!/bin/zsh -p\n\nThe option is enabled automatically on startup if the effective user\n(group) ID is not equal to the real user (group) ID. In this case,\nturning the option off causes the effective user and group IDs to be set\nto the real user and group IDs. Be aware that if that fails the shell may\nbe running with different IDs than was intended so a script should check\nfor failure and act accordingly, for example:\n\n unsetopt privileged || exit\n\nThe `PRIVILEGED` option disables sourcing user startup files.\nIf zsh is invoked as \"sh\" or \"ksh\" with this option set,\n`/etc/suid_profile` is sourced (after `/etc/profile` on interactive\nshells). Sourcing `~/.profile` is disabled and the contents of the\n`ENV` variable is ignored. This option cannot be changed using the\n`-m` option of `setopt` and `unsetopt`, and changing it inside a\nfunction always changes it globally regardless of the `LOCAL_OPTIONS`\noption."),
("SHIN_STDIN", "Commands are being read from the standard input.\nCommands are read from standard input if no command is specified with\n`-c` and no file of commands is specified. If `SHIN_STDIN`\nis set explicitly on the command line,\nany argument that would otherwise have been\ntaken as a file to run will instead be treated as a normal positional\nparameter.\nNote that setting or unsetting this option on the command line does not\nnecessarily affect the state the option will have while the shell is\nrunning - that is purely an indicator of whether or not commands are\n_actually_ being read from standard input.\nThe value of this option can only be changed via flags supplied at\ninvocation of the shell.\nIt cannot be changed once zsh is running."),
("SINGLE_COMMAND", "If the shell is reading from standard input, it exits after a single command\nhas been executed. This also makes the shell non-interactive, unless the\n`INTERACTIVE` option is explicitly set on the command line.\nThe value of this option can only be changed via flags supplied at\ninvocation of the shell.\nIt cannot be changed once zsh is running."),
("BEEP", "Beep on error in ZLE."),
("COMBINING_CHARS", "Assume that the terminal displays combining characters correctly.\nSpecifically, if a base alphanumeric character is followed by one or more\nzero-width punctuation characters, assume that the zero-width characters\nwill be displayed as modifications to the base character within the\nsame width. Not all terminals handle this. If this option is not\nset, zero-width characters are displayed separately with special\nmark-up.\n\nIf this option is set, the pattern test `[[:WORD:]]` matches a\nzero-width punctuation character on the assumption that it will be\nused as part of a word in combination with a word character.\nOtherwise the base shell does not handle combining characters specially."),
("EMACS", "If ZLE is loaded, turning on this option has the equivalent effect\nof \"bindkey -e\". In addition, the `VI` option is unset.\nTurning it off has no effect. The option setting is\nnot guaranteed to reflect the current keymap, and the `LOCALOPTIONS`\noption does not work correctly. This option is provided only for\ncompatibility, and its use is highly discouraged. `bindkey` is the\nrecommended interface."),
("OVERSTRIKE", "Start up the line editor in overstrike mode."),
("SINGLE_LINE_ZLE", "Use single-line command line editing instead of multi-line.\n\nNote that although this is on by default in ksh emulation it only\nprovides superficial compatibility with the ksh line editor and\nreduces the effectiveness of the zsh line editor. As it has no\neffect on shell syntax, many users may wish to disable this option\nwhen using ksh emulation interactively."),
("VI", "If ZLE is loaded, turning on this option has the equivalent effect\nof \"bindkey -v\". In addition, the `EMACS` option is unset.\nTurning it off has no effect. The option setting is\nnot guaranteed to reflect the current keymap, and the `LOCALOPTIONS`\noption does not work correctly. This option is provided only for\ncompatibility, and its use is highly discouraged. `bindkey` is the\nrecommended interface."),
("ZLE", "Use the zsh line editor. Set by default in interactive shells connected to\na terminal."),
("BRACE_EXPAND", "_NO__`IGNORE_BRACES`\n(ksh and bash compatibility)"),
("DOT_GLOB", "`GLOB_DOTS`\n(bash compatibility)"),
("HASH_ALL", "`HASH_CMDS`\n(bash compatibility)"),
("HIST_APPEND", "`APPEND_HISTORY`\n(bash compatibility)"),
("HIST_EXPAND", "`BANG_HIST`\n(bash compatibility)"),
("LOG", "_NO__`HIST_NO_FUNCTIONS`\n(ksh compatibility)"),
("MAIL_WARN", "`MAIL_WARNING`\n(bash compatibility)"),
("ONE_CMD", "`SINGLE_COMMAND`\n(bash compatibility)"),
("PHYSICAL", "`CHASE_LINKS`\n(ksh and bash compatibility)"),
("PROMPT_VARS", "`PROMPT_SUBST`\n(bash compatibility)"),
("STDIN", "`SHIN_STDIN`\n(ksh compatibility)"),
("TRACK_ALL", "`HASH_CMDS`\n(ksh compatibility)"),
];
/// Alias → canonical mapping. One entry per surface name
/// that should resolve to the same documentation body.
pub const OPTION_ALIASES: &[(&str, &str)] = &[
("AUTO_CD", "AUTO_CD"),
("NO_AUTO_CD", "AUTO_CD"),
("AUTOCD", "AUTO_CD"),
("NOAUTOCD", "AUTO_CD"),
("AUTO_PUSHD", "AUTO_PUSHD"),
("NO_AUTO_PUSHD", "AUTO_PUSHD"),
("AUTOPUSHD", "AUTO_PUSHD"),
("NOAUTOPUSHD", "AUTO_PUSHD"),
("CDABLE_VARS", "CDABLE_VARS"),
("NO_CDABLE_VARS", "CDABLE_VARS"),
("CDABLEVARS", "CDABLE_VARS"),
("NOCDABLEVARS", "CDABLE_VARS"),
("CD_SILENT", "CD_SILENT"),
("NO_CD_SILENT", "CD_SILENT"),
("CDSILENT", "CD_SILENT"),
("NOCDSILENT", "CD_SILENT"),
("CHASE_DOTS", "CHASE_DOTS"),
("NO_CHASE_DOTS", "CHASE_DOTS"),
("CHASEDOTS", "CHASE_DOTS"),
("NOCHASEDOTS", "CHASE_DOTS"),
("CHASE_LINKS", "CHASE_LINKS"),
("NO_CHASE_LINKS", "CHASE_LINKS"),
("CHASELINKS", "CHASE_LINKS"),
("NOCHASELINKS", "CHASE_LINKS"),
("POSIX_CD", "POSIX_CD"),
("POSIXCD", "POSIX_CD"),
("NO_POSIX_CD", "POSIX_CD"),
("NOPOSIXCD", "POSIX_CD"),
("PUSHD_IGNORE_DUPS", "PUSHD_IGNORE_DUPS"),
("NO_PUSHD_IGNORE_DUPS", "PUSHD_IGNORE_DUPS"),
("PUSHDIGNOREDUPS", "PUSHD_IGNORE_DUPS"),
("NOPUSHDIGNOREDUPS", "PUSHD_IGNORE_DUPS"),
("PUSHD_MINUS", "PUSHD_MINUS"),
("NO_PUSHD_MINUS", "PUSHD_MINUS"),
("PUSHDMINUS", "PUSHD_MINUS"),
("NOPUSHDMINUS", "PUSHD_MINUS"),
("PUSHD_SILENT", "PUSHD_SILENT"),
("NO_PUSHD_SILENT", "PUSHD_SILENT"),
("PUSHDSILENT", "PUSHD_SILENT"),
("NOPUSHDSILENT", "PUSHD_SILENT"),
("PUSHD_TO_HOME", "PUSHD_TO_HOME"),
("NO_PUSHD_TO_HOME", "PUSHD_TO_HOME"),
("PUSHDTOHOME", "PUSHD_TO_HOME"),
("NOPUSHDTOHOME", "PUSHD_TO_HOME"),
("ALWAYS_LAST_PROMPT", "ALWAYS_LAST_PROMPT"),
("NO_ALWAYS_LAST_PROMPT", "ALWAYS_LAST_PROMPT"),
("ALWAYSLASTPROMPT", "ALWAYS_LAST_PROMPT"),
("NOALWAYSLASTPROMPT", "ALWAYS_LAST_PROMPT"),
("ALWAYS_TO_END", "ALWAYS_TO_END"),
("NO_ALWAYS_TO_END", "ALWAYS_TO_END"),
("ALWAYSTOEND", "ALWAYS_TO_END"),
("NOALWAYSTOEND", "ALWAYS_TO_END"),
("AUTO_LIST", "AUTO_LIST"),
("NO_AUTO_LIST", "AUTO_LIST"),
("AUTOLIST", "AUTO_LIST"),
("NOAUTOLIST", "AUTO_LIST"),
("AUTO_MENU", "AUTO_MENU"),
("NO_AUTO_MENU", "AUTO_MENU"),
("AUTOMENU", "AUTO_MENU"),
("NOAUTOMENU", "AUTO_MENU"),
("AUTO_NAME_DIRS", "AUTO_NAME_DIRS"),
("NO_AUTO_NAME_DIRS", "AUTO_NAME_DIRS"),
("AUTONAMEDIRS", "AUTO_NAME_DIRS"),
("NOAUTONAMEDIRS", "AUTO_NAME_DIRS"),
("AUTO_PARAM_KEYS", "AUTO_PARAM_KEYS"),
("NO_AUTO_PARAM_KEYS", "AUTO_PARAM_KEYS"),
("AUTOPARAMKEYS", "AUTO_PARAM_KEYS"),
("NOAUTOPARAMKEYS", "AUTO_PARAM_KEYS"),
("AUTO_PARAM_SLASH", "AUTO_PARAM_SLASH"),
("NO_AUTO_PARAM_SLASH", "AUTO_PARAM_SLASH"),
("AUTOPARAMSLASH", "AUTO_PARAM_SLASH"),
("NOAUTOPARAMSLASH", "AUTO_PARAM_SLASH"),
("AUTO_REMOVE_SLASH", "AUTO_REMOVE_SLASH"),
("NO_AUTO_REMOVE_SLASH", "AUTO_REMOVE_SLASH"),
("AUTOREMOVESLASH", "AUTO_REMOVE_SLASH"),
("NOAUTOREMOVESLASH", "AUTO_REMOVE_SLASH"),
("BASH_AUTO_LIST", "BASH_AUTO_LIST"),
("NO_BASH_AUTO_LIST", "BASH_AUTO_LIST"),
("BASHAUTOLIST", "BASH_AUTO_LIST"),
("NOBASHAUTOLIST", "BASH_AUTO_LIST"),
("COMPLETE_ALIASES", "COMPLETE_ALIASES"),
("NO_COMPLETE_ALIASES", "COMPLETE_ALIASES"),
("COMPLETEALIASES", "COMPLETE_ALIASES"),
("NOCOMPLETEALIASES", "COMPLETE_ALIASES"),
("COMPLETE_IN_WORD", "COMPLETE_IN_WORD"),
("NO_COMPLETE_IN_WORD", "COMPLETE_IN_WORD"),
("COMPLETEINWORD", "COMPLETE_IN_WORD"),
("NOCOMPLETEINWORD", "COMPLETE_IN_WORD"),
("GLOB_COMPLETE", "GLOB_COMPLETE"),
("NO_GLOB_COMPLETE", "GLOB_COMPLETE"),
("GLOBCOMPLETE", "GLOB_COMPLETE"),
("NOGLOBCOMPLETE", "GLOB_COMPLETE"),
("HASH_LIST_ALL", "HASH_LIST_ALL"),
("NO_HASH_LIST_ALL", "HASH_LIST_ALL"),
("HASHLISTALL", "HASH_LIST_ALL"),
("NOHASHLISTALL", "HASH_LIST_ALL"),
("LIST_AMBIGUOUS", "LIST_AMBIGUOUS"),
("NO_LIST_AMBIGUOUS", "LIST_AMBIGUOUS"),
("LISTAMBIGUOUS", "LIST_AMBIGUOUS"),
("NOLISTAMBIGUOUS", "LIST_AMBIGUOUS"),
("LIST_BEEP", "LIST_BEEP"),
("NO_LIST_BEEP", "LIST_BEEP"),
("LISTBEEP", "LIST_BEEP"),
("NOLISTBEEP", "LIST_BEEP"),
("LIST_PACKED", "LIST_PACKED"),
("NO_LIST_PACKED", "LIST_PACKED"),
("LISTPACKED", "LIST_PACKED"),
("NOLISTPACKED", "LIST_PACKED"),
("LIST_ROWS_FIRST", "LIST_ROWS_FIRST"),
("NO_LIST_ROWS_FIRST", "LIST_ROWS_FIRST"),
("LISTROWSFIRST", "LIST_ROWS_FIRST"),
("NOLISTROWSFIRST", "LIST_ROWS_FIRST"),
("LIST_TYPES", "LIST_TYPES"),
("NO_LIST_TYPES", "LIST_TYPES"),
("LISTTYPES", "LIST_TYPES"),
("NOLISTTYPES", "LIST_TYPES"),
("MENU_COMPLETE", "MENU_COMPLETE"),
("NO_MENU_COMPLETE", "MENU_COMPLETE"),
("MENUCOMPLETE", "MENU_COMPLETE"),
("NOMENUCOMPLETE", "MENU_COMPLETE"),
("REC_EXACT", "REC_EXACT"),
("NO_REC_EXACT", "REC_EXACT"),
("RECEXACT", "REC_EXACT"),
("NORECEXACT", "REC_EXACT"),
("BAD_PATTERN", "BAD_PATTERN"),
("NO_BAD_PATTERN", "BAD_PATTERN"),
("BADPATTERN", "BAD_PATTERN"),
("NOBADPATTERN", "BAD_PATTERN"),
("BARE_GLOB_QUAL", "BARE_GLOB_QUAL"),
("NO_BARE_GLOB_QUAL", "BARE_GLOB_QUAL"),
("BAREGLOBQUAL", "BARE_GLOB_QUAL"),
("NOBAREGLOBQUAL", "BARE_GLOB_QUAL"),
("BRACE_CCL", "BRACE_CCL"),
("NO_BRACE_CCL", "BRACE_CCL"),
("BRACECCL", "BRACE_CCL"),
("NOBRACECCL", "BRACE_CCL"),
("CASE_GLOB", "CASE_GLOB"),
("NO_CASE_GLOB", "CASE_GLOB"),
("CASEGLOB", "CASE_GLOB"),
("NOCASEGLOB", "CASE_GLOB"),
("CASE_MATCH", "CASE_MATCH"),
("NO_CASE_MATCH", "CASE_MATCH"),
("CASEMATCH", "CASE_MATCH"),
("NOCASEMATCH", "CASE_MATCH"),
("CASE_PATHS", "CASE_PATHS"),
("NO_CASE_PATHS", "CASE_PATHS"),
("CASEPATHS", "CASE_PATHS"),
("NOCASEPATHS", "CASE_PATHS"),
("CSH_NULL_GLOB", "CSH_NULL_GLOB"),
("NO_CSH_NULL_GLOB", "CSH_NULL_GLOB"),
("CSHNULLGLOB", "CSH_NULL_GLOB"),
("NOCSHNULLGLOB", "CSH_NULL_GLOB"),
("EQUALS", "EQUALS"),
("NO_EQUALS", "EQUALS"),
("NOEQUALS", "EQUALS"),
("EXTENDED_GLOB", "EXTENDED_GLOB"),
("NO_EXTENDED_GLOB", "EXTENDED_GLOB"),
("EXTENDEDGLOB", "EXTENDED_GLOB"),
("NOEXTENDEDGLOB", "EXTENDED_GLOB"),
("FORCE_FLOAT", "FORCE_FLOAT"),
("NO_FORCE_FLOAT", "FORCE_FLOAT"),
("FORCEFLOAT", "FORCE_FLOAT"),
("NOFORCEFLOAT", "FORCE_FLOAT"),
("GLOB", "GLOB"),
("NO_GLOB", "GLOB"),
("NOGLOB", "GLOB"),
("GLOB_ASSIGN", "GLOB_ASSIGN"),
("NO_GLOB_ASSIGN", "GLOB_ASSIGN"),
("GLOBASSIGN", "GLOB_ASSIGN"),
("NOGLOBASSIGN", "GLOB_ASSIGN"),
("GLOB_DOTS", "GLOB_DOTS"),
("NO_GLOB_DOTS", "GLOB_DOTS"),
("GLOBDOTS", "GLOB_DOTS"),
("NOGLOBDOTS", "GLOB_DOTS"),
("GLOB_STAR_SHORT", "GLOB_STAR_SHORT"),
("NO_GLOB_STAR_SHORT", "GLOB_STAR_SHORT"),
("GLOBSTARSHORT", "GLOB_STAR_SHORT"),
("NOGLOBSTARSHORT", "GLOB_STAR_SHORT"),
("GLOB_SUBST", "GLOB_SUBST"),
("NO_GLOB_SUBST", "GLOB_SUBST"),
("GLOBSUBST", "GLOB_SUBST"),
("NOGLOBSUBST", "GLOB_SUBST"),
("HIST_SUBST_PATTERN", "HIST_SUBST_PATTERN"),
("NO_HIST_SUBST_PATTERN", "HIST_SUBST_PATTERN"),
("HISTSUBSTPATTERN", "HIST_SUBST_PATTERN"),
("NOHISTSUBSTPATTERN", "HIST_SUBST_PATTERN"),
("IGNORE_BRACES", "IGNORE_BRACES"),
("NO_IGNORE_BRACES", "IGNORE_BRACES"),
("IGNOREBRACES", "IGNORE_BRACES"),
("NOIGNOREBRACES", "IGNORE_BRACES"),
("IGNORE_CLOSE_BRACES", "IGNORE_CLOSE_BRACES"),
("NO_IGNORE_CLOSE_BRACES", "IGNORE_CLOSE_BRACES"),
("IGNORECLOSEBRACES", "IGNORE_CLOSE_BRACES"),
("NOIGNORECLOSEBRACES", "IGNORE_CLOSE_BRACES"),
("KSH_GLOB", "KSH_GLOB"),
("NO_KSH_GLOB", "KSH_GLOB"),
("KSHGLOB", "KSH_GLOB"),
("NOKSHGLOB", "KSH_GLOB"),
("MAGIC_EQUAL_SUBST", "MAGIC_EQUAL_SUBST"),
("NO_MAGIC_EQUAL_SUBST", "MAGIC_EQUAL_SUBST"),
("MAGICEQUALSUBST", "MAGIC_EQUAL_SUBST"),
("NOMAGICEQUALSUBST", "MAGIC_EQUAL_SUBST"),
("MARK_DIRS", "MARK_DIRS"),
("NO_MARK_DIRS", "MARK_DIRS"),
("MARKDIRS", "MARK_DIRS"),
("NOMARKDIRS", "MARK_DIRS"),
("MULTIBYTE", "MULTIBYTE"),
("NO_MULTIBYTE", "MULTIBYTE"),
("NOMULTIBYTE", "MULTIBYTE"),
("NOMATCH", "NOMATCH"),
("NO_NOMATCH", "NOMATCH"),
("NONOMATCH", "NOMATCH"),
("NULL_GLOB", "NULL_GLOB"),
("NO_NULL_GLOB", "NULL_GLOB"),
("NULLGLOB", "NULL_GLOB"),
("NONULLGLOB", "NULL_GLOB"),
("NUMERIC_GLOB_SORT", "NUMERIC_GLOB_SORT"),
("NO_NUMERIC_GLOB_SORT", "NUMERIC_GLOB_SORT"),
("NUMERICGLOBSORT", "NUMERIC_GLOB_SORT"),
("NONUMERICGLOBSORT", "NUMERIC_GLOB_SORT"),
("RC_EXPAND_PARAM", "RC_EXPAND_PARAM"),
("NO_RC_EXPAND_PARAM", "RC_EXPAND_PARAM"),
("RCEXPANDPARAM", "RC_EXPAND_PARAM"),
("NORCEXPANDPARAM", "RC_EXPAND_PARAM"),
("REMATCH_PCRE", "REMATCH_PCRE"),
("NO_REMATCH_PCRE", "REMATCH_PCRE"),
("REMATCHPCRE", "REMATCH_PCRE"),
("NOREMATCHPCRE", "REMATCH_PCRE"),
("SH_GLOB", "SH_GLOB"),
("NO_SH_GLOB", "SH_GLOB"),
("SHGLOB", "SH_GLOB"),
("NOSHGLOB", "SH_GLOB"),
("UNSET", "UNSET"),
("NO_UNSET", "UNSET"),
("NOUNSET", "UNSET"),
("WARN_CREATE_GLOBAL", "WARN_CREATE_GLOBAL"),
("NO_WARN_CREATE_GLOBAL", "WARN_CREATE_GLOBAL"),
("WARNCREATEGLOBAL", "WARN_CREATE_GLOBAL"),
("NOWARNCREATEGLOBAL", "WARN_CREATE_GLOBAL"),
("WARN_NESTED_VAR", "WARN_NESTED_VAR"),
("NO_WARN_NESTED_VAR", "WARN_NESTED_VAR"),
("WARNNESTEDVAR", "WARN_NESTED_VAR"),
("NO_WARNNESTEDVAR", "WARN_NESTED_VAR"),
("APPEND_HISTORY", "APPEND_HISTORY"),
("NO_APPEND_HISTORY", "APPEND_HISTORY"),
("APPENDHISTORY", "APPEND_HISTORY"),
("NOAPPENDHISTORY", "APPEND_HISTORY"),
("BANG_HIST", "BANG_HIST"),
("NO_BANG_HIST", "BANG_HIST"),
("BANGHIST", "BANG_HIST"),
("NOBANGHIST", "BANG_HIST"),
("EXTENDED_HISTORY", "EXTENDED_HISTORY"),
("NO_EXTENDED_HISTORY", "EXTENDED_HISTORY"),
("EXTENDEDHISTORY", "EXTENDED_HISTORY"),
("NOEXTENDEDHISTORY", "EXTENDED_HISTORY"),
("HIST_ALLOW_CLOBBER", "HIST_ALLOW_CLOBBER"),
("NO_HIST_ALLOW_CLOBBER", "HIST_ALLOW_CLOBBER"),
("HISTALLOWCLOBBER", "HIST_ALLOW_CLOBBER"),
("NOHISTALLOWCLOBBER", "HIST_ALLOW_CLOBBER"),
("HIST_BEEP", "HIST_BEEP"),
("NO_HIST_BEEP", "HIST_BEEP"),
("HISTBEEP", "HIST_BEEP"),
("NOHISTBEEP", "HIST_BEEP"),
("HIST_EXPIRE_DUPS_FIRST", "HIST_EXPIRE_DUPS_FIRST"),
("NO_HIST_EXPIRE_DUPS_FIRST", "HIST_EXPIRE_DUPS_FIRST"),
("HISTEXPIREDUPSFIRST", "HIST_EXPIRE_DUPS_FIRST"),
("NOHISTEXPIREDUPSFIRST", "HIST_EXPIRE_DUPS_FIRST"),
("HIST_FCNTL_LOCK", "HIST_FCNTL_LOCK"),
("NO_HIST_FCNTL_LOCK", "HIST_FCNTL_LOCK"),
("HISTFCNTLLOCK", "HIST_FCNTL_LOCK"),
("NOHISTFCNTLLOCK", "HIST_FCNTL_LOCK"),
("HIST_FIND_NO_DUPS", "HIST_FIND_NO_DUPS"),
("NO_HIST_FIND_NO_DUPS", "HIST_FIND_NO_DUPS"),
("HISTFINDNODUPS", "HIST_FIND_NO_DUPS"),
("NOHISTFINDNODUPS", "HIST_FIND_NO_DUPS"),
("HIST_IGNORE_ALL_DUPS", "HIST_IGNORE_ALL_DUPS"),
("NO_HIST_IGNORE_ALL_DUPS", "HIST_IGNORE_ALL_DUPS"),
("HISTIGNOREALLDUPS", "HIST_IGNORE_ALL_DUPS"),
("NOHISTIGNOREALLDUPS", "HIST_IGNORE_ALL_DUPS"),
("HIST_IGNORE_DUPS", "HIST_IGNORE_DUPS"),
("NO_HIST_IGNORE_DUPS", "HIST_IGNORE_DUPS"),
("HISTIGNOREDUPS", "HIST_IGNORE_DUPS"),
("NOHISTIGNOREDUPS", "HIST_IGNORE_DUPS"),
("HIST_IGNORE_SPACE", "HIST_IGNORE_SPACE"),
("NO_HIST_IGNORE_SPACE", "HIST_IGNORE_SPACE"),
("HISTIGNORESPACE", "HIST_IGNORE_SPACE"),
("NOHISTIGNORESPACE", "HIST_IGNORE_SPACE"),
("HIST_LEX_WORDS", "HIST_LEX_WORDS"),
("NO_HIST_LEX_WORDS", "HIST_LEX_WORDS"),
("HISTLEXWORDS", "HIST_LEX_WORDS"),
("NOHISTLEXWORDS", "HIST_LEX_WORDS"),
("HIST_NO_FUNCTIONS", "HIST_NO_FUNCTIONS"),
("NO_HIST_NO_FUNCTIONS", "HIST_NO_FUNCTIONS"),
("HISTNOFUNCTIONS", "HIST_NO_FUNCTIONS"),
("NOHISTNOFUNCTIONS", "HIST_NO_FUNCTIONS"),
("HIST_NO_STORE", "HIST_NO_STORE"),
("NO_HIST_NO_STORE", "HIST_NO_STORE"),
("HISTNOSTORE", "HIST_NO_STORE"),
("NOHISTNOSTORE", "HIST_NO_STORE"),
("HIST_REDUCE_BLANKS", "HIST_REDUCE_BLANKS"),
("NO_HIST_REDUCE_BLANKS", "HIST_REDUCE_BLANKS"),
("HISTREDUCEBLANKS", "HIST_REDUCE_BLANKS"),
("NOHISTREDUCEBLANKS", "HIST_REDUCE_BLANKS"),
("HIST_SAVE_BY_COPY", "HIST_SAVE_BY_COPY"),
("NO_HIST_SAVE_BY_COPY", "HIST_SAVE_BY_COPY"),
("HISTSAVEBYCOPY", "HIST_SAVE_BY_COPY"),
("NOHISTSAVEBYCOPY", "HIST_SAVE_BY_COPY"),
("HIST_SAVE_NO_DUPS", "HIST_SAVE_NO_DUPS"),
("NO_HIST_SAVE_NO_DUPS", "HIST_SAVE_NO_DUPS"),
("HISTSAVENODUPS", "HIST_SAVE_NO_DUPS"),
("NOHISTSAVENODUPS", "HIST_SAVE_NO_DUPS"),
("HIST_VERIFY", "HIST_VERIFY"),
("NO_HIST_VERIFY", "HIST_VERIFY"),
("HISTVERIFY", "HIST_VERIFY"),
("NOHISTVERIFY", "HIST_VERIFY"),
("INC_APPEND_HISTORY", "INC_APPEND_HISTORY"),
("NO_INC_APPEND_HISTORY", "INC_APPEND_HISTORY"),
("INCAPPENDHISTORY", "INC_APPEND_HISTORY"),
("NOINCAPPENDHISTORY", "INC_APPEND_HISTORY"),
("INC_APPEND_HISTORY_TIME", "INC_APPEND_HISTORY_TIME"),
("NO_INC_APPEND_HISTORY_TIME", "INC_APPEND_HISTORY_TIME"),
("INCAPPENDHISTORYTIME", "INC_APPEND_HISTORY_TIME"),
("NOINCAPPENDHISTORYTIME", "INC_APPEND_HISTORY_TIME"),
("SHARE_HISTORY", "SHARE_HISTORY"),
("NO_SHARE_HISTORY", "SHARE_HISTORY"),
("SHAREHISTORY", "SHARE_HISTORY"),
("NOSHAREHISTORY", "SHARE_HISTORY"),
("ALL_EXPORT", "ALL_EXPORT"),
("NO_ALL_EXPORT", "ALL_EXPORT"),
("ALLEXPORT", "ALL_EXPORT"),
("NOALLEXPORT", "ALL_EXPORT"),
("GLOBAL_EXPORT", "GLOBAL_EXPORT"),
("NO_GLOBAL_EXPORT", "GLOBAL_EXPORT"),
("GLOBALEXPORT", "GLOBAL_EXPORT"),
("NOGLOBALEXPORT", "GLOBAL_EXPORT"),
("GLOBAL_RCS", "GLOBAL_RCS"),
("NO_GLOBAL_RCS", "GLOBAL_RCS"),
("GLOBALRCS", "GLOBAL_RCS"),
("NOGLOBALRCS", "GLOBAL_RCS"),
("RCS", "RCS"),
("NO_RCS", "RCS"),
("NORCS", "RCS"),
("ALIASES", "ALIASES"),
("NO_ALIASES", "ALIASES"),
("NOALIASES", "ALIASES"),
("CLOBBER", "CLOBBER"),
("NO_CLOBBER", "CLOBBER"),
("NOCLOBBER", "CLOBBER"),
("CLOBBER_EMPTY", "CLOBBER_EMPTY"),
("NO_CLOBBER_EMPTY", "CLOBBER_EMPTY"),
("CLOBBEREMPTY", "CLOBBER_EMPTY"),
("NOCLOBBEREMPTY", "CLOBBER_EMPTY"),
("CORRECT", "CORRECT"),
("NO_CORRECT", "CORRECT"),
("NOCORRECT", "CORRECT"),
("CORRECT_ALL", "CORRECT_ALL"),
("NO_CORRECT_ALL", "CORRECT_ALL"),
("CORRECTALL", "CORRECT_ALL"),
("NOCORRECTALL", "CORRECT_ALL"),
("DVORAK", "DVORAK"),
("NO_DVORAK", "DVORAK"),
("NODVORAK", "DVORAK"),
("FLOW_CONTROL", "FLOW_CONTROL"),
("NO_FLOW_CONTROL", "FLOW_CONTROL"),
("FLOWCONTROL", "FLOW_CONTROL"),
("NOFLOWCONTROL", "FLOW_CONTROL"),
("IGNORE_EOF", "IGNORE_EOF"),
("NO_IGNORE_EOF", "IGNORE_EOF"),
("IGNOREEOF", "IGNORE_EOF"),
("NOIGNOREEOF", "IGNORE_EOF"),
("INTERACTIVE_COMMENTS", "INTERACTIVE_COMMENTS"),
("NO_INTERACTIVE_COMMENTS", "INTERACTIVE_COMMENTS"),
("INTERACTIVECOMMENTS", "INTERACTIVE_COMMENTS"),
("NOINTERACTIVECOMMENTS", "INTERACTIVE_COMMENTS"),
("HASH_CMDS", "HASH_CMDS"),
("NO_HASH_CMDS", "HASH_CMDS"),
("HASHCMDS", "HASH_CMDS"),
("NOHASHCMDS", "HASH_CMDS"),
("HASH_DIRS", "HASH_DIRS"),
("NO_HASH_DIRS", "HASH_DIRS"),
("HASHDIRS", "HASH_DIRS"),
("NOHASHDIRS", "HASH_DIRS"),
("HASH_EXECUTABLES_ONLY", "HASH_EXECUTABLES_ONLY"),
("NO_HASH_EXECUTABLES_ONLY", "HASH_EXECUTABLES_ONLY"),
("HASHEXECUTABLESONLY", "HASH_EXECUTABLES_ONLY"),
("NOHASHEXECUTABLESONLY", "HASH_EXECUTABLES_ONLY"),
("MAIL_WARNING", "MAIL_WARNING"),
("NO_MAIL_WARNING", "MAIL_WARNING"),
("MAILWARNING", "MAIL_WARNING"),
("NOMAILWARNING", "MAIL_WARNING"),
("PATH_DIRS", "PATH_DIRS"),
("NO_PATH_DIRS", "PATH_DIRS"),
("PATHDIRS", "PATH_DIRS"),
("NOPATHDIRS", "PATH_DIRS"),
("PATH_SCRIPT", "PATH_SCRIPT"),
("NO_PATH_SCRIPT", "PATH_SCRIPT"),
("PATHSCRIPT", "PATH_SCRIPT"),
("NOPATHSCRIPT", "PATH_SCRIPT"),
("PRINT_EIGHT_BIT", "PRINT_EIGHT_BIT"),
("NO_PRINT_EIGHT_BIT", "PRINT_EIGHT_BIT"),
("PRINTEIGHTBIT", "PRINT_EIGHT_BIT"),
("NOPRINTEIGHTBIT", "PRINT_EIGHT_BIT"),
("PRINT_EXIT_VALUE", "PRINT_EXIT_VALUE"),
("NO_PRINT_EXIT_VALUE", "PRINT_EXIT_VALUE"),
("PRINTEXITVALUE", "PRINT_EXIT_VALUE"),
("NOPRINTEXITVALUE", "PRINT_EXIT_VALUE"),
("RC_QUOTES", "RC_QUOTES"),
("NO_RC_QUOTES", "RC_QUOTES"),
("RCQUOTES", "RC_QUOTES"),
("NORCQUOTES", "RC_QUOTES"),
("RM_STAR_SILENT", "RM_STAR_SILENT"),
("NO_RM_STAR_SILENT", "RM_STAR_SILENT"),
("RMSTARSILENT", "RM_STAR_SILENT"),
("NORMSTARSILENT", "RM_STAR_SILENT"),
("RM_STAR_WAIT", "RM_STAR_WAIT"),
("NO_RM_STAR_WAIT", "RM_STAR_WAIT"),
("RMSTARWAIT", "RM_STAR_WAIT"),
("NORMSTARWAIT", "RM_STAR_WAIT"),
("SHORT_LOOPS", "SHORT_LOOPS"),
("NO_SHORT_LOOPS", "SHORT_LOOPS"),
("SHORTLOOPS", "SHORT_LOOPS"),
("NOSHORTLOOPS", "SHORT_LOOPS"),
("SHORT_REPEAT", "SHORT_REPEAT"),
("NO_SHORT_REPEAT", "SHORT_REPEAT"),
("SHORTREPEAT", "SHORT_REPEAT"),
("NOSHORTREPEAT", "SHORT_REPEAT"),
("SUN_KEYBOARD_HACK", "SUN_KEYBOARD_HACK"),
("NO_SUN_KEYBOARD_HACK", "SUN_KEYBOARD_HACK"),
("SUNKEYBOARDHACK", "SUN_KEYBOARD_HACK"),
("NOSUNKEYBOARDHACK", "SUN_KEYBOARD_HACK"),
("AUTO_CONTINUE", "AUTO_CONTINUE"),
("NO_AUTO_CONTINUE", "AUTO_CONTINUE"),
("AUTOCONTINUE", "AUTO_CONTINUE"),
("NOAUTOCONTINUE", "AUTO_CONTINUE"),
("AUTO_RESUME", "AUTO_RESUME"),
("NO_AUTO_RESUME", "AUTO_RESUME"),
("AUTORESUME", "AUTO_RESUME"),
("NOAUTORESUME", "AUTO_RESUME"),
("BG_NICE", "BG_NICE"),
("NO_BG_NICE", "BG_NICE"),
("BGNICE", "BG_NICE"),
("NOBGNICE", "BG_NICE"),
("CHECK_JOBS", "CHECK_JOBS"),
("NO_CHECK_JOBS", "CHECK_JOBS"),
("CHECKJOBS", "CHECK_JOBS"),
("NOCHECKJOBS", "CHECK_JOBS"),
("CHECK_RUNNING_JOBS", "CHECK_RUNNING_JOBS"),
("NO_CHECK_RUNNING_JOBS", "CHECK_RUNNING_JOBS"),
("CHECKRUNNINGJOBS", "CHECK_RUNNING_JOBS"),
("NOCHECKRUNNINGJOBS", "CHECK_RUNNING_JOBS"),
("HUP", "HUP"),
("NO_HUP", "HUP"),
("NOHUP", "HUP"),
("LONG_LIST_JOBS", "LONG_LIST_JOBS"),
("NO_LONG_LIST_JOBS", "LONG_LIST_JOBS"),
("LONGLISTJOBS", "LONG_LIST_JOBS"),
("NOLONGLISTJOBS", "LONG_LIST_JOBS"),
("MONITOR", "MONITOR"),
("NO_MONITOR", "MONITOR"),
("NOMONITOR", "MONITOR"),
("NOTIFY", "NOTIFY"),
("NO_NOTIFY", "NOTIFY"),
("NONOTIFY", "NOTIFY"),
("POSIX_JOBS", "POSIX_JOBS"),
("POSIXJOBS", "POSIX_JOBS"),
("NO_POSIX_JOBS", "POSIX_JOBS"),
("NOPOSIXJOBS", "POSIX_JOBS"),
("PROMPT_BANG", "PROMPT_BANG"),
("NO_PROMPT_BANG", "PROMPT_BANG"),
("PROMPTBANG", "PROMPT_BANG"),
("NOPROMPTBANG", "PROMPT_BANG"),
("PROMPT_CR", "PROMPT_CR"),
("NO_PROMPT_CR", "PROMPT_CR"),
("PROMPTCR", "PROMPT_CR"),
("NOPROMPTCR", "PROMPT_CR"),
("PROMPT_SP", "PROMPT_SP"),
("NO_PROMPT_SP", "PROMPT_SP"),
("PROMPTSP", "PROMPT_SP"),
("NOPROMPTSP", "PROMPT_SP"),
("PROMPT_PERCENT", "PROMPT_PERCENT"),
("NO_PROMPT_PERCENT", "PROMPT_PERCENT"),
("PROMPTPERCENT", "PROMPT_PERCENT"),
("NOPROMPTPERCENT", "PROMPT_PERCENT"),
("PROMPT_SUBST", "PROMPT_SUBST"),
("NO_PROMPT_SUBST", "PROMPT_SUBST"),
("PROMPTSUBST", "PROMPT_SUBST"),
("NOPROMPTSUBST", "PROMPT_SUBST"),
("TRANSIENT_RPROMPT", "TRANSIENT_RPROMPT"),
("NO_TRANSIENT_RPROMPT", "TRANSIENT_RPROMPT"),
("TRANSIENTRPROMPT", "TRANSIENT_RPROMPT"),
("NOTRANSIENTRPROMPT", "TRANSIENT_RPROMPT"),
("ALIAS_FUNC_DEF", "ALIAS_FUNC_DEF"),
("NO_ALIAS_FUNC_DEF", "ALIAS_FUNC_DEF"),
("ALIASFUNCDEF", "ALIAS_FUNC_DEF"),
("NOALIASFUNCDEF", "ALIAS_FUNC_DEF"),
("C_BASES", "C_BASES"),
("NO_C_BASES", "C_BASES"),
("CBASES", "C_BASES"),
("NOCBASES", "C_BASES"),
("C_PRECEDENCES", "C_PRECEDENCES"),
("NO_C_PRECEDENCES", "C_PRECEDENCES"),
("CPRECEDENCES", "C_PRECEDENCES"),
("NOCPRECEDENCES", "C_PRECEDENCES"),
("DEBUG_BEFORE_CMD", "DEBUG_BEFORE_CMD"),
("NO_DEBUG_BEFORE_CMD", "DEBUG_BEFORE_CMD"),
("DEBUGBEFORECMD", "DEBUG_BEFORE_CMD"),
("NODEBUGBEFORECMD", "DEBUG_BEFORE_CMD"),
("ERR_EXIT", "ERR_EXIT"),
("NO_ERR_EXIT", "ERR_EXIT"),
("ERREXIT", "ERR_EXIT"),
("NOERREXIT", "ERR_EXIT"),
("ERR_RETURN", "ERR_RETURN"),
("NO_ERR_RETURN", "ERR_RETURN"),
("ERRRETURN", "ERR_RETURN"),
("NOERRRETURN", "ERR_RETURN"),
("EVAL_LINENO", "EVAL_LINENO"),
("NO_EVAL_LINENO", "EVAL_LINENO"),
("EVALLINENO", "EVAL_LINENO"),
("NOEVALLINENO", "EVAL_LINENO"),
("EXEC", "EXEC"),
("NO_EXEC", "EXEC"),
("NOEXEC", "EXEC"),
("FUNCTION_ARGZERO", "FUNCTION_ARGZERO"),
("NO_FUNCTION_ARGZERO", "FUNCTION_ARGZERO"),
("FUNCTIONARGZERO", "FUNCTION_ARGZERO"),
("NOFUNCTIONARGZERO", "FUNCTION_ARGZERO"),
("LOCAL_LOOPS", "LOCAL_LOOPS"),
("NO_LOCAL_LOOPS", "LOCAL_LOOPS"),
("LOCALLOOPS", "LOCAL_LOOPS"),
("NOLOCALLOOPS", "LOCAL_LOOPS"),
("LOCAL_OPTIONS", "LOCAL_OPTIONS"),
("NO_LOCAL_OPTIONS", "LOCAL_OPTIONS"),
("LOCALOPTIONS", "LOCAL_OPTIONS"),
("NOLOCALOPTIONS", "LOCAL_OPTIONS"),
("LOCAL_PATTERNS", "LOCAL_PATTERNS"),
("NO_LOCAL_PATTERNS", "LOCAL_PATTERNS"),
("LOCALPATTERNS", "LOCAL_PATTERNS"),
("NOLOCALPATTERNS", "LOCAL_PATTERNS"),
("LOCAL_TRAPS", "LOCAL_TRAPS"),
("NO_LOCAL_TRAPS", "LOCAL_TRAPS"),
("LOCALTRAPS", "LOCAL_TRAPS"),
("NOLOCALTRAPS", "LOCAL_TRAPS"),
("MULTI_FUNC_DEF", "MULTI_FUNC_DEF"),
("NO_MULTI_FUNC_DEF", "MULTI_FUNC_DEF"),
("MULTIFUNCDEF", "MULTI_FUNC_DEF"),
("NOMULTIFUNCDEF", "MULTI_FUNC_DEF"),
("MULTIOS", "MULTIOS"),
("NO_MULTIOS", "MULTIOS"),
("NOMULTIOS", "MULTIOS"),
("OCTAL_ZEROES", "OCTAL_ZEROES"),
("NO_OCTAL_ZEROES", "OCTAL_ZEROES"),
("OCTALZEROES", "OCTAL_ZEROES"),
("NOOCTALZEROES", "OCTAL_ZEROES"),
("PIPE_FAIL", "PIPE_FAIL"),
("NO_PIPE_FAIL", "PIPE_FAIL"),
("PIPEFAIL", "PIPE_FAIL"),
("NOPIPEFAIL", "PIPE_FAIL"),
("SOURCE_TRACE", "SOURCE_TRACE"),
("NO_SOURCE_TRACE", "SOURCE_TRACE"),
("SOURCETRACE", "SOURCE_TRACE"),
("NOSOURCETRACE", "SOURCE_TRACE"),
("TYPESET_SILENT", "TYPESET_SILENT"),
("NO_TYPESET_SILENT", "TYPESET_SILENT"),
("TYPESETSILENT", "TYPESET_SILENT"),
("NOTYPESETSILENT", "TYPESET_SILENT"),
("TYPESET_TO_UNSET", "TYPESET_TO_UNSET"),
("NO_TYPESET_TO_UNSET", "TYPESET_TO_UNSET"),
("TYPESETTOUNSET", "TYPESET_TO_UNSET"),
("NOTYPESETTOUNSET", "TYPESET_TO_UNSET"),
("VERBOSE", "VERBOSE"),
("NO_VERBOSE", "VERBOSE"),
("NOVERBOSE", "VERBOSE"),
("XTRACE", "XTRACE"),
("NO_XTRACE", "XTRACE"),
("NOXTRACE", "XTRACE"),
("APPEND_CREATE", "APPEND_CREATE"),
("NO_APPEND_CREATE", "APPEND_CREATE"),
("APPENDCREATE", "APPEND_CREATE"),
("NOAPPENDCREATE", "APPEND_CREATE"),
("BASH_REMATCH", "BASH_REMATCH"),
("NO_BASH_REMATCH", "BASH_REMATCH"),
("BASHREMATCH", "BASH_REMATCH"),
("NOBASHREMATCH", "BASH_REMATCH"),
("BSD_ECHO", "BSD_ECHO"),
("NO_BSD_ECHO", "BSD_ECHO"),
("BSDECHO", "BSD_ECHO"),
("NOBSDECHO", "BSD_ECHO"),
("CONTINUE_ON_ERROR", "CONTINUE_ON_ERROR"),
("NO_CONTINUE_ON_ERROR", "CONTINUE_ON_ERROR"),
("CONTINUEONERROR", "CONTINUE_ON_ERROR"),
("NOCONTINUEONERROR", "CONTINUE_ON_ERROR"),
("CSH_JUNKIE_HISTORY", "CSH_JUNKIE_HISTORY"),
("NO_CSH_JUNKIE_HISTORY", "CSH_JUNKIE_HISTORY"),
("CSHJUNKIEHISTORY", "CSH_JUNKIE_HISTORY"),
("NOCSHJUNKIEHISTORY", "CSH_JUNKIE_HISTORY"),
("CSH_JUNKIE_LOOPS", "CSH_JUNKIE_LOOPS"),
("NO_CSH_JUNKIE_LOOPS", "CSH_JUNKIE_LOOPS"),
("CSHJUNKIELOOPS", "CSH_JUNKIE_LOOPS"),
("NOCSHJUNKIELOOPS", "CSH_JUNKIE_LOOPS"),
("CSH_JUNKIE_QUOTES", "CSH_JUNKIE_QUOTES"),
("NO_CSH_JUNKIE_QUOTES", "CSH_JUNKIE_QUOTES"),
("CSHJUNKIEQUOTES", "CSH_JUNKIE_QUOTES"),
("NOCSHJUNKIEQUOTES", "CSH_JUNKIE_QUOTES"),
("CSH_NULLCMD", "CSH_NULLCMD"),
("NO_CSH_NULLCMD", "CSH_NULLCMD"),
("CSHNULLCMD", "CSH_NULLCMD"),
("NOCSHNULLCMD", "CSH_NULLCMD"),
("KSH_ARRAYS", "KSH_ARRAYS"),
("NO_KSH_ARRAYS", "KSH_ARRAYS"),
("KSHARRAYS", "KSH_ARRAYS"),
("NOKSHARRAYS", "KSH_ARRAYS"),
("KSH_AUTOLOAD", "KSH_AUTOLOAD"),
("NO_KSH_AUTOLOAD", "KSH_AUTOLOAD"),
("KSHAUTOLOAD", "KSH_AUTOLOAD"),
("NOKSHAUTOLOAD", "KSH_AUTOLOAD"),
("KSH_OPTION_PRINT", "KSH_OPTION_PRINT"),
("NO_KSH_OPTION_PRINT", "KSH_OPTION_PRINT"),
("KSHOPTIONPRINT", "KSH_OPTION_PRINT"),
("NOKSHOPTIONPRINT", "KSH_OPTION_PRINT"),
("KSH_TYPESET", "KSH_TYPESET"),
("NO_KSH_TYPESET", "KSH_TYPESET"),
("KSHTYPESET", "KSH_TYPESET"),
("NOKSHTYPESET", "KSH_TYPESET"),
("KSH_ZERO_SUBSCRIPT", "KSH_ZERO_SUBSCRIPT"),
("NO_KSH_ZERO_SUBSCRIPT", "KSH_ZERO_SUBSCRIPT"),
("KSHZEROSUBSCRIPT", "KSH_ZERO_SUBSCRIPT"),
("NOKSHZEROSUBSCRIPT", "KSH_ZERO_SUBSCRIPT"),
("POSIX_ALIASES", "POSIX_ALIASES"),
("NO_POSIX_ALIASES", "POSIX_ALIASES"),
("POSIXALIASES", "POSIX_ALIASES"),
("NOPOSIXALIASES", "POSIX_ALIASES"),
("POSIX_ARGZERO", "POSIX_ARGZERO"),
("NO_POSIX_ARGZERO", "POSIX_ARGZERO"),
("POSIXARGZERO", "POSIX_ARGZERO"),
("NOPOSIXARGZERO", "POSIX_ARGZERO"),
("POSIX_BUILTINS", "POSIX_BUILTINS"),
("NO_POSIX_BUILTINS", "POSIX_BUILTINS"),
("POSIXBUILTINS", "POSIX_BUILTINS"),
("NOPOSIXBUILTINS", "POSIX_BUILTINS"),
("POSIX_IDENTIFIERS", "POSIX_IDENTIFIERS"),
("NO_POSIX_IDENTIFIERS", "POSIX_IDENTIFIERS"),
("POSIXIDENTIFIERS", "POSIX_IDENTIFIERS"),
("NOPOSIXIDENTIFIERS", "POSIX_IDENTIFIERS"),
("POSIX_STRINGS", "POSIX_STRINGS"),
("NO_POSIX_STRINGS", "POSIX_STRINGS"),
("POSIXSTRINGS", "POSIX_STRINGS"),
("NOPOSIXSTRINGS", "POSIX_STRINGS"),
("POSIX_TRAPS", "POSIX_TRAPS"),
("NO_POSIX_TRAPS", "POSIX_TRAPS"),
("POSIXTRAPS", "POSIX_TRAPS"),
("NOPOSIXTRAPS", "POSIX_TRAPS"),
("SH_FILE_EXPANSION", "SH_FILE_EXPANSION"),
("NO_SH_FILE_EXPANSION", "SH_FILE_EXPANSION"),
("SHFILEEXPANSION", "SH_FILE_EXPANSION"),
("NOSHFILEEXPANSION", "SH_FILE_EXPANSION"),
("SH_NULLCMD", "SH_NULLCMD"),
("NO_SH_NULLCMD", "SH_NULLCMD"),
("SHNULLCMD", "SH_NULLCMD"),
("NOSHNULLCMD", "SH_NULLCMD"),
("SH_OPTION_LETTERS", "SH_OPTION_LETTERS"),
("NO_SH_OPTION_LETTERS", "SH_OPTION_LETTERS"),
("SHOPTIONLETTERS", "SH_OPTION_LETTERS"),
("NOSHOPTIONLETTERS", "SH_OPTION_LETTERS"),
("SH_WORD_SPLIT", "SH_WORD_SPLIT"),
("NO_SH_WORD_SPLIT", "SH_WORD_SPLIT"),
("SHWORDSPLIT", "SH_WORD_SPLIT"),
("NOSHWORDSPLIT", "SH_WORD_SPLIT"),
("TRAPS_ASYNC", "TRAPS_ASYNC"),
("NO_TRAPS_ASYNC", "TRAPS_ASYNC"),
("TRAPSASYNC", "TRAPS_ASYNC"),
("NOTRAPSASYNC", "TRAPS_ASYNC"),
("INTERACTIVE", "INTERACTIVE"),
("NO_INTERACTIVE", "INTERACTIVE"),
("NOINTERACTIVE", "INTERACTIVE"),
("LOGIN", "LOGIN"),
("NO_LOGIN", "LOGIN"),
("NOLOGIN", "LOGIN"),
("PRIVILEGED", "PRIVILEGED"),
("NO_PRIVILEGED", "PRIVILEGED"),
("NOPRIVILEGED", "PRIVILEGED"),
("SHIN_STDIN", "SHIN_STDIN"),
("NO_SHIN_STDIN", "SHIN_STDIN"),
("SHINSTDIN", "SHIN_STDIN"),
("NOSHINSTDIN", "SHIN_STDIN"),
("SINGLE_COMMAND", "SINGLE_COMMAND"),
("NO_SINGLE_COMMAND", "SINGLE_COMMAND"),
("SINGLECOMMAND", "SINGLE_COMMAND"),
("NOSINGLECOMMAND", "SINGLE_COMMAND"),
("BEEP", "BEEP"),
("NO_BEEP", "BEEP"),
("NOBEEP", "BEEP"),
("COMBINING_CHARS", "COMBINING_CHARS"),
("NO_COMBINING_CHARS", "COMBINING_CHARS"),
("COMBININGCHARS", "COMBINING_CHARS"),
("NOCOMBININGCHARS", "COMBINING_CHARS"),
("EMACS", "EMACS"),
("NO_EMACS", "EMACS"),
("NOEMACS", "EMACS"),
("OVERSTRIKE", "OVERSTRIKE"),
("NO_OVERSTRIKE", "OVERSTRIKE"),
("NOOVERSTRIKE", "OVERSTRIKE"),
("SINGLE_LINE_ZLE", "SINGLE_LINE_ZLE"),
("NO_SINGLE_LINE_ZLE", "SINGLE_LINE_ZLE"),
("SINGLELINEZLE", "SINGLE_LINE_ZLE"),
("NOSINGLELINEZLE", "SINGLE_LINE_ZLE"),
("VI", "VI"),
("NO_VI", "VI"),
("NOVI", "VI"),
("ZLE", "ZLE"),
("NO_ZLE", "ZLE"),
("NOZLE", "ZLE"),
("BRACE_EXPAND", "BRACE_EXPAND"),
("NO_BRACE_EXPAND", "BRACE_EXPAND"),
("BRACEEXPAND", "BRACE_EXPAND"),
("NOBRACEEXPAND", "BRACE_EXPAND"),
("DOT_GLOB", "DOT_GLOB"),
("NO_DOT_GLOB", "DOT_GLOB"),
("DOTGLOB", "DOT_GLOB"),
("NODOTGLOB", "DOT_GLOB"),
("HASH_ALL", "HASH_ALL"),
("NO_HASH_ALL", "HASH_ALL"),
("HASHALL", "HASH_ALL"),
("NOHASHALL", "HASH_ALL"),
("HIST_APPEND", "HIST_APPEND"),
("NO_HIST_APPEND", "HIST_APPEND"),
("HISTAPPEND", "HIST_APPEND"),
("NOHISTAPPEND", "HIST_APPEND"),
("HIST_EXPAND", "HIST_EXPAND"),
("NO_HIST_EXPAND", "HIST_EXPAND"),
("HISTEXPAND", "HIST_EXPAND"),
("NOHISTEXPAND", "HIST_EXPAND"),
("LOG", "LOG"),
("NO_LOG", "LOG"),
("NOLOG", "LOG"),
("MAIL_WARN", "MAIL_WARN"),
("NO_MAIL_WARN", "MAIL_WARN"),
("MAILWARN", "MAIL_WARN"),
("NOMAILWARN", "MAIL_WARN"),
("ONE_CMD", "ONE_CMD"),
("NO_ONE_CMD", "ONE_CMD"),
("ONECMD", "ONE_CMD"),
("NOONECMD", "ONE_CMD"),
("PHYSICAL", "PHYSICAL"),
("NO_PHYSICAL", "PHYSICAL"),
("NOPHYSICAL", "PHYSICAL"),
("PROMPT_VARS", "PROMPT_VARS"),
("NO_PROMPT_VARS", "PROMPT_VARS"),
("PROMPTVARS", "PROMPT_VARS"),
("NOPROMPTVARS", "PROMPT_VARS"),
("STDIN", "STDIN"),
("NO_STDIN", "STDIN"),
("NOSTDIN", "STDIN"),
("TRACK_ALL", "TRACK_ALL"),
("NO_TRACK_ALL", "TRACK_ALL"),
("TRACKALL", "TRACK_ALL"),
("NOTRACKALL", "TRACK_ALL"),
];
/// Resolve a option name (case-insensitive, alias-aware)
/// to its canonical name + markdown body.
pub fn lookup_option_doc(name: &str) -> Option<(&'static str, &'static str)> {
let key = name.to_ascii_uppercase();
let canon = OPTION_ALIASES
.iter()
.find(|(a, _)| *a == key.as_str())
.map(|(_, c)| *c)?;
OPTION_DOCS.iter().find(|(n, _)| *n == canon).map(|&(n, d)| (n, d))
}