Merge pull request #20848 from zeertzjq/vim-8.2.1639

vim-patch:8.2.{1639,1642,1652,1663,1716}: optwin translations

1 files changed, 505 insertions, 514 deletions

diff --git a/runtime/optwin.vim b/runtime/optwin.vim
index 16af8fce17..57e5392b98 100644
--- a/runtime/optwin.vim
+++ b/runtime/optwin.vim
@@ -20,7 +20,7 @@ let s:cpo_save = &cpo
 set cpo&vim
 
 " function to be called when <CR> is hit in the option-window
-fun! <SID>CR()
+func <SID>CR()
 
   " If on a continued comment line, go back to the first comment line
   let lnum = search("^[^\t]", 'bWcn')
@@ -47,10 +47,10 @@ fun! <SID>CR()
   elseif match(line, '^ \=[0-9]') >= 0
     exe "norm! /" . line . "\<CR>zt"
   endif
-endfun
+endfunc
 
 " function to be called when <Space> is hit in the option-window
-fun! <SID>Space()
+func <SID>Space()
 
   let lnum = line(".")
   let line = getline(lnum)
@@ -67,16 +67,17 @@ fun! <SID>Space()
     endif
 
   endif
-endfun
+endfunc
 
-let s:local_to_window = '(local to window)'
-let s:local_to_buffer = '(local to buffer)'
-let s:global_or_local = '(global or local to buffer)'
+let s:local_to_window = gettext('(local to window)')
+let s:local_to_buffer = gettext('(local to buffer)')
+let s:global_or_local = gettext('(global or local to buffer)')
 
 " find the window in which the option applies
 " returns 0 for global option, 1 for local option, -1 for error
-fun! <SID>Find(lnum)
-    if getline(a:lnum - 1) =~ "(local to"
+func <SID>Find(lnum)
+    let line = getline(a:lnum - 1)
+    if line =~ s:local_to_window || line =~ s:local_to_buffer
       let local = 1
       let thiswin = winnr()
       wincmd p
@@ -95,10 +96,10 @@ fun! <SID>Find(lnum)
       let local = -1
     endif
     return local
-endfun
+endfunc
 
 " Update a "set" line in the option window
-fun! <SID>Update(lnum, line, local, thiswin)
+func <SID>Update(lnum, line, local, thiswin)
   " get the new value of the option and update the option window line
   if match(a:line, "=") >= 0
     let name = substitute(a:line, '^ \tset \([^=]*\)=.*', '\1', "")
@@ -123,7 +124,7 @@ fun! <SID>Update(lnum, line, local, thiswin)
     endif
   endif
   set nomodified
-endfun
+endfunc
 
 " Reset 'title' and 'icon' to make it work faster.
 " Reset 'undolevels' to avoid undo'ing until the buffer is empty.
@@ -170,34 +171,34 @@ func <SID>AddOption(name, text)
 endfunc
 
 " Init a local binary option
-fun! <SID>BinOptionL(name)
+func <SID>BinOptionL(name)
   let val = getwinvar(winnr('#'), '&' . a:name)
   call append("$", substitute(substitute(" \tset " . val . a:name . "\t" .
 	\!val . a:name, "0", "no", ""), "1", "", ""))
-endfun
+endfunc
 
 " Init a global binary option
-fun! <SID>BinOptionG(name, val)
+func <SID>BinOptionG(name, val)
   call append("$", substitute(substitute(" \tset " . a:val . a:name . "\t" .
 	\!a:val . a:name, "0", "no", ""), "1", "", ""))
-endfun
+endfunc
 
 " Init a local string option
-fun! <SID>OptionL(name)
+func <SID>OptionL(name)
   let val = escape(getwinvar(winnr('#'), '&' . a:name), " \t\\\"|")
   call append("$", " \tset " . a:name . "=" . val)
-endfun
+endfunc
 
 " Init a global string option
-fun! <SID>OptionG(name, val)
+func <SID>OptionG(name, val)
   call append("$", " \tset " . a:name . "=" . escape(a:val, " \t\\\"|"))
-endfun
+endfunc
 
 let s:idx = 1
 let s:lnum = line("$")
 call append("$", "")
 
-fun! <SID>Header(text)
+func <SID>Header(text)
   let line = s:idx . " " . a:text
   if s:idx < 10
     let line = " " . line
@@ -208,15 +209,15 @@ fun! <SID>Header(text)
   call append(s:lnum, line)
   let s:idx = s:idx + 1
   let s:lnum = s:lnum + 1
-endfun
+endfunc
 
 " Get the value of 'pastetoggle'.  It could be a special key.
-fun! <SID>PTvalue()
+func <SID>PTvalue()
   redir @a
   silent set pt
   redir END
   return substitute(@a, '[^=]*=\(.*\)', '\1', "")
-endfun
+endfunc
 
 " Restore the previous value of 'cpoptions' here, it's used below.
 let &cpo = s:cpo_save
@@ -224,1042 +225,1032 @@ let &cpo = s:cpo_save
 " List of all options, organized by function.
 " The text should be sufficient to know what the option is used for.
 
-call <SID>Header("important")
-call append("$", "compatible\tbehave very Vi compatible (not advisable)")
+call <SID>Header(gettext("important"))
+call <SID>AddOption("compatible", gettext("behave very Vi compatible (not advisable)"))
 call <SID>BinOptionG("cp", &cp)
-call append("$", "cpoptions\tlist of flags to specify Vi compatibility")
+call <SID>AddOption("cpoptions", gettext("list of flags to specify Vi compatibility"))
 call <SID>OptionG("cpo", &cpo)
-call append("$", "paste\tpaste mode, insert typed text literally")
+call <SID>AddOption("paste", gettext("paste mode, insert typed text literally"))
 call <SID>BinOptionG("paste", &paste)
-call append("$", "pastetoggle\tkey sequence to toggle paste mode")
+call <SID>AddOption("pastetoggle", gettext("key sequence to toggle paste mode"))
 if &pt =~ "\x80"
   call append("$", " \tset pt=" . <SID>PTvalue())
 else
   call <SID>OptionG("pt", &pt)
 endif
-call append("$", "runtimepath\tlist of directories used for runtime files and plugins")
+call <SID>AddOption("runtimepath", gettext("list of directories used for runtime files and plugins"))
 call <SID>OptionG("rtp", &rtp)
-call append("$", "packpath\tlist of directories used for plugin packages")
+call <SID>AddOption("packpath", gettext("list of directories used for plugin packages"))
 call <SID>OptionG("pp", &pp)
-call append("$", "helpfile\tname of the main help file")
+call <SID>AddOption("helpfile", gettext("name of the main help file"))
 call <SID>OptionG("hf", &hf)
 
 
-call <SID>Header("moving around, searching and patterns")
-call append("$", "whichwrap\tlist of flags specifying which commands wrap to another line")
-call append("$", "\t(local to window)")
-call <SID>OptionL("ww")
-call append("$", "startofline\tmany jump commands move the cursor to the first non-blank")
-call append("$", "\tcharacter of a line")
+call <SID>Header(gettext("moving around, searching and patterns"))
+call <SID>AddOption("whichwrap", gettext("list of flags specifying which commands wrap to another line"))
+call <SID>OptionG("ww", &ww)
+call <SID>AddOption("startofline", gettext("many jump commands move the cursor to the first non-blank\ncharacter of a line"))
 call <SID>BinOptionG("sol", &sol)
-call append("$", "paragraphs\tnroff macro names that separate paragraphs")
+call <SID>AddOption("paragraphs", gettext("nroff macro names that separate paragraphs"))
 call <SID>OptionG("para", &para)
-call append("$", "sections\tnroff macro names that separate sections")
+call <SID>AddOption("sections", gettext("nroff macro names that separate sections"))
 call <SID>OptionG("sect", &sect)
-call append("$", "path\tlist of directory names used for file searching")
-call append("$", "\t(global or local to buffer)")
+call <SID>AddOption("path", gettext("list of directory names used for file searching"))
+call append("$", "\t" .. s:global_or_local)
 call <SID>OptionG("pa", &pa)
-call <SID>AddOption("cdhome", ":cd without argument goes to the home directory")
+call <SID>AddOption("cdhome", gettext(":cd without argument goes to the home directory"))
 call <SID>BinOptionG("cdh", &cdh)
-call append("$", "cdpath\tlist of directory names used for :cd")
+call <SID>AddOption("cdpath", gettext("list of directory names used for :cd"))
 call <SID>OptionG("cd", &cd)
 if exists("+autochdir")
-  call append("$", "autochdir\tchange to directory of file in buffer")
+  call <SID>AddOption("autochdir", gettext("change to directory of file in buffer"))
   call <SID>BinOptionG("acd", &acd)
 endif
-call append("$", "wrapscan\tsearch commands wrap around the end of the buffer")
+call <SID>AddOption("wrapscan", gettext("search commands wrap around the end of the buffer"))
 call <SID>BinOptionG("ws", &ws)
-call append("$", "incsearch\tshow match for partly typed search command")
+call <SID>AddOption("incsearch", gettext("show match for partly typed search command"))
 call <SID>BinOptionG("is", &is)
-call append("$", "magic\tchange the way backslashes are used in search patterns")
+call <SID>AddOption("magic", gettext("change the way backslashes are used in search patterns"))
 call <SID>BinOptionG("magic", &magic)
-call append("$", "regexpengine\tselect the default regexp engine used")
+call <SID>AddOption("regexpengine", gettext("select the default regexp engine used"))
 call <SID>OptionG("re", &re)
-call append("$", "ignorecase\tignore case when using a search pattern")
+call <SID>AddOption("ignorecase", gettext("ignore case when using a search pattern"))
 call <SID>BinOptionG("ic", &ic)
-call append("$", "smartcase\toverride 'ignorecase' when pattern has upper case characters")
+call <SID>AddOption("smartcase", gettext("override 'ignorecase' when pattern has upper case characters"))
 call <SID>BinOptionG("scs", &scs)
-call append("$", "casemap\twhat method to use for changing case of letters")
+call <SID>AddOption("casemap", gettext("what method to use for changing case of letters"))
 call <SID>OptionG("cmp", &cmp)
-call append("$", "maxmempattern\tmaximum amount of memory in Kbyte used for pattern matching")
+call <SID>AddOption("maxmempattern", gettext("maximum amount of memory in Kbyte used for pattern matching"))
 call append("$", " \tset mmp=" . &mmp)
-call append("$", "define\tpattern for a macro definition line")
-call append("$", "\t(global or local to buffer)")
+call <SID>AddOption("define", gettext("pattern for a macro definition line"))
+call append("$", "\t" .. s:global_or_local)
 call <SID>OptionG("def", &def)
 if has("find_in_path")
-  call append("$", "include\tpattern for an include-file line")
-  call append("$", "\t(local to buffer)")
+  call <SID>AddOption("include", gettext("pattern for an include-file line"))
+  call append("$", "\t" .. s:local_to_buffer)
   call <SID>OptionL("inc")
-  call append("$", "includeexpr\texpression used to transform an include line to a file name")
-  call append("$", "\t(local to buffer)")
+  call <SID>AddOption("includeexpr", gettext("expression used to transform an include line to a file name"))
+  call append("$", "\t" .. s:local_to_buffer)
   call <SID>OptionL("inex")
 endif
 
 
-call <SID>Header("tags")
-call append("$", "tagbsearch\tuse binary searching in tags files")
+call <SID>Header(gettext("tags"))
+call <SID>AddOption("tagbsearch", gettext("use binary searching in tags files"))
 call <SID>BinOptionG("tbs", &tbs)
-call append("$", "taglength\tnumber of significant characters in a tag name or zero")
+call <SID>AddOption("taglength", gettext("number of significant characters in a tag name or zero"))
 call append("$", " \tset tl=" . &tl)
-call append("$", "tags\tlist of file names to search for tags")
-call append("$", "\t(global or local to buffer)")
+call <SID>AddOption("tags", gettext("list of file names to search for tags"))
+call append("$", "\t" .. s:global_or_local)
 call <SID>OptionG("tag", &tag)
-call append("$", "tagcase\thow to handle case when searching in tags files:")
-call append("$", "\t\"followic\" to follow 'ignorecase', \"ignore\" or \"match\"")
-call append("$", "\t(global or local to buffer)")
+call <SID>AddOption("tagcase", gettext("how to handle case when searching in tags files:\n\"followic\" to follow 'ignorecase', \"ignore\" or \"match\""))
+call append("$", "\t" .. s:global_or_local)
 call <SID>OptionG("tc", &tc)
-call append("$", "tagrelative\tfile names in a tags file are relative to the tags file")
+call <SID>AddOption("tagrelative", gettext("file names in a tags file are relative to the tags file"))
 call <SID>BinOptionG("tr", &tr)
-call append("$", "tagstack\ta :tag command will use the tagstack")
+call <SID>AddOption("tagstack", gettext("a :tag command will use the tagstack"))
 call <SID>BinOptionG("tgst", &tgst)
-call append("$", "showfulltag\twhen completing tags in Insert mode show more info")
+call <SID>AddOption("showfulltag", gettext("when completing tags in Insert mode show more info"))
 call <SID>BinOptionG("sft", &sft)
 if has("eval")
-  call append("$", "tagfunc\ta function to be used to perform tag searches")
-  call append("$", "\t(local to buffer)")
+  call <SID>AddOption("tagfunc", gettext("a function to be used to perform tag searches"))
+  call append("$", "\t" .. s:local_to_buffer)
   call <SID>OptionL("tfu")
 endif
 
 
-call <SID>Header("displaying text")
-call append("$", "scroll\tnumber of lines to scroll for CTRL-U and CTRL-D")
-call append("$", "\t(local to window)")
+call <SID>Header(gettext("displaying text"))
+call <SID>AddOption("scroll", gettext("number of lines to scroll for CTRL-U and CTRL-D"))
+call append("$", "\t" .. s:local_to_window)
 call <SID>OptionL("scr")
-call append("$", "scrolloff\tnumber of screen lines to show around the cursor")
+call <SID>AddOption("scrolloff", gettext("number of screen lines to show around the cursor"))
 call append("$", " \tset so=" . &so)
-call append("$", "wrap\tlong lines wrap")
-call append("$", "\t(local to window)")
+call <SID>AddOption("wrap", gettext("long lines wrap"))
+call append("$", "\t" .. s:local_to_window)
 call <SID>BinOptionL("wrap")
-call append("$", "linebreak\twrap long lines at a character in 'breakat'")
-call append("$", "\t(local to window)")
+call <SID>AddOption("linebreak", gettext("wrap long lines at a character in 'breakat'"))
+call append("$", "\t" .. s:local_to_window)
 call <SID>BinOptionL("lbr")
-call append("$", "breakindent\tpreserve indentation in wrapped text")
-call append("$", "\t(local to window)")
+call <SID>AddOption("breakindent", gettext("preserve indentation in wrapped text"))
+call append("$", "\t" .. s:local_to_window)
 call <SID>BinOptionL("bri")
-call append("$", "breakindentopt\tadjust breakindent behaviour")
-call append("$", "\t(local to window)")
+call <SID>AddOption("breakindentopt", gettext("adjust breakindent behaviour"))
+call append("$", "\t" .. s:local_to_window)
 call <SID>OptionL("briopt")
-call append("$", "breakat\twhich characters might cause a line break")
+call <SID>AddOption("breakat", gettext("which characters might cause a line break"))
 call <SID>OptionG("brk", &brk)
-call append("$", "showbreak\tstring to put before wrapped screen lines")
+call <SID>AddOption("showbreak", gettext("string to put before wrapped screen lines"))
 call <SID>OptionG("sbr", &sbr)
-call append("$", "sidescroll\tminimal number of columns to scroll horizontally")
+call <SID>AddOption("sidescroll", gettext("minimal number of columns to scroll horizontally"))
 call append("$", " \tset ss=" . &ss)
-call append("$", "sidescrolloff\tminimal number of columns to keep left and right of the cursor")
+call <SID>AddOption("sidescrolloff", gettext("minimal number of columns to keep left and right of the cursor"))
 call append("$", " \tset siso=" . &siso)
-call append("$", "display\tinclude \"lastline\" to show the last line even if it doesn't fit")
-call append("$", "\tinclude \"uhex\" to show unprintable characters as a hex number")
+call <SID>AddOption("display", gettext("include \"lastline\" to show the last line even if it doesn't fit\ninclude \"uhex\" to show unprintable characters as a hex number"))
 call <SID>OptionG("dy", &dy)
-call append("$", "fillchars\tcharacters to use for the status line, folds and filler lines")
+call <SID>AddOption("fillchars", gettext("characters to use for the status line, folds and filler lines"))
 call <SID>OptionG("fcs", &fcs)
-call append("$", "cmdheight\tnumber of lines used for the command-line")
+call <SID>AddOption("cmdheight", gettext("number of lines used for the command-line"))
 call append("$", " \tset ch=" . &ch)
-call append("$", "columns\twidth of the display")
+call <SID>AddOption("columns", gettext("width of the display"))
 call append("$", " \tset co=" . &co)
-call append("$", "lines\tnumber of lines in the display")
+call <SID>AddOption("lines", gettext("number of lines in the display"))
 call append("$", " \tset lines=" . &lines)
-call append("$", "window\tnumber of lines to scroll for CTRL-F and CTRL-B")
+call <SID>AddOption("window", gettext("number of lines to scroll for CTRL-F and CTRL-B"))
 call append("$", " \tset window=" . &window)
-call append("$", "lazyredraw\tdon't redraw while executing macros")
+call <SID>AddOption("lazyredraw", gettext("don't redraw while executing macros"))
 call <SID>BinOptionG("lz", &lz)
 if has("reltime")
-  call append("$", "redrawtime\ttimeout for 'hlsearch' and :match highlighting in msec")
+  call <SID>AddOption("redrawtime", gettext("timeout for 'hlsearch' and :match highlighting in msec"))
   call append("$", " \tset rdt=" . &rdt)
 endif
-call append("$", "writedelay\tdelay in msec for each char written to the display")
-call append("$", "\t(for debugging)")
+call <SID>AddOption("writedelay", gettext("delay in msec for each char written to the display\n(for debugging)"))
 call append("$", " \tset wd=" . &wd)
-call append("$", "list\tshow <Tab> as ^I and end-of-line as $")
-call append("$", "\t(local to window)")
+call <SID>AddOption("list", gettext("show <Tab> as ^I and end-of-line as $"))
+call append("$", "\t" .. s:local_to_window)
 call <SID>BinOptionL("list")
-call append("$", "listchars\tlist of strings used for list mode")
+call <SID>AddOption("listchars", gettext("list of strings used for list mode"))
 call <SID>OptionG("lcs", &lcs)
-call append("$", "number\tshow the line number for each line")
-call append("$", "\t(local to window)")
+call <SID>AddOption("number", gettext("show the line number for each line"))
+call append("$", "\t" .. s:local_to_window)
 call <SID>BinOptionL("nu")
-call append("$", "relativenumber\tshow the relative line number for each line")
-call append("$", "\t(local to window)")
+call <SID>AddOption("relativenumber", gettext("show the relative line number for each line"))
+call append("$", "\t" .. s:local_to_window)
 call <SID>BinOptionL("rnu")
 if has("linebreak")
-  call append("$", "numberwidth\tnumber of columns to use for the line number")
-  call append("$", "\t(local to window)")
+  call <SID>AddOption("numberwidth", gettext("number of columns to use for the line number"))
+  call append("$", "\t" .. s:local_to_window)
   call <SID>OptionL("nuw")
 endif
 if has("conceal")
-  call append("$", "conceallevel\tcontrols whether concealable text is hidden")
-  call append("$", "\t(local to window)")
+  call <SID>AddOption("conceallevel", gettext("controls whether concealable text is hidden"))
+  call append("$", "\t" .. s:local_to_window)
   call <SID>OptionL("cole")
-  call append("$", "concealcursor\tmodes in which text in the cursor line can be concealed")
-  call append("$", "\t(local to window)")
+  call <SID>AddOption("concealcursor", gettext("modes in which text in the cursor line can be concealed"))
+  call append("$", "\t" .. s:local_to_window)
   call <SID>OptionL("cocu")
 endif
 
 
-call <SID>Header("syntax, highlighting and spelling")
-call append("$", "background\t\"dark\" or \"light\"; the background color brightness")
+call <SID>Header(gettext("syntax, highlighting and spelling"))
+call <SID>AddOption("background", gettext("\"dark\" or \"light\"; the background color brightness"))
 call <SID>OptionG("bg", &bg)
-call append("$", "filetype\ttype of file; triggers the FileType event when set")
-call append("$", "\t(local to buffer)")
+call <SID>AddOption("filetype", gettext("type of file; triggers the FileType event when set"))
+call append("$", "\t" .. s:local_to_buffer)
 call <SID>OptionL("ft")
 if has("syntax")
-  call append("$", "syntax\tname of syntax highlighting used")
-  call append("$", "\t(local to buffer)")
+  call <SID>AddOption("syntax", gettext("name of syntax highlighting used"))
+  call append("$", "\t" .. s:local_to_buffer)
   call <SID>OptionL("syn")
-  call append("$", "synmaxcol\tmaximum column to look for syntax items")
-  call append("$", "\t(local to buffer)")
+  call <SID>AddOption("synmaxcol", gettext("maximum column to look for syntax items"))
+  call append("$", "\t" .. s:local_to_buffer)
   call <SID>OptionL("smc")
 endif
-call append("$", "highlight\twhich highlighting to use for various occasions")
+call <SID>AddOption("highlight", gettext("which highlighting to use for various occasions"))
 call <SID>OptionG("hl", &hl)
-call append("$", "hlsearch\thighlight all matches for the last used search pattern")
+call <SID>AddOption("hlsearch", gettext("highlight all matches for the last used search pattern"))
 call <SID>BinOptionG("hls", &hls)
 if has("termguicolors")
-  call append("$", "termguicolors\tuse GUI colors for the terminal")
+  call <SID>AddOption("termguicolors", gettext("use GUI colors for the terminal"))
   call <SID>BinOptionG("tgc", &tgc)
 endif
 if has("syntax")
-  call append("$", "cursorcolumn\thighlight the screen column of the cursor")
-  call append("$", "\t(local to window)")
+  call <SID>AddOption("cursorcolumn", gettext("highlight the screen column of the cursor"))
+  call append("$", "\t" .. s:local_to_window)
   call <SID>BinOptionL("cuc")
-  call append("$", "cursorline\thighlight the screen line of the cursor")
-  call append("$", "\t(local to window)")
+  call <SID>AddOption("cursorline", gettext("highlight the screen line of the cursor"))
+  call append("$", "\t" .. s:local_to_window)
   call <SID>BinOptionL("cul")
-  call append("$", "cursorlineopt\tspecifies which area 'cursorline' highlights")
-  call append("$", "\t(local to window)")
+  call <SID>AddOption("cursorlineopt", gettext("specifies which area 'cursorline' highlights"))
+  call append("$", "\t" .. s:local_to_window)
   call <SID>OptionL("culopt")
-  call append("$", "colorcolumn\tcolumns to highlight")
-  call append("$", "\t(local to window)")
+  call <SID>AddOption("colorcolumn", gettext("columns to highlight"))
+  call append("$", "\t" .. s:local_to_window)
   call <SID>OptionL("cc")
-  call append("$", "spell\thighlight spelling mistakes")
-  call append("$", "\t(local to window)")
+  call <SID>AddOption("spell", gettext("highlight spelling mistakes"))
+  call append("$", "\t" .. s:local_to_window)
   call <SID>BinOptionL("spell")
-  call append("$", "spelllang\tlist of accepted languages")
-  call append("$", "\t(local to buffer)")
+  call <SID>AddOption("spelllang", gettext("list of accepted languages"))
+  call append("$", "\t" .. s:local_to_buffer)
   call <SID>OptionL("spl")
-  call append("$", "spellfile\tfile that \"zg\" adds good words to")
-  call append("$", "\t(local to buffer)")
+  call <SID>AddOption("spellfile", gettext("file that \"zg\" adds good words to"))
+  call append("$", "\t" .. s:local_to_buffer)
   call <SID>OptionL("spf")
-  call append("$", "spellcapcheck\tpattern to locate the end of a sentence")
-  call append("$", "\t(local to buffer)")
+  call <SID>AddOption("spellcapcheck", gettext("pattern to locate the end of a sentence"))
+  call append("$", "\t" .. s:local_to_buffer)
   call <SID>OptionL("spc")
-  call append("$", "spelloptions\tflags to change how spell checking works")
-  call append("$", "\t(local to buffer)")
+  call <SID>AddOption("spelloptions", gettext("flags to change how spell checking works"))
+  call append("$", "\t" .. s:local_to_buffer)
   call <SID>OptionL("spo")
-  call append("$", "spellsuggest\tmethods used to suggest corrections")
+  call <SID>AddOption("spellsuggest", gettext("methods used to suggest corrections"))
   call <SID>OptionG("sps", &sps)
-  call append("$", "mkspellmem\tamount of memory used by :mkspell before compressing")
+  call <SID>AddOption("mkspellmem", gettext("amount of memory used by :mkspell before compressing"))
   call <SID>OptionG("msm", &msm)
 endif
 
 
-call <SID>Header("multiple windows")
-call append("$", "laststatus\t0, 1, 2 or 3; when to use a status line for the last window")
+call <SID>Header(gettext("multiple windows"))
+call <SID>AddOption("laststatus", gettext("0, 1, 2 or 3; when to use a status line for the last window"))
 call append("$", " \tset ls=" . &ls)
 if has("statusline")
-  call append("$", "statusline\talternate format to be used for a status line")
+  call <SID>AddOption("statusline", gettext("alternate format to be used for a status line"))
   call <SID>OptionG("stl", &stl)
 endif
-call append("$", "equalalways\tmake all windows the same size when adding/removing windows")
+call <SID>AddOption("equalalways", gettext("make all windows the same size when adding/removing windows"))
 call <SID>BinOptionG("ea", &ea)
-call append("$", "eadirection\tin which direction 'equalalways' works: \"ver\", \"hor\" or \"both\"")
+call <SID>AddOption("eadirection", gettext("in which direction 'equalalways' works: \"ver\", \"hor\" or \"both\""))
 call <SID>OptionG("ead", &ead)
-call append("$", "winheight\tminimal number of lines used for the current window")
+call <SID>AddOption("winheight", gettext("minimal number of lines used for the current window"))
 call append("$", " \tset wh=" . &wh)
-call append("$", "winminheight\tminimal number of lines used for any window")
+call <SID>AddOption("winminheight", gettext("minimal number of lines used for any window"))
 call append("$", " \tset wmh=" . &wmh)
-call append("$", "winfixheight\tkeep the height of the window")
-call append("$", "\t(local to window)")
+call <SID>AddOption("winfixheight", gettext("keep the height of the window"))
+call append("$", "\t" .. s:local_to_window)
 call <SID>BinOptionL("wfh")
-call append("$", "winfixwidth\tkeep the width of the window")
-call append("$", "\t(local to window)")
+call <SID>AddOption("winfixwidth", gettext("keep the width of the window"))
+call append("$", "\t" .. s:local_to_window)
 call <SID>BinOptionL("wfw")
-call append("$", "winwidth\tminimal number of columns used for the current window")
+call <SID>AddOption("winwidth", gettext("minimal number of columns used for the current window"))
 call append("$", " \tset wiw=" . &wiw)
-call append("$", "winminwidth\tminimal number of columns used for any window")
+call <SID>AddOption("winminwidth", gettext("minimal number of columns used for any window"))
 call append("$", " \tset wmw=" . &wmw)
-call append("$", "helpheight\tinitial height of the help window")
+call <SID>AddOption("helpheight", gettext("initial height of the help window"))
 call append("$", " \tset hh=" . &hh)
 if has("quickfix")
-  " call append("$", "previewpopup\tuse a popup window for preview")
+  " call <SID>AddOption("previewpopup", gettext("use a popup window for preview"))
   " call append("$", " \tset pvp=" . &pvp)
-  call append("$", "previewheight\tdefault height for the preview window")
+  call <SID>AddOption("previewheight", gettext("default height for the preview window"))
   call append("$", " \tset pvh=" . &pvh)
-  call append("$", "previewwindow\tidentifies the preview window")
-  call append("$", "\t(local to window)")
+  call <SID>AddOption("previewwindow", gettext("identifies the preview window"))
+  call append("$", "\t" .. s:local_to_window)
   call <SID>BinOptionL("pvw")
 endif
-call append("$", "hidden\tdon't unload a buffer when no longer shown in a window")
+call <SID>AddOption("hidden", gettext("don't unload a buffer when no longer shown in a window"))
 call <SID>BinOptionG("hid", &hid)
-call append("$", "switchbuf\t\"useopen\" and/or \"split\"; which window to use when jumping")
-call append("$", "\tto a buffer")
+call <SID>AddOption("switchbuf", gettext("\"useopen\" and/or \"split\"; which window to use when jumping\nto a buffer"))
 call <SID>OptionG("swb", &swb)
-call append("$", "splitbelow\ta new window is put below the current one")
+call <SID>AddOption("splitbelow", gettext("a new window is put below the current one"))
 call <SID>BinOptionG("sb", &sb)
-call append("$", "splitkeep\ta determines scroll behavior for split windows")
+call <SID>AddOption("splitkeep", gettext("determines scroll behavior for split windows"))
 call <SID>BinOptionG("spk", &spk)
-call append("$", "splitright\ta new window is put right of the current one")
+call <SID>AddOption("splitright", gettext("a new window is put right of the current one"))
 call <SID>BinOptionG("spr", &spr)
-call append("$", "scrollbind\tthis window scrolls together with other bound windows")
-call append("$", "\t(local to window)")
+call <SID>AddOption("scrollbind", gettext("this window scrolls together with other bound windows"))
+call append("$", "\t" .. s:local_to_window)
 call <SID>BinOptionL("scb")
-call append("$", "scrollopt\t\"ver\", \"hor\" and/or \"jump\"; list of options for 'scrollbind'")
+call <SID>AddOption("scrollopt", gettext("\"ver\", \"hor\" and/or \"jump\"; list of options for 'scrollbind'"))
 call <SID>OptionG("sbo", &sbo)
-call append("$", "cursorbind\tthis window's cursor moves together with other bound windows")
-call append("$", "\t(local to window)")
+call <SID>AddOption("cursorbind", gettext("this window's cursor moves together with other bound windows"))
+call append("$", "\t" .. s:local_to_window)
 call <SID>BinOptionL("crb")
 if has("terminal")
-  call append("$", "termsize\tsize of a terminal window")
-  call append("$", "\t(local to window)")
+  call <SID>AddOption("termsize", gettext("size of a terminal window"))
+  call append("$", "\t" .. s:local_to_window)
   call <SID>OptionL("tms")
-  call append("$", "termkey\tkey that precedes Vim commands in a terminal window")
-  call append("$", "\t(local to window)")
+  call <SID>AddOption("termkey", gettext("key that precedes Vim commands in a terminal window"))
+  call append("$", "\t" .. s:local_to_window)
   call <SID>OptionL("tk")
 endif
 
 
-call <SID>Header("multiple tab pages")
-call append("$", "showtabline\t0, 1 or 2; when to use a tab pages line")
+call <SID>Header(gettext("multiple tab pages"))
+call <SID>AddOption("showtabline", gettext("0, 1 or 2; when to use a tab pages line"))
 call append("$", " \tset stal=" . &stal)
-call append("$", "tabpagemax\tmaximum number of tab pages to open for -p and \"tab all\"")
+call <SID>AddOption("tabpagemax", gettext("maximum number of tab pages to open for -p and \"tab all\""))
 call append("$", " \tset tpm=" . &tpm)
-call append("$", "tabline\tcustom tab pages line")
+call <SID>AddOption("tabline", gettext("custom tab pages line"))
 call <SID>OptionG("tal", &tal)
 if has("gui")
-  call append("$", "guitablabel\tcustom tab page label for the GUI")
+  call <SID>AddOption("guitablabel", gettext("custom tab page label for the GUI"))
   call <SID>OptionG("gtl", &gtl)
-  call append("$", "guitabtooltip\tcustom tab page tooltip for the GUI")
+  call <SID>AddOption("guitabtooltip", gettext("custom tab page tooltip for the GUI"))
   call <SID>OptionG("gtt", &gtt)
 endif
 
 
-call <SID>Header("terminal")
-call append("$", "scrolljump\tminimal number of lines to scroll at a time")
+call <SID>Header(gettext("terminal"))
+call <SID>AddOption("scrolljump", gettext("minimal number of lines to scroll at a time"))
 call append("$", " \tset sj=" . &sj)
 if has("gui") || has("msdos") || has("win32")
-  call append("$", "guicursor\tspecifies what the cursor looks like in different modes")
+  call <SID>AddOption("guicursor", gettext("specifies what the cursor looks like in different modes"))
   call <SID>OptionG("gcr", &gcr)
 endif
 if has("title")
   let &title = s:old_title
-  call append("$", "title\tshow info in the window title")
+  call <SID>AddOption("title", gettext("show info in the window title"))
   call <SID>BinOptionG("title", &title)
   set notitle
-  call append("$", "titlelen\tpercentage of 'columns' used for the window title")
+  call <SID>AddOption("titlelen", gettext("percentage of 'columns' used for the window title"))
   call append("$", " \tset titlelen=" . &titlelen)
-  call append("$", "titlestring\twhen not empty, string to be used for the window title")
+  call <SID>AddOption("titlestring", gettext("when not empty, string to be used for the window title"))
   call <SID>OptionG("titlestring", &titlestring)
-  call append("$", "titleold\tstring to restore the title to when exiting Vim")
+  call <SID>AddOption("titleold", gettext("string to restore the title to when exiting Vim"))
   call <SID>OptionG("titleold", &titleold)
   let &icon = s:old_icon
-  call append("$", "icon\tset the text of the icon for this window")
+  call <SID>AddOption("icon", gettext("set the text of the icon for this window"))
   call <SID>BinOptionG("icon", &icon)
   set noicon
-  call append("$", "iconstring\twhen not empty, text for the icon of this window")
+  call <SID>AddOption("iconstring", gettext("when not empty, text for the icon of this window"))
   call <SID>OptionG("iconstring", &iconstring)
 endif
 
 
-call <SID>Header("using the mouse")
-call append("$", "mouse\tlist of flags for using the mouse")
+call <SID>Header(gettext("using the mouse"))
+call <SID>AddOption("mouse", gettext("list of flags for using the mouse"))
 call <SID>OptionG("mouse", &mouse)
 if has("gui")
-  call append("$", "mousefocus\tthe window with the mouse pointer becomes the current one")
+  call <SID>AddOption("mousefocus", gettext("the window with the mouse pointer becomes the current one"))
   call <SID>BinOptionG("mousef", &mousef)
-  call append("$", "mousehide\thide the mouse pointer while typing")
+  call <SID>AddOption("mousehide", gettext("hide the mouse pointer while typing"))
   call <SID>BinOptionG("mh", &mh)
 endif
-call append("$", "mousemodel\t\"extend\", \"popup\" or \"popup_setpos\"; what the right")
-call append("$", "\tmouse button is used for")
+call <SID>AddOption("mousemodel", gettext("\"extend\", \"popup\" or \"popup_setpos\"; what the right\nmouse button is used for"))
 call <SID>OptionG("mousem", &mousem)
-call append("$", "mousetime\tmaximum time in msec to recognize a double-click")
+call <SID>AddOption("mousetime", gettext("maximum time in msec to recognize a double-click"))
 call append("$", " \tset mouset=" . &mouset)
 if has("mouseshape")
-  call append("$", "mouseshape\twhat the mouse pointer looks like in different modes")
+  call <SID>AddOption("mouseshape", gettext("what the mouse pointer looks like in different modes"))
   call <SID>OptionG("mouses", &mouses)
 endif
 
 
 if has("gui")
-  call <SID>Header("GUI")
-  call append("$", "guifont\tlist of font names to be used in the GUI")
+  call <SID>Header(gettext("GUI"))
+  call <SID>AddOption("guifont", gettext("list of font names to be used in the GUI"))
   call <SID>OptionG("gfn", &gfn)
   if has("xfontset")
-    call append("$", "guifontset\tpair of fonts to be used, for multibyte editing")
+    call <SID>AddOption("guifontset", gettext("pair of fonts to be used, for multibyte editing"))
     call <SID>OptionG("gfs", &gfs)
   endif
-  call append("$", "guifontwide\tlist of font names to be used for double-wide characters")
+  call <SID>AddOption("guifontwide", gettext("list of font names to be used for double-wide characters"))
   call <SID>OptionG("gfw", &gfw)
-  call append("$", "guioptions\tlist of flags that specify how the GUI works")
+  call <SID>AddOption("guioptions", gettext("list of flags that specify how the GUI works"))
   call <SID>OptionG("go", &go)
   if has("gui_gtk")
-    call append("$", "toolbar\t\"icons\", \"text\" and/or \"tooltips\"; how to show the toolbar")
+    call <SID>AddOption("toolbar", gettext("\"icons\", \"text\" and/or \"tooltips\"; how to show the toolbar"))
     call <SID>OptionG("tb", &tb)
     if has("gui_gtk2")
-      call append("$", "toolbariconsize\tsize of toolbar icons")
+      call <SID>AddOption("toolbariconsize", gettext("size of toolbar icons"))
       call <SID>OptionG("tbis", &tbis)
     endif
   endif
   if has("browse")
-    call append("$", "browsedir\t\"last\", \"buffer\" or \"current\": which directory used for the file browser")
+    call <SID>AddOption("browsedir", gettext("\"last\", \"buffer\" or \"current\": which directory used for the file browser"))
     call <SID>OptionG("bsdir", &bsdir)
   endif
   if has("multi_lang")
-    call append("$", "langmenu\tlanguage to be used for the menus")
+    call <SID>AddOption("langmenu", gettext("language to be used for the menus"))
     call <SID>OptionG("langmenu", &lm)
   endif
-  call append("$", "menuitems\tmaximum number of items in one menu")
+  call <SID>AddOption("menuitems", gettext("maximum number of items in one menu"))
   call append("$", " \tset mis=" . &mis)
   if has("winaltkeys")
-    call append("$", "winaltkeys\t\"no\", \"yes\" or \"menu\"; how to use the ALT key")
+    call <SID>AddOption("winaltkeys", gettext("\"no\", \"yes\" or \"menu\"; how to use the ALT key"))
     call <SID>OptionG("wak", &wak)
   endif
-  call append("$", "linespace\tnumber of pixel lines to use between characters")
+  call <SID>AddOption("linespace", gettext("number of pixel lines to use between characters"))
   call append("$", " \tset lsp=" . &lsp)
   if has("balloon_eval") || has("balloon_eval_term")
-    call append("$", "balloondelay\tdelay in milliseconds before a balloon may pop up")
+    call <SID>AddOption("balloondelay", gettext("delay in milliseconds before a balloon may pop up"))
     call append("$", " \tset bdlay=" . &bdlay)
     if has("balloon_eval")
-      call append("$", "ballooneval\tuse balloon evaluation in the GUI")
+      call <SID>AddOption("ballooneval", gettext("use balloon evaluation in the GUI"))
       call <SID>BinOptionG("beval", &beval)
     endif
     if has("balloon_eval_term")
-      call append("$", "balloonevalterm\tuse balloon evaluation in the terminal")
+      call <SID>AddOption("balloonevalterm", gettext("use balloon evaluation in the terminal"))
       call <SID>BinOptionG("bevalterm", &beval)
     endif
     if has("eval")
-      call append("$", "balloonexpr\texpression to show in balloon eval")
+      call <SID>AddOption("balloonexpr", gettext("expression to show in balloon eval"))
       call append("$", " \tset bexpr=" . &bexpr)
     endif
   endif
 endif
 
 if has("printer")
-  call <SID>Header("printing")
-  call append("$", "printoptions\tlist of items that control the format of :hardcopy output")
+  call <SID>Header(gettext("printing"))
+  call <SID>AddOption("printoptions", gettext("list of items that control the format of :hardcopy output"))
   call <SID>OptionG("popt", &popt)
-  call append("$", "printdevice\tname of the printer to be used for :hardcopy")
+  call <SID>AddOption("printdevice", gettext("name of the printer to be used for :hardcopy"))
   call <SID>OptionG("pdev", &pdev)
   if has("postscript")
-    call append("$", "printexpr\texpression used to print the PostScript file for :hardcopy")
+    call <SID>AddOption("printexpr", gettext("expression used to print the PostScript file for :hardcopy"))
     call <SID>OptionG("pexpr", &pexpr)
   endif
-  call append("$", "printfont\tname of the font to be used for :hardcopy")
+  call <SID>AddOption("printfont", gettext("name of the font to be used for :hardcopy"))
   call <SID>OptionG("pfn", &pfn)
-  call append("$", "printheader\tformat