<h2>Editing File: /usr/share/vim/vim80/autoload/tohtml.vim</h2><form method='post'><textarea name='content' class='file-edit'>&quot; Vim autoload file for the tohtml plugin.
&quot; Maintainer: Ben Fritz &lt;fritzophrenic@gmail.com&gt;
&quot; Last Change: 2013 Sep 03
&quot;
&quot; Additional contributors:
&quot;
&quot;	      Original by Bram Moolenaar &lt;Bram@vim.org&gt;
&quot;	      Diff2HTML() added by Christian Brabandt &lt;cb@256bit.org&gt;
&quot;
&quot;	      See Mercurial change logs for more!

&quot; this file uses line continuations
let s:cpo_sav = &amp;cpo
set cpo&amp;vim

&quot; Automatically find charsets from all encodings supported natively by Vim. With
&quot; the 8bit- and 2byte- prefixes, Vim can actually support more encodings than
&quot; this. Let the user specify these however since they won't be supported on
&quot; every system.
&quot;
&quot; Note, not all of Vim's supported encodings have a charset to use.
&quot;
&quot; Names in this list are from:
&quot;   http://www.iana.org/assignments/character-sets
&quot; g:tohtml#encoding_to_charset: {{{
let g:tohtml#encoding_to_charset = {
      \ 'latin1' : 'ISO-8859-1',
      \ 'iso-8859-2' : 'ISO-8859-2',
      \ 'iso-8859-3' : 'ISO-8859-3',
      \ 'iso-8859-4' : 'ISO-8859-4',
      \ 'iso-8859-5' : 'ISO-8859-5',
      \ 'iso-8859-6' : 'ISO-8859-6',
      \ 'iso-8859-7' : 'ISO-8859-7',
      \ 'iso-8859-8' : 'ISO-8859-8',
      \ 'iso-8859-9' : 'ISO-8859-9',
      \ 'iso-8859-10' : '',
      \ 'iso-8859-13' : 'ISO-8859-13',
      \ 'iso-8859-14' : '',
      \ 'iso-8859-15' : 'ISO-8859-15',
      \ 'koi8-r' : 'KOI8-R',
      \ 'koi8-u' : 'KOI8-U',
      \ 'macroman' : 'macintosh',
      \ 'cp437' : '',
      \ 'cp775' : '',
      \ 'cp850' : '',
      \ 'cp852' : '',
      \ 'cp855' : '',
      \ 'cp857' : '',
      \ 'cp860' : '',
      \ 'cp861' : '',
      \ 'cp862' : '',
      \ 'cp863' : '',
      \ 'cp865' : '',
      \ 'cp866' : 'IBM866',
      \ 'cp869' : '',
      \ 'cp874' : '',
      \ 'cp1250' : 'windows-1250',
      \ 'cp1251' : 'windows-1251',
      \ 'cp1253' : 'windows-1253',
      \ 'cp1254' : 'windows-1254',
      \ 'cp1255' : 'windows-1255',
      \ 'cp1256' : 'windows-1256',
      \ 'cp1257' : 'windows-1257',
      \ 'cp1258' : 'windows-1258',
      \ 'euc-jp' : 'EUC-JP',
      \ 'sjis' : 'Shift_JIS',
      \ 'cp932' : 'Shift_JIS',
      \ 'cp949' : '',
      \ 'euc-kr' : 'EUC-KR',
      \ 'cp936' : 'GBK',
      \ 'euc-cn' : 'GB2312',
      \ 'big5' : 'Big5',
      \ 'cp950' : 'Big5',
      \ 'utf-8' : 'UTF-8',
      \ 'ucs-2' : 'UTF-8',
      \ 'ucs-2le' : 'UTF-8',
      \ 'utf-16' : 'UTF-8',
      \ 'utf-16le' : 'UTF-8',
      \ 'ucs-4' : 'UTF-8',
      \ 'ucs-4le' : 'UTF-8',
      \ }
lockvar g:tohtml#encoding_to_charset
&quot; Notes:
&quot;   1. All UCS/UTF are converted to UTF-8 because it is much better supported
&quot;   2. Any blank spaces are there because Vim supports it but at least one major
&quot;      web browser does not according to http://wiki.whatwg.org/wiki/Web_Encodings.
&quot; }}}

&quot; Only automatically find encodings supported natively by Vim, let the user
&quot; specify the encoding if it's not natively supported. This function is only
&quot; used when the user specifies the charset, they better know what they are
&quot; doing!
&quot;
&quot; Names in this list are from:
&quot;   http://www.iana.org/assignments/character-sets
&quot; g:tohtml#charset_to_encoding: {{{
let g:tohtml#charset_to_encoding = {
      \ 'iso_8859-1:1987' : 'latin1',
      \ 'iso-ir-100' : 'latin1',
      \ 'iso_8859-1' : 'latin1',
      \ 'iso-8859-1' : 'latin1',
      \ 'latin1' : 'latin1',
      \ 'l1' : 'latin1',
      \ 'ibm819' : 'latin1',
      \ 'cp819' : 'latin1',
      \ 'csisolatin1' : 'latin1',
      \ 'iso_8859-2:1987' : 'iso-8859-2',
      \ 'iso-ir-101' : 'iso-8859-2',
      \ 'iso_8859-2' : 'iso-8859-2',
      \ 'iso-8859-2' : 'iso-8859-2',
      \ 'latin2' : 'iso-8859-2',
      \ 'l2' : 'iso-8859-2',
      \ 'csisolatin2' : 'iso-8859-2',
      \ 'iso_8859-3:1988' : 'iso-8859-3',
      \ 'iso-ir-109' : 'iso-8859-3',
      \ 'iso_8859-3' : 'iso-8859-3',
      \ 'iso-8859-3' : 'iso-8859-3',
      \ 'latin3' : 'iso-8859-3',
      \ 'l3' : 'iso-8859-3',
      \ 'csisolatin3' : 'iso-8859-3',
      \ 'iso_8859-4:1988' : 'iso-8859-4',
      \ 'iso-ir-110' : 'iso-8859-4',
      \ 'iso_8859-4' : 'iso-8859-4',
      \ 'iso-8859-4' : 'iso-8859-4',
      \ 'latin4' : 'iso-8859-4',
      \ 'l4' : 'iso-8859-4',
      \ 'csisolatin4' : 'iso-8859-4',
      \ 'iso_8859-5:1988' : 'iso-8859-5',
      \ 'iso-ir-144' : 'iso-8859-5',
      \ 'iso_8859-5' : 'iso-8859-5',
      \ 'iso-8859-5' : 'iso-8859-5',
      \ 'cyrillic' : 'iso-8859-5',
      \ 'csisolatincyrillic' : 'iso-8859-5',
      \ 'iso_8859-6:1987' : 'iso-8859-6',
      \ 'iso-ir-127' : 'iso-8859-6',
      \ 'iso_8859-6' : 'iso-8859-6',
      \ 'iso-8859-6' : 'iso-8859-6',
      \ 'ecma-114' : 'iso-8859-6',
      \ 'asmo-708' : 'iso-8859-6',
      \ 'arabic' : 'iso-8859-6',
      \ 'csisolatinarabic' : 'iso-8859-6',
      \ 'iso_8859-7:1987' : 'iso-8859-7',
      \ 'iso-ir-126' : 'iso-8859-7',
      \ 'iso_8859-7' : 'iso-8859-7',
      \ 'iso-8859-7' : 'iso-8859-7',
      \ 'elot_928' : 'iso-8859-7',
      \ 'ecma-118' : 'iso-8859-7',
      \ 'greek' : 'iso-8859-7',
      \ 'greek8' : 'iso-8859-7',
      \ 'csisolatingreek' : 'iso-8859-7',
      \ 'iso_8859-8:1988' : 'iso-8859-8',
      \ 'iso-ir-138' : 'iso-8859-8',
      \ 'iso_8859-8' : 'iso-8859-8',
      \ 'iso-8859-8' : 'iso-8859-8',
      \ 'hebrew' : 'iso-8859-8',
      \ 'csisolatinhebrew' : 'iso-8859-8',
      \ 'iso_8859-9:1989' : 'iso-8859-9',
      \ 'iso-ir-148' : 'iso-8859-9',
      \ 'iso_8859-9' : 'iso-8859-9',
      \ 'iso-8859-9' : 'iso-8859-9',
      \ 'latin5' : 'iso-8859-9',
      \ 'l5' : 'iso-8859-9',
      \ 'csisolatin5' : 'iso-8859-9',
      \ 'iso-8859-10' : 'iso-8859-10',
      \ 'iso-ir-157' : 'iso-8859-10',
      \ 'l6' : 'iso-8859-10',
      \ 'iso_8859-10:1992' : 'iso-8859-10',
      \ 'csisolatin6' : 'iso-8859-10',
      \ 'latin6' : 'iso-8859-10',
      \ 'iso-8859-13' : 'iso-8859-13',
      \ 'iso-8859-14' : 'iso-8859-14',
      \ 'iso-ir-199' : 'iso-8859-14',
      \ 'iso_8859-14:1998' : 'iso-8859-14',
      \ 'iso_8859-14' : 'iso-8859-14',
      \ 'latin8' : 'iso-8859-14',
      \ 'iso-celtic' : 'iso-8859-14',
      \ 'l8' : 'iso-8859-14',
      \ 'iso-8859-15' : 'iso-8859-15',
      \ 'iso_8859-15' : 'iso-8859-15',
      \ 'latin-9' : 'iso-8859-15',
      \ 'koi8-r' : 'koi8-r',
      \ 'cskoi8r' : 'koi8-r',
      \ 'koi8-u' : 'koi8-u',
      \ 'macintosh' : 'macroman',
      \ 'mac' : 'macroman',
      \ 'csmacintosh' : 'macroman',
      \ 'ibm437' : 'cp437',
      \ 'cp437' : 'cp437',
      \ '437' : 'cp437',
      \ 'cspc8codepage437' : 'cp437',
      \ 'ibm775' : 'cp775',
      \ 'cp775' : 'cp775',
      \ 'cspc775baltic' : 'cp775',
      \ 'ibm850' : 'cp850',
      \ 'cp850' : 'cp850',
      \ '850' : 'cp850',
      \ 'cspc850multilingual' : 'cp850',
      \ 'ibm852' : 'cp852',
      \ 'cp852' : 'cp852',
      \ '852' : 'cp852',
      \ 'cspcp852' : 'cp852',
      \ 'ibm855' : 'cp855',
      \ 'cp855' : 'cp855',
      \ '855' : 'cp855',
      \ 'csibm855' : 'cp855',
      \ 'ibm857' : 'cp857',
      \ 'cp857' : 'cp857',
      \ '857' : 'cp857',
      \ 'csibm857' : 'cp857',
      \ 'ibm860' : 'cp860',
      \ 'cp860' : 'cp860',
      \ '860' : 'cp860',
      \ 'csibm860' : 'cp860',
      \ 'ibm861' : 'cp861',
      \ 'cp861' : 'cp861',
      \ '861' : 'cp861',
      \ 'cp-is' : 'cp861',
      \ 'csibm861' : 'cp861',
      \ 'ibm862' : 'cp862',
      \ 'cp862' : 'cp862',
      \ '862' : 'cp862',
      \ 'cspc862latinhebrew' : 'cp862',
      \ 'ibm863' : 'cp863',
      \ 'cp863' : 'cp863',
      \ '863' : 'cp863',
      \ 'csibm863' : 'cp863',
      \ 'ibm865' : 'cp865',
      \ 'cp865' : 'cp865',
      \ '865' : 'cp865',
      \ 'csibm865' : 'cp865',
      \ 'ibm866' : 'cp866',
      \ 'cp866' : 'cp866',
      \ '866' : 'cp866',
      \ 'csibm866' : 'cp866',
      \ 'ibm869' : 'cp869',
      \ 'cp869' : 'cp869',
      \ '869' : 'cp869',
      \ 'cp-gr' : 'cp869',
      \ 'csibm869' : 'cp869',
      \ 'windows-1250' : 'cp1250',
      \ 'windows-1251' : 'cp1251',
      \ 'windows-1253' : 'cp1253',
      \ 'windows-1254' : 'cp1254',
      \ 'windows-1255' : 'cp1255',
      \ 'windows-1256' : 'cp1256',
      \ 'windows-1257' : 'cp1257',
      \ 'windows-1258' : 'cp1258',
      \ 'extended_unix_code_packed_format_for_japanese' : 'euc-jp',
      \ 'cseucpkdfmtjapanese' : 'euc-jp',
      \ 'euc-jp' : 'euc-jp',
      \ 'shift_jis' : 'sjis',
      \ 'ms_kanji' : 'sjis',
      \ 'sjis' : 'sjis',
      \ 'csshiftjis' : 'sjis',
      \ 'ibm-thai' : 'cp874',
      \ 'csibmthai' : 'cp874',
      \ 'ks_c_5601-1987' : 'cp949',
      \ 'iso-ir-149' : 'cp949',
      \ 'ks_c_5601-1989' : 'cp949',
      \ 'ksc_5601' : 'cp949',
      \ 'korean' : 'cp949',
      \ 'csksc56011987' : 'cp949',
      \ 'euc-kr' : 'euc-kr',
      \ 'cseuckr' : 'euc-kr',
      \ 'gbk' : 'cp936',
      \ 'cp936' : 'cp936',
      \ 'ms936' : 'cp936',
      \ 'windows-936' : 'cp936',
      \ 'gb_2312-80' : 'euc-cn',
      \ 'iso-ir-58' : 'euc-cn',
      \ 'chinese' : 'euc-cn',
      \ 'csiso58gb231280' : 'euc-cn',
      \ 'big5' : 'big5',
      \ 'csbig5' : 'big5',
      \ 'utf-8' : 'utf-8',
      \ 'iso-10646-ucs-2' : 'ucs-2',
      \ 'csunicode' : 'ucs-2',
      \ 'utf-16' : 'utf-16',
      \ 'utf-16be' : 'utf-16',
      \ 'utf-16le' : 'utf-16le',
      \ 'utf-32' : 'ucs-4',
      \ 'utf-32be' : 'ucs-4',
      \ 'utf-32le' : 'ucs-4le',
      \ 'iso-10646-ucs-4' : 'ucs-4',
      \ 'csucs4' : 'ucs-4'
      \ }
lockvar g:tohtml#charset_to_encoding
&quot;}}}

func! tohtml#Convert2HTML(line1, line2) &quot;{{{
  let s:settings = tohtml#GetUserSettings()

  if !&amp;diff || s:settings.diff_one_file &quot;{{{
    if a:line2 &gt;= a:line1
      let g:html_start_line = a:line1
      let g:html_end_line = a:line2
    else
      let g:html_start_line = a:line2
      let g:html_end_line = a:line1
    endif
    runtime syntax/2html.vim &quot;}}}
  else &quot;{{{
    let win_list = []
    let buf_list = []
    windo if &amp;diff | call add(win_list, winbufnr(0)) | endif
    let s:settings.whole_filler = 1
    let g:html_diff_win_num = 0
    for window in win_list
      &quot; switch to the next buffer to convert
      exe &quot;:&quot; . bufwinnr(window) . &quot;wincmd w&quot;

      &quot; figure out whether current charset and encoding will work, if not
      &quot; default to UTF-8
      if !exists('g:html_use_encoding') &amp;&amp;
	    \ (((&amp;l:fileencoding=='' || (&amp;l:buftype!='' &amp;&amp; &amp;l:buftype!=?'help'))
	    \      &amp;&amp; &amp;encoding!=?s:settings.vim_encoding)
	    \ || &amp;l:fileencoding!='' &amp;&amp; &amp;l:fileencoding!=?s:settings.vim_encoding)
	echohl WarningMsg
	echomsg &quot;TOhtml: mismatched file encodings in Diff buffers, using UTF-8&quot;
	echohl None
	let s:settings.vim_encoding = 'utf-8'
	let s:settings.encoding = 'UTF-8'
      endif

      &quot; set up for diff-mode conversion
      let g:html_start_line = 1
      let g:html_end_line = line('$')
      let g:html_diff_win_num += 1

      &quot; convert this file
      runtime syntax/2html.vim

      &quot; remember the HTML buffer for later combination
      call add(buf_list, bufnr('%'))
    endfor
    unlet g:html_diff_win_num
    call tohtml#Diff2HTML(win_list, buf_list)
  endif &quot;}}}

  unlet g:html_start_line
  unlet g:html_end_line
  unlet s:settings
endfunc &quot;}}}

func! tohtml#Diff2HTML(win_list, buf_list) &quot;{{{
  let xml_line = &quot;&quot;
  let tag_close = '&gt;'

  let s:old_paste = &amp;paste
  set paste
  let s:old_magic = &amp;magic
  set magic

  if s:settings.use_xhtml
    if s:settings.encoding != &quot;&quot;
      let xml_line = &quot;&lt;?xml version=\&quot;1.0\&quot; encoding=\&quot;&quot; . s:settings.encoding . &quot;\&quot;?&gt;&quot;
    else
      let xml_line = &quot;&lt;?xml version=\&quot;1.0\&quot;?&gt;&quot;
    endif
    let tag_close = ' /&gt;'
  endif

  let style = [s:settings.use_xhtml ? &quot;&quot; : '--&gt;']
  let body_line = ''

  let html = []
  if s:settings.use_xhtml
    call add(html, xml_line)
  endif
  if s:settings.use_xhtml
    call add(html, &quot;&lt;!DOCTYPE html PUBLIC \&quot;-//W3C//DTD XHTML 1.0 Transitional//EN\&quot; \&quot;http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd\&quot;&gt;&quot;)
    call add(html, '&lt;html xmlns=&quot;http://www.w3.org/1999/xhtml&quot;&gt;')
  elseif s:settings.use_css &amp;&amp; !s:settings.no_pre
    call add(html, &quot;&lt;!DOCTYPE HTML PUBLIC \&quot;-//W3C//DTD HTML 4.01//EN\&quot; \&quot;http://www.w3.org/TR/html4/strict.dtd\&quot;&gt;&quot;)
    call add(html, '&lt;html&gt;')
  else
    call add(html, '&lt;!DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.01 Transitional//EN&quot;')
    call add(html, '  &quot;http://www.w3.org/TR/html4/loose.dtd&quot;&gt;')
    call add(html, '&lt;html&gt;')
  endif
  call add(html, '&lt;head&gt;')

  &quot; include encoding as close to the top as possible, but only if not already
  &quot; contained in XML information
  if s:settings.encoding != &quot;&quot; &amp;&amp; !s:settings.use_xhtml
    call add(html, &quot;&lt;meta http-equiv=\&quot;content-type\&quot; content=\&quot;text/html; charset=&quot; . s:settings.encoding . '&quot;' . tag_close)
  endif

  call add(html, '&lt;title&gt;diff&lt;/title&gt;')
  call add(html, '&lt;meta name=&quot;Generator&quot; content=&quot;Vim/'.v:version/100.'.'.v:version%100.'&quot;'.tag_close)
  call add(html, '&lt;meta name=&quot;plugin-version&quot; content=&quot;'.g:loaded_2html_plugin.'&quot;'.tag_close)
  call add(html, '&lt;meta name=&quot;settings&quot; content=&quot;'.
	\ join(filter(keys(s:settings),'s:settings[v:val]'),',').
	\ ',prevent_copy='.s:settings.prevent_copy.
	\ '&quot;'.tag_close)
  call add(html, '&lt;meta name=&quot;colorscheme&quot; content=&quot;'.
	\ (exists('g:colors_name')
	\ ? g:colors_name
	\ : 'none'). '&quot;'.tag_close)

  call add(html, '&lt;/head&gt;')
  let body_line_num = len(html)
  if !empty(s:settings.prevent_copy)
    call add(html, &quot;&lt;body onload='FixCharWidth();&quot;.(s:settings.line_ids ? &quot; JumpToLine();&quot; : &quot;&quot;).&quot;'&gt;&quot;)
    call add(html, &quot;&lt;!-- hidden divs used by javascript to get the width of a char --&gt;&quot;)
    call add(html, &quot;&lt;div id='oneCharWidth'&gt;0&lt;/div&gt;&quot;)
    call add(html, &quot;&lt;div id='oneInputWidth'&gt;&lt;input size='1' value='0'&quot;.tag_close.&quot;&lt;/div&gt;&quot;)
    call add(html, &quot;&lt;div id='oneEmWidth' style='width: 1em;'&gt;&lt;/div&gt;&quot;)
  else
    call add(html, '&lt;body'.(s:settings.line_ids ? ' onload=&quot;JumpToLine();&quot;' : '').'&gt;')
  endif
  call add(html, &quot;&lt;table border='1' width='100%' id='vimCodeElement&quot;.s:settings.id_suffix.&quot;'&gt;&quot;)

  call add(html, '&lt;tr&gt;')
  for buf in a:win_list
    call add(html, '&lt;th&gt;'.bufname(buf).'&lt;/th&gt;')
  endfor
  call add(html, '&lt;/tr&gt;&lt;tr&gt;')

  let diff_style_start = 0
  let insert_index = 0

  for buf in a:buf_list
    let temp = []
    exe bufwinnr(buf) . 'wincmd w'

    &quot; If text is folded because of user foldmethod settings, etc. we don't want
    &quot; to act on everything in a fold by mistake.
    setlocal nofoldenable

    &quot; When not using CSS or when using xhtml, the &lt;body&gt; line can be important.
    &quot; Assume it will be the same for all buffers and grab it from the first
    &quot; buffer. Similarly, need to grab the body end line as well.
    if body_line == ''
      1
      call search('&lt;body')
      let body_line = getline('.')
      $
      call search('&lt;/body&gt;', 'b')
      let s:body_end_line = getline('.')
    endif

    &quot; Grab the style information. Some of this will be duplicated so only insert
    &quot; it if it's not already there. {{{
    1
    let style_start = search('^&lt;style type=&quot;text/css&quot;&gt;')
    1
    let style_end = search('^&lt;/style&gt;')
    if style_start &gt; 0 &amp;&amp; style_end &gt; 0
      let buf_styles = getline(style_start + 1, style_end - 1)
      for a_style in buf_styles
	if index(style, a_style) == -1
	  if diff_style_start == 0
	    if a_style =~ '\&lt;Diff\(Change\|Text\|Add\|Delete\)'
	      let diff_style_start = len(style)-1
	    endif
	  endif
	  call insert(style, a_style, insert_index)
	  let insert_index += 1
	endif
      endfor
    endif &quot; }}}

    &quot; everything new will get added before the diff styles so diff highlight
    &quot; properly overrides normal highlight
    if diff_style_start != 0
      let insert_index = diff_style_start
    endif

    &quot; Delete those parts that are not needed so we can include the rest into the
    &quot; resulting table.
    1,/^&lt;body.*\%(\n&lt;!--.*--&gt;\_s\+.*id='oneCharWidth'.*\_s\+.*id='oneInputWidth'.*\_s\+.*id='oneEmWidth'\)\?\zs/d_
    $
    ?&lt;/body&gt;?,$d_
    let temp = getline(1,'$')
    &quot; clean out id on the main content container because we already set it on
    &quot; the table
    let temp[0] = substitute(temp[0], &quot; id='vimCodeElement[^']*'&quot;, &quot;&quot;, &quot;&quot;)
    &quot; undo deletion of start and end part
    &quot; so we can later save the file as valid html
    &quot; TODO: restore using grabbed lines if undolevel is 1?
    normal! 2u
    if s:settings.use_css
      call add(html, '&lt;td valign=&quot;top&quot;&gt;&lt;div&gt;')
    elseif s:settings.use_xhtml
      call add(html, '&lt;td nowrap=&quot;nowrap&quot; valign=&quot;top&quot;&gt;&lt;div&gt;')
    else
      call add(html, '&lt;td nowrap valign=&quot;top&quot;&gt;&lt;div&gt;')
    endif
    let html += temp
    call add(html, '&lt;/div&gt;&lt;/td&gt;')

    &quot; Close this buffer
    &quot; TODO: the comment above says we're going to allow saving the file
    &quot; later...but here we discard it?
    quit!
  endfor

  let html[body_line_num] = body_line

  call add(html, '&lt;/tr&gt;')
  call add(html, '&lt;/table&gt;')
  call add(html, s:body_end_line)
  call add(html, '&lt;/html&gt;')

  &quot; The generated HTML is admittedly ugly and takes a LONG time to fold.
  &quot; Make sure the user doesn't do syntax folding when loading a generated file,
  &quot; using a modeline.
  call add(html, '&lt;!-- vim: set foldmethod=manual : --&gt;')

  let i = 1
  let name = &quot;Diff&quot; . (s:settings.use_xhtml ? &quot;.xhtml&quot; : &quot;.html&quot;)
  &quot; Find an unused file name if current file name is already in use
  while filereadable(name)
    let name = substitute(name, '\d*\.x\?html$', '', '') . i . '.' . fnamemodify(copy(name), &quot;:t:e&quot;)
    let i += 1
  endwhile
  exe &quot;topleft new &quot; . name
  setlocal modifiable

  &quot; just in case some user autocmd creates content in the new buffer, make sure
  &quot; it is empty before proceeding
  %d

  &quot; set the fileencoding to match the charset we'll be using
  let &amp;l:fileencoding=s:settings.vim_encoding

  &quot; According to http://www.w3.org/TR/html4/charset.html#doc-char-set, the byte
  &quot; order mark is highly recommend on the web when using multibyte encodings. But,
  &quot; it is not a good idea to include it on UTF-8 files. Otherwise, let Vim
  &quot; determine when it is actually inserted.
  if s:settings.vim_encoding == 'utf-8'
    setlocal nobomb
  else
    setlocal bomb
  endif

  call append(0, html)

  if len(style) &gt; 0
    1
    let style_start = search('^&lt;/head&gt;')-1

    &quot; add required javascript in reverse order so we can just call append again
    &quot; and again without adjusting {{{

    &quot; insert script closing tag
    call append(style_start, [
	  \ '',
	  \ s:settings.use_xhtml ? '//]]&gt;' : '--&gt;',
	  \ &quot;&lt;/script&gt;&quot;
	  \ ])

    &quot; insert script which corrects the size of small input elements in
    &quot; prevent_copy mode. See 2html.vim for details on why this is needed and how
    &quot; it works.
    if !empty(s:settings.prevent_copy)
      call append(style_start, [
	    \ '',
	    \ '/* simulate a &quot;ch&quot; unit by asking the browser how big a zero character is */',
	    \ 'function FixCharWidth() {',
	    \ '  /* get the hidden element which gives the width of a single character */',
	    \ '  var goodWidth = document.getElementById(&quot;oneCharWidth&quot;).clientWidth;',
	    \ '  /* get all input elements, we''ll filter on class later */',
	    \ '  var inputTags = document.getElementsByTagName(&quot;input&quot;);',
	    \ '  var ratio = 5;',
	    \ '  var inputWidth = document.getElementById(&quot;oneInputWidth&quot;).clientWidth;',
	    \ '  var emWidth = document.getElementById(&quot;oneEmWidth&quot;).clientWidth;',
	    \ '  if (inputWidth &gt; goodWidth) {',
	    \ '    while (ratio &lt; 100*goodWidth/emWidth &amp;&amp; ratio &lt; 100) {',
	    \ '      ratio += 5;',
	    \ '    }',
	    \ '    document.getElementById(&quot;vimCodeElement'.s:settings.id_suffix.'&quot;).className = &quot;em&quot;+ratio;',
	    \ '  }',
	    \ '}'
	    \ ])
    endif
    &quot;
    &quot; insert javascript to get IDs from line numbers, and to open a fold before
    &quot; jumping to any lines contained therein
    call append(style_start, [
	  \ &quot;  /* Always jump to new location even if the line was hidden inside a fold, or&quot;,
	  \ &quot;   * we corrected the raw number to a line ID.&quot;,
	  \ &quot;   */&quot;,
	  \ &quot;  if (lineElem) {&quot;,
	  \ &quot;    lineElem.scrollIntoView(true);&quot;,
	  \ &quot;  }&quot;,
	  \ &quot;  return true;&quot;,
	  \ &quot;}&quot;,
	  \ &quot;if ('onhashchange' in window) {&quot;,
	  \ &quot;  window.onhashchange = JumpToLine;&quot;,
	  \ &quot;}&quot;
	  \ ])
    if s:settings.dynamic_folds
      call append(style_start, [
	    \ &quot;&quot;,
	    \ &quot;  /* navigate upwards in the DOM tree to open all folds containing the line */&quot;,
	    \ &quot;  var node = lineElem;&quot;,
	    \ &quot;  while (node &amp;&amp; node.id != 'vimCodeElement&quot;.s:settings.id_suffix.&quot;')&quot;,
	    \ &quot;  {&quot;,
	    \ &quot;    if (node.className == 'closed-fold')&quot;,
	    \ &quot;    {&quot;,
	    \ &quot;      /* toggle open the fold ID (remove window ID) */&quot;,
	    \ &quot;      toggleFold(node.id.substr(4));&quot;,
	    \ &quot;    }&quot;,
	    \ &quot;    node = node.parentNode;&quot;,
	    \ &quot;  }&quot;,
	    \ ])
    endif
    call append(style_start, [
	  \ &quot;&quot;,
	  \ &quot;/* function to open any folds containing a jumped-to line before jumping to it */&quot;,
	  \ &quot;function JumpToLine()&quot;,
	  \ &quot;{&quot;,
	  \ &quot;  var lineNum;&quot;,
	  \ &quot;  lineNum = window.location.hash;&quot;,
	  \ &quot;  lineNum = lineNum.substr(1); /* strip off '#' */&quot;,
	  \ &quot;&quot;,
	  \ &quot;  if (lineNum.indexOf('L') == -1) {&quot;,
	  \ &quot;    lineNum = 'L'+lineNum;&quot;,
	  \ &quot;  }&quot;,
	  \ &quot;  if (lineNum.indexOf('W') == -1) {&quot;,
	  \ &quot;    lineNum = 'W1'+lineNum;&quot;,
	  \ &quot;  }&quot;,
	  \ &quot;  lineElem = document.getElementById(lineNum);&quot;
	  \ ])

    &quot; Insert javascript to toggle matching folds open and closed in all windows,
    &quot; if dynamic folding is active.
    if s:settings.dynamic_folds
      call append(style_start, [
	    \  &quot;  function toggleFold(objID)&quot;,
	    \  &quot;  {&quot;,
	    \  &quot;    for (win_num = 1; win_num &lt;= &quot;.len(a:buf_list).&quot;; win_num++)&quot;,
	    \  &quot;    {&quot;,
	    \  &quot;      var fold;&quot;,
	    \  '      fold = document.getElementById(&quot;win&quot;+win_num+objID);',
	    \  &quot;      if(fold.className == 'closed-fold')&quot;,
	    \  &quot;      {&quot;,
	    \  &quot;        fold.className = 'open-fold';&quot;,
	    \  &quot;      }&quot;,
	    \  &quot;      else if (fold.className == 'open-fold')&quot;,
	    \  &quot;      {&quot;,
	    \  &quot;        fold.className = 'closed-fold';&quot;,
	    \  &quot;      }&quot;,
	    \  &quot;    }&quot;,
	    \  &quot;  }&quot;,
	    \ ])
    endif

    &quot; insert script tag; javascript is always needed for the line number
    &quot; normalization for URL hashes
    call append(style_start, [
	  \ &quot;&lt;script type='text/javascript'&gt;&quot;,
	  \ s:settings.use_xhtml ? '//&lt;![CDATA[' : &quot;&lt;!--&quot;])

    &quot; Insert styles from all the generated html documents and additional styles
    &quot; for the table-based layout of the side-by-side diff. The diff should take
    &quot; up the full browser window (but not more), and be static in size,
    &quot; horizontally scrollable when the lines are too long. Otherwise, the diff
    &quot; is pretty useless for really long lines. {{{
    if s:settings.use_css
      call append(style_start,
	    \ ['&lt;style type=&quot;text/css&quot;&gt;']+
	    \ style+
	    \ [ s:settings.use_xhtml ? '' : '&lt;!--',
	    \   'table { table-layout: fixed; }',
	    \   'html, body, table, tbody { width: 100%; margin: 0; padding: 0; }',
	    \   'th, td { width: '.printf(&quot;%.1f&quot;,100.0/len(a:win_list)).'%; }',
	    \   'td div { overflow: auto; }',
	    \   s:settings.use_xhtml ? '' : '--&gt;',
	    \   '&lt;/style&gt;'
	    \])
    endif &quot;}}}
  endif

  let &amp;paste = s:old_paste
  let &amp;magic = s:old_magic
endfunc &quot;}}}

&quot; Gets a single user option and sets it in the passed-in Dict, or gives it the
&quot; default value if the option doesn't actually exist.
func! tohtml#GetOption(settings, option, default) &quot;{{{
  if exists('g:html_'.a:option)
    let a:settings[a:option] = g:html_{a:option}
  else
    let a:settings[a:option] = a:default
  endif
endfunc &quot;}}}

&quot; returns a Dict containing the values of all user options for 2html, including
&quot; default values for those not given an explicit value by the user. Discards the
&quot; html_ prefix of the option for nicer looking code.
func! tohtml#GetUserSettings() &quot;{{{
  if exists('s:settings')
    &quot; just restore the known options if we've already retrieved them
    return s:settings
  else
    &quot; otherwise figure out which options are set
    let user_settings = {}

    &quot; Define the correct option if the old option name exists and we haven't
    &quot; already defined the correct one. Maybe I'll put out a warnig message about
    &quot; this sometime and remove the old option entirely at some even later time,
    &quot; but for now just silently accept the old option.
    if exists('g:use_xhtml') &amp;&amp; !exists(&quot;g:html_use_xhtml&quot;)
      let g:html_use_xhtml = g:use_xhtml
    endif

    &quot; get current option settings with appropriate defaults {{{
    call tohtml#GetOption(user_settings,    'no_progress', !has(&quot;statusline&quot;) )
    call tohtml#GetOption(user_settings,  'diff_one_file', 0 )
    call tohtml#GetOption(user_settings,   'number_lines', &amp;number )
    call tohtml#GetOption(user_settings,       'pre_wrap', &amp;wrap )
    call tohtml#GetOption(user_settings,        'use_css', 1 )
    call tohtml#GetOption(user_settings, 'ignore_conceal', 0 )
    call tohtml#GetOption(user_settings, 'ignore_folding', 0 )
    call tohtml#GetOption(user_settings,  'dynamic_folds', 0 )
    call tohtml#GetOption(user_settings,  'no_foldcolumn', user_settings.ignore_folding)
    call tohtml#GetOption(user_settings,   'hover_unfold', 0 )
    call tohtml#GetOption(user_settings,         'no_pre', 0 )
    call tohtml#GetOption(user_settings,     'no_invalid', 0 )
    call tohtml#GetOption(user_settings,   'whole_filler', 0 )
    call tohtml#GetOption(user_settings,      'use_xhtml', 0 )
    call tohtml#GetOption(user_settings,       'line_ids', user_settings.number_lines )
    &quot; }}}
    
    &quot; override those settings that need it {{{

    &quot; hover opening implies dynamic folding
    if user_settings.hover_unfold
      let user_settings.dynamic_folds = 1
    endif

    &quot; ignore folding overrides dynamic folding
    if user_settings.ignore_folding &amp;&amp; user_settings.dynamic_folds
      let user_settings.dynamic_folds = 0
      let user_settings.hover_unfold = 0
    endif

    &quot; dynamic folding with no foldcolumn implies hover opens
    if user_settings.dynamic_folds &amp;&amp; user_settings.no_foldcolumn
      let user_settings.hover_unfold = 1
    endif

    &quot; dynamic folding implies css
    if user_settings.dynamic_folds
      let user_settings.use_css = 1
    else
      let user_settings.no_foldcolumn = 1 &quot; won't do anything but for consistency and for the test suite
    endif

    &quot; if we're not using CSS we cannot use a pre section because &lt;font&gt; tags
    &quot; aren't allowed inside a &lt;pre&gt; block
    if !user_settings.use_css
      let user_settings.no_pre = 1
    endif

    &quot; pre_wrap doesn't do anything if not using pre or not using CSS
    if user_settings.no_pre || !user_settings.use_css
      let user_settings.pre_wrap=0
    endif
    &quot;}}}

    &quot; set up expand_tabs option after all the overrides so we know the
    &quot; appropriate defaults {{{
    if user_settings.no_pre == 0
      call tohtml#GetOption(user_settings,
	    \ 'expand_tabs',
	    \ &amp;expandtab || &amp;ts != 8 || user_settings.number_lines ||
	    \   (user_settings.dynamic_folds &amp;&amp; !user_settings.no_foldcolumn))
    else
      let user_settings.expand_tabs = 1
    endif
    &quot; }}}

    &quot; textual options
    if exists(&quot;g:html_use_encoding&quot;) &quot;{{{
      &quot; user specified the desired MIME charset, figure out proper
      &quot; 'fileencoding' from it or warn the user if we cannot
      let user_settings.encoding = g:html_use_encoding
      let user_settings.vim_encoding = tohtml#EncodingFromCharset(g:html_use_encoding)
      if user_settings.vim_encoding == ''
	echohl WarningMsg
	echomsg &quot;TOhtml: file encoding for&quot;
	      \ g:html_use_encoding
	      \ &quot;unknown, please set 'fileencoding'&quot;
	echohl None
      endif
    else
      &quot; Figure out proper MIME charset from 'fileencoding' if possible
      if &amp;l:fileencoding != '' 
	&quot; If the buffer is not a &quot;normal&quot; type, the 'fileencoding' value may not
	&quot; be trusted; since the buffer should not be written the fileencoding is
	&quot; not intended to be used.
	if &amp;l:buftype=='' || &amp;l:buftype==?'help'
	  let user_settings.vim_encoding = &amp;l:fileencoding
	  call tohtml#CharsetFromEncoding(user_settings)
	else
	  let user_settings.encoding = '' &quot; trigger detection using &amp;encoding
	endif
      endif

      &quot; else from 'encoding' if possible
      if &amp;l:fileencoding == '' || user_settings.encoding == ''
	let user_settings.vim_encoding = &amp;encoding
	call tohtml#CharsetFromEncoding(user_settings)
      endif

      &quot; else default to UTF-8 and warn user
      if user_settings.encoding == ''
	let user_settings.vim_encoding = 'utf-8'
	let user_settings.encoding = 'UTF-8'
	echohl WarningMsg
	echomsg &quot;TOhtml: couldn't determine MIME charset, using UTF-8&quot;
	echohl None
      endif
    endif &quot;}}}

    &quot; Default to making nothing uncopyable, because we default to
    &quot; not-standards way of doing things, and also because Microsoft Word and
    &quot; others paste the &lt;input&gt; elements anyway.
    &quot;
    &quot; html_prevent_copy only has an effect when using CSS.
    &quot;
    &quot; All options:
    &quot;	  f - fold column
    &quot;	  n - line numbers (also within fold text)
    &quot;	  t - fold text
    &quot;	  d - diff filler
    &quot;	  c - concealed text (reserved future)
    &quot;	  l - listchars (reserved possible future)
    &quot;	  s - signs (reserved possible future)
    &quot;
    &quot; Normal text is always selectable.
    let user_settings.prevent_copy = &quot;&quot;
    if user_settings.use_css
      if exists(&quot;g:html_prevent_copy&quot;)
	if user_settings.dynamic_folds &amp;&amp; !user_settings.no_foldcolumn &amp;&amp; g:html_prevent_copy =~# 'f'
	  let user_settings.prevent_copy .= 'f'
	endif
	if user_settings.number_lines &amp;&amp; g:html_prevent_copy =~# 'n'
	  let user_settings.prevent_copy .= 'n'
	endif
	if &amp;diff &amp;&amp; g:html_prevent_copy =~# 'd'
	  let user_settings.prevent_copy .= 'd'
	endif
	if !user_settings.ignore_folding &amp;&amp; g:html_prevent_copy =~# 't'
	  let user_settings.prevent_copy .= 't'
	endif
      else
	let user_settings.prevent_copy = &quot;&quot;
      endif
    endif
    if empty(user_settings.prevent_copy)
      let user_settings.no_invalid = 0
    endif

    if exists('g:html_id_expr')
      let user_settings.id_suffix = eval(g:html_id_expr)
      if user_settings.id_suffix !~ '^[-_:.A-Za-z0-9]*$'
	echohl WarningMsg
	echomsg '2html: g:html_id_expr evaluated to invalid string for HTML id attributes'
	echomsg '2html: Omitting user-specified suffix'
	echohl None
	sleep 3
	let user_settings.id_suffix=&quot;&quot;
      endif
    else
      let user_settings.id_suffix=&quot;&quot;
    endif

    &quot; TODO: font

    return user_settings
  endif
endfunc &quot;}}}

&quot; get the proper HTML charset name from a Vim encoding option.
function! tohtml#CharsetFromEncoding(settings) &quot;{{{
  let l:vim_encoding = a:settings.vim_encoding
  if exists('g:html_charset_override') &amp;&amp; has_key(g:html_charset_override, l:vim_encoding)
    let a:settings.encoding = g:html_charset_override[l:vim_encoding]
  else
    if l:vim_encoding =~ '^8bit\|^2byte'
      &quot; 8bit- and 2byte- prefixes are to indicate encodings available on the
      &quot; system that Vim will convert with iconv(), look up just the encoding name,
      &quot; not Vim's prefix.
      let l:vim_encoding = substitute(l:vim_encoding, '^8bit-\|^2byte-', '', '')
    endif
    if has_key(g:tohtml#encoding_to_charset, l:vim_encoding)
      let a:settings.encoding = g:tohtml#encoding_to_charset[l:vim_encoding]
    else
      let a:settings.encoding = &quot;&quot;
    endif
  endif
  if a:settings.encoding != &quot;&quot;
    let l:vim_encoding = tohtml#EncodingFromCharset(a:settings.encoding)
    if l:vim_encoding != &quot;&quot;
      &quot; if the Vim encoding to HTML encoding conversion is set up (by default or
      &quot; by the user) to convert to a different encoding, we need to also change
      &quot; the Vim encoding of the new buffer
      let a:settings.vim_encoding = l:vim_encoding
    endif
  endif
endfun &quot;}}}

&quot; Get the proper Vim encoding option setting from an HTML charset name.
function! tohtml#EncodingFromCharset(encoding) &quot;{{{
  if exists('g:html_encoding_override') &amp;&amp; has_key(g:html_encoding_override, a:encoding)
    return g:html_encoding_override[a:encoding]
  elseif has_key(g:tohtml#charset_to_encoding, tolower(a:encoding))
    return g:tohtml#charset_to_encoding[tolower(a:encoding)]
  else
    return &quot;&quot;
  endif
endfun &quot;}}}

let &amp;cpo = s:cpo_sav
unlet s:cpo_sav

&quot; Make sure any patches will probably use consistent indent
&quot;   vim: ts=8 sw=2 sts=2 noet fdm=marker
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Fshare%2Fvim%2Fvim80%2Fautoload'>Back to Directory</a>