vim syntax file

vim.vim

" Vim reduced (and faster) syntax file
" Language:          Vim 8.1 script
" Edits By:          Gianmaria Bajo <mg1979@git.gmail.com>
" Base File Author:  Charles E. Campbell <NdrOchipS@PcampbellAfamily.Mbiz>
" Base File Version: 8.0-20
" Base File URL:     http://www.drchip.org/astronaut/vim/index.html#SYNTAX_VIM

if exists("b:current_syntax")
  finish
endif

let s:keepcpo= &cpo
set cpo&vim

" Variable options

if exists("g:vim_maxlines")
 let s:vimsyn_maxlines= g:vim_maxlines
else
 let s:vimsyn_maxlines= 60
endif

" Keywords, commands, options {{{1
syn keyword vimLet         let unlet skipwhite nextgroup=vimVar,vimScope
syn keyword vimFuncDecl    fu[nction] endf[unction] skipwhite nextgroup=vimFuncDef,vimComment
syn match   vimFuncDef     '.*' contains=vimNotation,vimComment,vimParenSep,vimOperParen contained
syn keyword vimSelf        self
syn keyword vimReturn      retu[rn] skipwhite nextgroup=vimScope,vimVar,vimFunc,vimComment

syn keyword vimConditional if el[se] elsei[f] en[dif] skipwhite nextgroup=vimScope,vimVar,vimFunc,vimComment,vimExclam
syn keyword vimRepeat      wh[ile] for in endw[hile] endfo[r] skipwhite nextgroup=vimScope,vimVar,vimFunc,vimComment,vimExclam
syn keyword vimException   try catch fina[lly] endt[ry]

" vimTodo: contains common special-notices for comments
" Use the vimTodoGroup cluster to add your own.
syn keyword vimTodo contained COMBAK  FIXME TODO  XXX
syn cluster vimTodoGroup contains=vimTodo,@Spell

" regular vim commands
if !exists("g:vimsyn_no_abbreviated_commands") || g:vimsyn_no_abbreviated_commands
  syn keyword vimCommand contained append abclear aboveleft all args argadd argdelete argdo argedit argglobal arglocal argument ascii buffer bNext ball badd bdelete belowright bfirst blast bmodified bnext botright bprevious brewind break breakadd breakdel breaklist browse buffers bufdo bunload bwipeout change cNext cNfile cabclear caddbuffer caddexpr caddfile cbuffer cbottom cc cclose cd cdo center cexpr cfile cfdo cfirst cgetfile cgetbuffer cgetexpr chdir changes checkpath checktime chistory clist clast close clearjumps cnext cnewer cnfile copy colder colorscheme command comclear compiler continue confirm copen
  syn keyword vimCommand contained cprevious cpfile cquit crewind cscope cstag cunabbrev cwindow delete delmarks debug debuggreedy delcommand delfunction display diffupdate diffget diffoff diffpatch diffput diffsplit diffthis digraphs djump dlist drop dsearch dsplit edit earlier emenu enew ex[ecute] exit exusage file files filter find finish first fixdel fold foldclose folddoopen folddoclosed foldopen global goto grep grepadd gui gvim help helpclose helpfind helpgrep helptags hardcopy hide history insert iabclear ijump
  syn keyword vimCommand contained ilist intro isearch isplit iunabbrev join jumps keepmarks keepjumps keeppatterns keepalt list lNext lNfile last language laddexpr laddbuffer laddfile later lbuffer lbottom lcd lchdir lclose lcscope ldo left leftabove lexpr lfile lfdo lfirst lgetfile lgetbuffer lgetexpr lgrep lgrepadd lhelpgrep lhistory ll llast llist lmake lnext lnewer lnfile loadview loadkeymap lockmarks lockvar lolder lopen lprevious lpfile lrewind ltag lua luado luafile lvimgrep lvimgrepadd lwindow ls move mark make marks match menutranslate messages mkexrc mksession mkspell mkvimrc mkview mode mzscheme mzfile
  syn keyword vimCommand contained next nbkey nbclose nbstart new noautocmd nohlsearch noswapfile number open oldfiles only options ownsyntax print packadd packloadall pclose perl perldo pedit pop popup ppop preserve previous promptfind promptrepl profile profdel psearch ptag ptNext ptfirst ptjump ptlast ptnext ptprevious ptrewind ptselect put pwd python pydo pyfile py3 py3do python3 py3file pyx pyxdo pythonx pyxfile quit quitall qall read recover redo redir redraw redrawstatus redrawtabline registers resize retab rewind right rightbelow runtime ruby rubydo rubyfile rundo rviminfo sNext sargument sall sandbox
  syn keyword vimCommand contained saveas sbuffer sbNext sball sbfirst sblast sbmodified sbnext sbprevious sbrewind scriptnames scriptencoding scscope setfiletype sfind sfirst shell simalt sign silent sleep slast snext source sort split spellgood spelldump spellinfo spellrepall spellundo spellwrong sprevious srewind stop stag startinsert startgreplace startreplace stopinsert stjump stselect sunhide suspend sview swapname syntime syncbind smile tNext tag tags tab tabclose tabdo tabedit tabfind tabfirst tabmove tablast tabnext tabnew tabonly tabprevious tabNext tabrewind tabs tcd tcl tcldo tclfile tearoff terminal tfirst throw tjump
  syn keyword vimCommand contained tlast tlmenu tlnoremenu tlunmenu tmenu tmap tmapclear tnext tnoremap topleft tprevious trewind tselect tunmenu tunmap undo undojoin undolist unabbreviate unhide unlockvar unsilent update vglobal version verbose vertical visual view vimgrep vimgrepadd viusage vnew vsplit write wNext wall winsize wincmd windo winpos wnext wprevious wq wqall wundo wviminfo xit xall yank Next Print X
  syn keyword vimCommand contained filetype

else
  syn keyword vimCommand contained a[ppend] abc[lear] abo[veleft] al[l] ar[gs] arga[dd] argd[elete] argdo arge[dit] argg[lobal] argl[ocal] argu[ment] as[cii] b[uffer] bN[ext] ba[ll] bad[d] bd[elete] bel[owright] bf[irst] bl[ast] bm[odified] bn[ext] bo[tright] bp[revious] br[ewind] brea[k] breaka[dd] breakd[el] breakl[ist] bro[wse] buffers bufd[o] bun[load] bw[ipeout] c[hange] cN[ext] cNf[ile] cabc[lear] cad[dbuffer] cadde[xpr] caddf[ile] cat[ch] cb[uffer] cbo[ttom] cc ccl[ose] cd cdo ce[nter] cex[pr] cf[ile] cfd[o] cfir[st] cg[etfile] cgetb[uffer] cgete[xpr] chd[ir] changes che[ckpath] checkt[ime] chi[story] cl[ist] cla[st] clo[se] cle[arjumps] cn[ext] cnew[er] cnf[ile] co[py] col[der] colo[rscheme] com[mand] comc[lear] comp[iler] con[tinue] conf[irm] cope[n]
  syn keyword vimCommand contained cp[revious] cpf[ile] cq[uit] cr[ewind] cs[cope] cst[ag] cuna[bbrev] cw[indow] d[elete] delm[arks] deb[ug] debugg[reedy] delc[ommand] delf[unction] di[splay] dif[fupdate] diffg[et] diffo[ff] diffp[atch] diffpu[t] diffs[plit] difft[his] dig[raphs] dj[ump] dli[st] dr[op] ds[earch] dsp[lit] e[dit] ea[rlier] em[enu] ene[w] ex[ecute] exi[t] exu[sage] f[ile] files filt[er] fin[d] fini[sh] fir[st] fix[del] fo[ld] foldc[lose] foldd[oopen] folddoc[losed] foldo[pen] g[lobal] go[to] gr[ep] grepa[dd] gu[i] gv[im] h[elp] helpc[lose] helpf[ind] helpg[rep] helpt[ags] ha[rdcopy] hid[e] his[tory] i[nsert] iabc[lear] ij[ump]
  syn keyword vimCommand contained il[ist] int[ro] is[earch] isp[lit] iuna[bbrev] j[oin] ju[mps] k kee[pmarks] keepj[umps] keepp[atterns] keepa[lt] l[ist] lN[ext] lNf[ile] la[st] lan[guage] lad[dexpr] laddb[uffer] laddf[ile] lat[er] lb[uffer] lbo[ttom] lc[d] lch[dir] lcl[ose] lcs[cope] ld[o] le[ft] lefta[bove] lex[pr] lf[ile] lfd[o] lfir[st] lg[etfile] lgetb[uffer] lgete[xpr] lgr[ep] lgrepa[dd] lh[elpgrep] lhi[story] ll lla[st] lli[st] lmak[e] lne[xt] lnew[er] lnf[ile] lo[adview] loadk[eymap] loc[kmarks] lockv[ar] lol[der] lop[en] lp[revious] lpf[ile] lr[ewind] lt[ag] lua luad[o] luaf[ile] lv[imgrep] lvimgrepa[dd] lw[indow] ls m[ove] ma[rk] mak[e] marks mat[ch] menut[ranslate] mes[sages] mk[exrc] mks[ession] mksp[ell] mkv[imrc] mkvie[w] mod[e] mz[scheme] mzf[ile]
  syn keyword vimCommand contained n[ext] nb[key] nbc[lose] nbs[tart] new noa[utocmd] noh[lsearch] nos[wapfile] nu[mber] o[pen] ol[dfiles] on[ly] opt[ions] ow[nsyntax] p[rint] pa[ckadd] packl[oadall] pc[lose] pe[rl] perld[o] ped[it] po[p] popu[p] pp[op] pre[serve] prev[ious] pro[mptfind] promptr[epl] prof[ile] profd[el] ps[earch] pt[ag] ptN[ext] ptf[irst] ptj[ump] ptl[ast] ptn[ext] ptp[revious] ptr[ewind] pts[elect] pu[t] pw[d] py[thon] pyd[o] pyf[ile] py3 py3d[o] python3 py3f[ile] pyx pyxd[o] pythonx pyxf[ile] q[uit] quita[ll] qa[ll] r[ead] rec[over] red[o] redi[r] redr[aw] redraws[tatus] redrawt[abline] reg[isters] res[ize] ret[ab] retu[rn] rew[ind] ri[ght] rightb[elow] ru[ntime] rub[y] rubyd[o] rubyf[ile] rund[o] rv[iminfo] sN[ext] sa[rgument] sal[l] san[dbox]
  syn keyword vimCommand contained sav[eas] sb[uffer] sbN[ext] sba[ll] sbf[irst] sbl[ast] sbm[odified] sbn[ext] sbp[revious] sbr[ewind] sc[riptnames] scripte[ncoding] scs[cope] setf[iletype] sf[ind] sfir[st] sh[ell] si[malt] sig[n] sil[ent] sl[eep] sla[st] sn[ext] so[urce] sor[t] sp[lit] spe[llgood] spelld[ump] spelli[nfo] spellr[epall] spellu[ndo] spellw[rong] spr[evious] sr[ewind] st[op] sta[g] star[tinsert] startg[replace] startr[eplace] stopi[nsert] stj[ump] sts[elect] sun[hide] sus[pend] sv[iew] sw[apname] synti[me] sync[bind] smi[le] t tN[ext] ta[g] tags tab tabc[lose] tabd[o] tabe[dit] tabf[ind] tabfir[st] tabm[ove] tabl[ast] tabn[ext] tabnew tabo[nly] tabp[revious] tabN[ext] tabr[ewind] tabs tc[l] tcld[o] tclf[ile] te[aroff] ter[minal] tf[irst] th[row] tj[ump]
  syn keyword vimCommand contained tl[ast] tlm[enu] tln[oremenu] tlu[nmenu] tm[enu] tma[p] tmapc[lear] tn[ext] tno[remap] to[pleft] tp[revious] tr[ewind] ts[elect] tu[nmenu] tunma[p] u[ndo] undoj[oin] undol[ist] una[bbreviate] unh[ide] unlo[ckvar] uns[ilent] up[date] v[global] ve[rsion] verb[ose] vert[ical] vi[sual] vie[w] vim[grep] vimgrepa[dd] viu[sage] vne[w] vs[plit] w[rite] wN[ext] wa[ll] wi[nsize] winc[md] wind[o] winp[os] wn[ext] wp[revious] wq wqa[ll] wu[ndo] wv[iminfo] x[it] xa[ll] y[ank] z N[ext] P[rint] X dl dell delel deletl deletel dp dep delp delep deletp deletep
  syn match   vimCommand contained  "\<z[-+^.=]\=\>"
  syn keyword vimCommand contained filet[ype]

endif

syn keyword vimStdPlugin contained  Arguments Break Clear Continue DiffOrig Evaluate Finish Gdb Man Over Program Run S Source Step Stop Termdebug TermdebugCommand TOhtml Winbar XMLent XMLns

" vimOptions are caught only when contained in a vimSet
syn keyword vimOption contained al aleph anti antialias arab arabic arshape arabicshape ari allowrevins ambw ambiwidth acd autochdir ai autoindent ar autoread aw autowrite awa autowriteall bg background bs backspace bk backup bkc backupcopy bdir backupdir bex backupext bsk backupskip bdlay balloondelay beval ballooneval bevalterm balloonevalterm bexpr balloonexpr bo belloff bin binary bomb brk breakat bri breakindent briopt breakindentopt bsdir browsedir bh bufhidden bl buflisted bt buftype cmp casemap cd cdpath cedit ccv charconvert cin cindent cink cinkeys cino cinoptions cinw cinwords cb clipboard ch cmdheight cwh cmdwinheight cc colorcolumn co columns com comments cms commentstring cp compatible cpt complete cocu concealcursor cole conceallevel cfu completefunc
syn keyword vimOption contained cot completeopt cf confirm ci copyindent cpo cpoptions cm cryptmethod cspc cscopepathcomp csprg cscopeprg csqf cscopequickfix csre cscoperelative cst cscopetag csto cscopetagorder csverb cscopeverbose crb cursorbind cuc cursorcolumn cul cursorline debug def define deco delcombine dict dictionary diff dex diffexpr dip diffopt dg digraph dir directory dy display ead eadirection ed edcompatible emo emoji enc encoding eol endofline ea equalalways ep equalprg eb errorbells ef errorfile efm errorformat ek esckeys ei eventignore et expandtab ex exrc fenc fileencoding fencs fileencodings ff fileformat ffs fileformats fic fileignorecase ft filetype fcs fillchars fixeol fixendofline fcl foldclose fdc foldcolumn fen foldenable fde foldexpr
syn keyword vimOption contained fdi foldignore fdl foldlevel fdls foldlevelstart fmr foldmarker fdm foldmethod fml foldminlines fdn foldnestmax fdo foldopen fdt foldtext fex formatexpr fo formatoptions flp formatlistpat fp formatprg fs fsync gd gdefault gfm grepformat gp grepprg gcr guicursor gfn guifont gfs guifontset gfw guifontwide ghr guiheadroom go guioptions guipty gtl guitablabel gtt guitabtooltip hf helpfile hh helpheight hlg helplang hid hidden hl highlight hi history hk hkmap hkp hkmapp hls hlsearch icon iconstring ic ignorecase imaf imactivatefunc imak imactivatekey imc imcmdline imd imdisable imi iminsert ims imsearch imsf imstatusfunc imst imstyle inc include inex includeexpr is incsearch inde indentexpr indk indentkeys inf infercase im insertmode
syn keyword vimOption contained isf isfname isi isident isk iskeyword isp isprint js joinspaces key kmp keymap km keymodel kp keywordprg lmap langmap lm langmenu lnr langnoremap lrm langremap ls laststatus lz lazyredraw lbr linebreak lines lsp linespace lisp lw lispwords list lcs listchars lpl loadplugins luadll macatsui magic mef makeef menc makeencoding mp makeprg mps matchpairs mat matchtime mco maxcombine mfd maxfuncdepth mmd maxmapdepth mm maxmem mmp maxmempattern mmt maxmemtot mis menuitems msm mkspellmem ml modeline mls modelines ma modifiable mod modified more mouse mousef mousefocus mh mousehide mousem mousemodel mouses mouseshape mouset mousetime mzschemedll mzschemegcdll mzq mzquantum nf nrformats nu number nuw numberwidth ofu omnifunc odev opendevice
syn keyword vimOption contained opfunc operatorfunc pp packpath para paragraphs paste pt pastetoggle pex patchexpr pm patchmode pa path perldll pi preserveindent pvh previewheight pvw previewwindow pdev printdevice penc printencoding pexpr printexpr pfn printfont pheader printheader pmbcs printmbcharset pmbfn printmbfont popt printoptions prompt ph pumheight pw pumwidth pythonthreedll pythonthreehome pythondll pythonhome pyx pyxversion qe quoteescape ro readonly rdt redrawtime re regexpengine rnu relativenumber remap rop renderoptions report rs restorescreen ri revins rl rightleft rlc rightleftcmd rubydll ru ruler ruf rulerformat rtp runtimepath scr scroll scb scrollbind sj scrolljump so scrolloff sbo scrollopt sect sections secure sel selection slm selectmode
syn keyword vimOption contained ssop sessionoptions sh shell shcf shellcmdflag sp shellpipe shq shellquote srr shellredir ssl shellslash stmp shelltemp st shelltype sxq shellxquote sxe shellxescape sr shiftround sw shiftwidth shm shortmess sn shortname sbr showbreak sc showcmd sft showfulltag sm showmatch smd showmode stal showtabline ss sidescroll siso sidescrolloff scl signcolumn scs smartcase si smartindent sta smarttab sts softtabstop spell spc spellcapcheck spf spellfile spl spelllang sps spellsuggest sb splitbelow spr splitright sol startofline stl statusline su suffixes sua suffixesadd swf swapfile sws swapsync swb switchbuf smc synmaxcol syn syntax tal tabline tpm tabpagemax ts tabstop tbs tagbsearch tc tagcase tl taglength tr tagrelative tag tags tgst tagstack
syn keyword vimOption contained tcldll term tbidi termbidi tenc termencoding tgc termguicolors twk termwinkey twsl termwinscroll tws termwinsize twt termwintype terse ta textauto tx textmode tw textwidth tsr thesaurus top tildeop to timeout tm timeoutlen title titlelen titleold titlestring tb toolbar tbis toolbariconsize ttimeout ttm ttimeoutlen tbi ttybuiltin tf ttyfast ttym ttymouse tsl ttyscroll tty ttytype udir undodir udf undofile ul undolevels ur undoreload uc updatecount ut updatetime vsts varsofttabstop vts vartabstop vbs verbose vfile verbosefile vdir viewdir vop viewoptions vi viminfo vif viminfofile ve virtualedit vb visualbell warn wiv weirdinvert ww whichwrap wc wildchar wcm wildcharm wig wildignore wic wildignorecase wmnu wildmenu wim wildmode wop wildoptions
syn keyword vimOption contained wak winaltkeys wi window wh winheight wfh winfixheight wfw winfixwidth wmh winminheight wmw winminwidth winptydll wiw winwidth wrap wm wrapmargin ws wrapscan write wa writeany wb writebackup wd writedelay

" vimOptions: These are the turn-off setting variants
syn keyword vimOption contained noanti noantialias noarab noarabic noarshape noarabicshape noari noallowrevins noacd noautochdir noai noautoindent noar noautoread noaw noautowrite noawa noautowriteall nobk nobackup nobeval noballooneval nobevalterm noballoonevalterm nobin nobinary nobomb nobri nobreakindent nobl nobuflisted nocin nocindent nocp nocompatible nocf noconfirm noci nocopyindent nocsre nocscoperelative nocst nocscopetag nocsverb nocscopeverbose nocrb nocursorbind nocuc nocursorcolumn nocul nocursorline nodeco nodelcombine nodiff nodg nodigraph noed noedcompatible noemo noemoji noeol noendofline noea noequalalways noeb noerrorbells noek noesckeys noet noexpandtab noex noexrc nofic nofileignorecase nofixeol nofixendofline nofen nofoldenable nofs nofsync
syn keyword vimOption contained nogd nogdefault noguipty nohid nohidden nohk nohkmap nohkp nohkmapp nohls nohlsearch noicon noic noignorecase noimc noimcmdline noimd noimdisable nois noincsearch noinf noinfercase noim noinsertmode nojs nojoinspaces nolnr nolangnoremap nolrm nolangremap nolz nolazyredraw nolbr nolinebreak nolisp nolist nolpl noloadplugins nomacatsui nomagic noml nomodeline noma nomodifiable nomod nomodified nomore nomousef nomousefocus nomh nomousehide nonu nonumber noodev noopendevice nopaste nopi nopreserveindent nopvw nopreviewwindow noprompt noro noreadonly nornu norelativenumber noremap nors norestorescreen nori norevins norl norightleft noru noruler noscb noscrollbind nosecure nossl noshellslash nostmp noshelltemp nosr noshiftround nosn noshortname
syn keyword vimOption contained nosc noshowcmd nosft noshowfulltag nosm noshowmatch nosmd noshowmode noscs nosmartcase nosi nosmartindent nosta nosmarttab nospell nosb nosplitbelow nospr nosplitright nosol nostartofline noswf noswapfile notbs notagbsearch notr notagrelative notgst notagstack notbidi notermbidi notgc notermguicolors noterse nota notextauto notx notextmode notop notildeop noto notimeout notitle nottimeout notbi nottybuiltin notf nottyfast noudf noundofile novb novisualbell nowarn nowiv noweirdinvert nowic nowildignorecase nowmnu nowildmenu nowfh nowinfixheight nowfw nowinfixwidth nowrap nows nowrapscan nowrite nowa nowriteany nowb nowritebackup

" vimOptions: These are the invertible variants
syn keyword vimOption contained invanti invantialias invarab invarabic invarshape invarabicshape invari invallowrevins invacd invautochdir invai invautoindent invar invautoread invaw invautowrite invawa invautowriteall invbk invbackup invbeval invballooneval invbevalterm invballoonevalterm invbin invbinary invbomb invbri invbreakindent invbl invbuflisted invcin invcindent invcp invcompatible invcf invconfirm invci invcopyindent invcsre invcscoperelative invcst invcscopetag invcsverb invcscopeverbose invcrb invcursorbind invcuc invcursorcolumn invcul invcursorline invdeco invdelcombine invdiff invdg invdigraph inved invedcompatible invemo invemoji inveol invendofline invea invequalalways inveb inverrorbells invek invesckeys invet invexpandtab invex invexrc invfic invfileignorecase
syn keyword vimOption contained invfixeol invfixendofline invfen invfoldenable invfs invfsync invgd invgdefault invguipty invhid invhidden invhk invhkmap invhkp invhkmapp invhls invhlsearch invicon invic invignorecase invimc invimcmdline invimd invimdisable invis invincsearch invinf invinfercase invim invinsertmode invjs invjoinspaces invlnr invlangnoremap invlrm invlangremap invlz invlazyredraw invlbr invlinebreak invlisp invlist invlpl invloadplugins invmacatsui invmagic invml invmodeline invma invmodifiable invmod invmodified invmore invmousef invmousefocus invmh invmousehide invnu invnumber invodev invopendevice invpaste invpi invpreserveindent invpvw invpreviewwindow invprompt invro invreadonly invrnu invrelativenumber invremap invrs invrestorescreen invri invrevins
syn keyword vimOption contained invrl invrightleft invru invruler invscb invscrollbind invsecure invssl invshellslash invstmp invshelltemp invsr invshiftround invsn invshortname invsc invshowcmd invsft invshowfulltag invsm invshowmatch invsmd invshowmode invscs invsmartcase invsi invsmartindent invsta invsmarttab invspell invsb invsplitbelow invspr invsplitright invsol invstartofline invswf invswapfile invtbs invtagbsearch invtr invtagrelative invtgst invtagstack invtbidi invtermbidi invtgc invtermguicolors invterse invta invtextauto invtx invtextmode invtop invtildeop invto invtimeout invtitle invttimeout invtbi invttybuiltin invtf invttyfast invudf invundofile invvb invvisualbell invwarn invwiv invweirdinvert invwic invwildignorecase invwmnu invwildmenu invwfh invwinfixheight
syn keyword vimOption contained invwfw invwinfixwidth invwrap invws invwrapscan invwrite invwa invwriteany invwb invwritebackup

" termcap codes (which can also be set)
syn keyword vimOption contained t_AB t_AF t_AL t_al t_bc t_BE t_BD t_cd t_ce t_cl t_cm t_Ce t_Co t_CS t_Cs t_cs t_CV t_da t_db t_DL t_dl t_EC t_EI t_fs t_GP t_IE t_IS t_ke t_ks t_le t_mb t_md t_me t_mr t_ms t_nd t_op t_RF t_RB t_RC t_RI t_Ri t_RS t_RT t_RV t_Sb t_SC t_se t_Sf t_SH t_SI t_Si t_so t_SR t_sr t_ST t_Te t_te t_ti t_Ts t_ts t_u7 t_ue t_us t_ut t_vb t_ve t_vi t_VS t_vs t_WP t_WS t_xn t_xs t_ZH t_ZR t_8f t_8b
" term key codes
syn keyword vimOption contained t_F1 t_F2 t_F3 t_F4 t_F5 t_F6 t_F7 t_F8 t_F9 t_k1 t_K1 t_k2 t_k3 t_K3 t_k4 t_K4 t_k5 t_K5 t_k6 t_K6 t_k7 t_K7 t_k8 t_K8 t_k9 t_K9 t_KA t_kb t_kB t_KB t_KC t_kd t_kD t_KD t_KE t_KF t_KG t_kh t_KH t_kI t_KI t_KJ t_KK t_kl t_KL t_kN t_kP t_kr t_ku
syn match   vimOption contained "t_%1"
syn match   vimOption contained "t_#2"
syn match   vimOption contained "t_#4"
syn match   vimOption contained "t_@7"
syn match   vimOption contained "t_*7"
syn match   vimOption contained "t_&8"
syn match   vimOption contained "t_%i"
syn match   vimOption contained "t_k;"

" unsupported settings: some were supported by vi but don't do anything in vim
syn keyword vimErrSetting contained akm altkeymap ap autoprint bf beautify biosk bioskey consk conskey fk fkmap fl flash gr graphic ht hardtabs mesg novice open opt optimize oft osfiletype redraw slow slowopen sourceany w300 w1200 w9600
syn keyword vimErrSetting contained noakm noaltkeymap noap noautoprint nobf nobeautify nobiosk nobioskey noconsk noconskey nofk nofkmap nofl noflash nogr nographic nomesg nonovice noopen noopt nooptimize noredraw noslow noslowopen nosourceany
syn keyword vimErrSetting contained invakm invaltkeymap invap invautoprint invbf invbeautify invbiosk invbioskey invconsk invconskey invfk invfkmap invfl invflash invgr invgraphic invmesg invnovice invopen invopt invoptimize invredraw invslow invslowopen invsourceany

" AutoCmd Events
syn case ignore
syn keyword vimAutoEvent contained BufAdd BufCreate BufDelete BufEnter BufFilePost BufFilePre BufHidden BufLeave BufNew BufNewFile BufRead BufReadCmd BufReadPost BufReadPre BufUnload BufWinEnter BufWinLeave BufWipeout BufWrite BufWritePost BufWritePre BufWriteCmd CmdlineChanged CmdlineEnter CmdlineLeave CmdwinEnter CmdwinLeave CmdUndefined ColorScheme ColorSchemePre CompleteDone CursorHold CursorHoldI CursorMoved CursorMovedI DiffUpdated DirChanged EncodingChanged ExitPre FileEncoding FileAppendPost FileAppendPre FileAppendCmd FileChangedShell FileChangedShellPost FileChangedRO FileReadPost FileReadPre FileReadCmd FileType FileWritePost FileWritePre FileWriteCmd FilterReadPost FilterReadPre FilterWritePost FilterWritePre FocusGained FocusLost FuncUndefined GUIEnter
syn keyword vimAutoEvent contained GUIFailed InsertChange InsertEnter InsertLeave InsertCharPre MenuPopup OptionSet QuickFixCmdPost QuickFixCmdPre QuitPre RemoteReply SessionLoadPost ShellCmdPost ShellFilterPost SourceCmd SourcePre SourcePost SpellFileMissing StdinReadPost StdinReadPre SwapExists Syntax TabNew TabClosed TabEnter TabLeave TermChanged TerminalOpen TermResponse TextChanged TextChangedI TextChangedP User VimEnter VimLeave VimLeavePre WinNew WinEnter WinLeave VimResized TextYankPost

" Highlight commonly used Groupnames
syn keyword vimGroup contained  Comment Constant String Character Number Boolean Float Identifier Function Statement Conditional Repeat Label Operator Keyword Exception PreProc Include Define Macro PreCondit Type StorageClass Structure Typedef Special SpecialChar Tag Delimiter SpecialComment Debug Underlined Ignore Error Todo

" Default highlighting groups
syn keyword vimHLGroup contained ErrorMsg IncSearch ModeMsg NonText StatusLine StatusLineNC EndOfBuffer VertSplit VisualNOS DiffText PmenuSbar TabLineSel TabLineFill Cursor lCursor QuickFixLine Directory LineNr CursorLineNr MoreMsg Question Search SpellBad SpellCap SpellRare SpellLocal PmenuThumb Pmenu PmenuSel SpecialKey Title WarningMsg WildMenu Folded FoldColumn SignColumn Visual DiffAdd DiffChange DiffDelete TabLine CursorColumn CursorLine ColorColumn Conceal MatchParen Normal StatusLineTerm StatusLineTermNC ToolbarLine ToolbarButton Menu Tooltip Scrollbar CursorIM
syn case match

" Function Names
syn keyword vimFuncName contained abs acos add and append appendbufline argc argidx arglistid argv asin assert_beeps assert_equal assert_equalfile assert_exception assert_fails assert_false assert_inrange assert_match assert_notequal assert_notmatch assert_report assert_true atan atan2 balloon_show balloon_split browse browsedir bufexists buflisted bufloaded bufname bufnr bufwinid bufwinnr byte2line byteidx byteidxcomp call ceil ch_canread ch_close ch_close_in ch_evalexpr ch_evalraw ch_getbufnr ch_getjob ch_info ch_log ch_logfile ch_open ch_read ch_readblob ch_readraw ch_sendexpr ch_sendraw ch_setoptions ch_status changenr char2nr cindent clearmatches col complete complete_add complete_check confirm copy cos cosh count cscope_connection cursor debugbreak deepcopy
syn keyword vimFuncName contained delete deletebufline did_filetype diff_filler diff_hlID empty escape eval eventhandler executable execute exepath exists exp expand extend feedkeys filereadable filewritable filter finddir findfile float2nr floor fmod fnameescape fnamemodify foldclosed foldclosedend foldlevel foldtext foldtextresult foreground funcref function garbagecollect get getbufinfo getbufline getbufvar getchangelist getchar getcharmod getcharsearch getcmdline getcmdpos getcmdtype getcmdwintype getcompletion getcurpos getcwd getfontname getfperm getfsize getftime getftype getjumplist getline getloclist getmatches getpid getpos getqflist getreg getregtype gettabinfo gettabvar gettabwinvar gettagstack getwininfo getwinpos getwinposx getwinposy getwinvar glob
syn keyword vimFuncName contained glob2regpat globpath has has_key haslocaldir hasmapto histadd histdel histget histnr hlID hlexists hostname iconv indent index input inputdialog inputlist inputrestore inputsave inputsecret insert invert isdirectory islocked isnan items job_getchannel job_info job_setoptions job_start job_status job_stop join js_decode js_encode json_decode json_encode keys len libcall libcallnr line line2byte lispindent localtime log log10 luaeval map maparg mapcheck match matchadd matchaddpos matcharg matchdelete matchend matchlist matchstr matchstrpos max min mkdir mode mzeval nextnonblank nr2char or pathshorten perleval pow prevnonblank printf prompt_setcallback prompt_setinterrupt prompt_setprompt prop_add prop_clear prop_list prop_remove
syn keyword vimFuncName contained prop_type_add prop_type_change prop_type_delete prop_type_get prop_type_list pumvisible py3eval pyeval pyxeval range readfile reg_executing reg_recording reltime reltimefloat reltimestr remote_expr remote_foreground remote_peek remote_read remote_send remote_startserver remove rename repeat resolve reverse round screenattr screenchar screencol screenrow search searchdecl searchpair searchpairpos searchpos server2client serverlist setbufline setbufvar setcharsearch setcmdpos setfperm setline setloclist setmatches setpos setqflist setreg settabvar settabwinvar settagstack setwinvar sha256 shellescape shiftwidth sign_define sign_getdefined sign_getplaced sign_jump sign_place sign_undefine sign_unplace simplify sin sinh sort soundfold
syn keyword vimFuncName contained spellbadword spellsuggest split sqrt str2float str2nr strcharpart strchars strdisplaywidth strftime strgetchar stridx string strlen strpart strridx strtrans strwidth submatch substitute swapinfo swapname synID synIDattr synIDtrans synconcealed synstack system systemlist tabpagebuflist tabpagenr tabpagewinnr tagfiles taglist tan tanh tempname term_dumpdiff term_dumpload term_dumpwrite term_getaltscreen term_getansicolors term_getattr term_getcursor term_getjob term_getline term_getscrolled term_getsize term_getstatus term_gettitle term_gettty term_list term_scrape term_sendkeys term_setansicolors term_setkill term_setrestore term_setsize term_start term_wait test_alloc_fail test_autochdir test_feedinput test_garbagecollect_now
syn keyword vimFuncName contained test_ignore_error test_null_blob test_null_channel test_null_dict test_null_job test_null_list test_null_partial test_null_string test_option_not_set test_override test_scrollbar test_settime timer_info timer_pause timer_start timer_stop timer_stopall tolower toupper tr trim trunc type undofile undotree uniq values virtcol visualmode wildmenumode win_findbuf win_getid win_gotoid win_id2tabwin win_id2win win_screenpos winbufnr wincol winheight winlayout winline winnr winrestcmd winrestview winsaveview winwidth wordcount writefile xor

if !has('nvim')
  syn keyword vimFuncName contained popup_create popup_atcursor popup_beval popup_notification popup_dialog popup_menu popup_hide popup_show popup_move popup_setoptions popup_settext popup_close popup_clear popup_filter_menu popup_filter_yesno popup_getoptions popup_getpos popup_locate
else
endif

" Call goes after function names, so that it has precedence
syn keyword vimCall cal[l] skipwhite nextgroup=vimFunc,vimScope

" Commands, functions, scopes {{{1

" All vimCommands are contained by vimIsCommand.
syn match vimCmdSep "|\s\|\_^\s*:"  skipwhite nextgroup=vimAddress,vimAutoCmd,vimEcho,vimExtCmd,vimFilter,vimCall,vimLet,vimMap,vimMark,vimSet,vimSyntax,vimUserCmd,vimConditional,vimRepeat,vimScope,vimFunc,vimNorm
syn match vimDot    "\." skipwhite nextgroup=vimFunc,vimVar,vimScope
syn match vimIsCommand  "\<\h\w*\(!\|\s\+\|\_$\)" contains=vimCommand,vimStdPlugin,vimConditional,vimRepeat,vimException,vimFunc,vimReturn,vimEcho,vimEchoHL,vimComment,vimExecute
syn match vimVar    contained "\h[a-zA-Z0-9#_]*\>\ze\s\?[^(]\?" contains=vimSelf
syn match vimExclam "!" nextgroup=vimScope,vimVar,vimFunc
syn match vimConditional "[?:]" skipwhite nextgroup=vimScope,vimVar,vimFunc
syn match vimIsCommand  "^\s*:" nextgroup=vimGlobal,vimSubst

" Functions: vimFunc can contain builtin ones, vimScopedFunc is contained in vimScope
syn match vimScopedFunc   contained "\h\w*\(\.\h\w*\)*\ze\s*("
syn match vimFunc   contained "\h[a-zA-Z0-9#_]*\ze\s*(" contains=vimFuncName

" Numbers, operators, autocommands {{{1

syn match vimNumber "\<\d\+\(\.\d\+\)\?\>" display
syn match vimNumber "\<0[xX]\x\+" display

" Autocmd

syn match vimAutoEventList  contained "\(!\s\+\)\=\(\a\+,\)*\a\+" contains=vimAutoEvent nextgroup=vimAutoCmdSpace
syn match vimAutoCmdSpace contained "\s\+"  nextgroup=vimAutoCmdSfxList
syn match vimAutoCmdSfxList contained "\S*"
syn keyword vimAutoCmd  au[tocmd] do[autocmd] doautoa[ll] skipwhite nextgroup=vimAutoEventList

" Augroup

syn cluster vimAugroupList  contains=vimCall,vimAugroup,vimIsCommand,vimCommand,vimUserCmd,vimExecute,vimNotFunc,vimFuncName,vimLineComment,vimMap,vimSpecFile,vimOper,vimNumber,vimOperParen,vimComment,vimString,vimSubst,vimMark,vimRegister,vimAddress,vimFilter,vimCmplxRepeat,vimLet,vimSet,vimAutoCmd,vimRegion,vimSynLine,vimNotation,vimCtrlChar,vimContinue,vimSetEqual,vimOption
syn region  vimAugroup      matchgroup=vimAugroupKey start="\<aug\%[roup]\>\ze\s\+\K\k*" end="\<aug\%[roup]\>\ze\s\+[eE][nN][dD]\>"   contains=vimAutoCmd,@vimAugroupList
syn match   vimAugroup      "aug\%[roup]!"  contains=vimAugroupKey
syn keyword vimAugroupKey   contained aug[roup]

" Operators

syn cluster vimOperGroup    contains=vimEnvvar,vimFunc,vimOper,vimOperParen,vimNumber,vimString,vimRegister,vimContinue,vimNotation,vimScope,vimVar,vimOperBracket
syn match   vimOper         "\%#=1\(==\|!=\|>=\|<=\|=\~\|!\~\|>\|<\|=\)[?#]\{0,2}"  skipwhite nextgroup=vimString,vimSpecFile,vimNotation,vimScope,vimVar,vimFunc,vimExclam
syn keyword vimOper         is isnot skipwhite nextgroup=vimString,vimSpecFile,vimScope,vimVar,vimFunc,vimExclam
syn match   vimOper         "||\|&&\|[-+]"     skipwhite nextgroup=vimString,vimSpecFile,vimScope,vimVar,vimFunc,vimExclam
syn region  vimOperParen    matchgroup=vimParenSep  start="(" end=")" contains=@vimOperGroup
syn region  vimOperParen    matchgroup=vimSep   start="{" end="}" contains=@vimOperGroup nextgroup=vimVar,vimNotation
syn region  vimOperBracket  start="\[" end="]" contains=@vimOperGroup

" User-Specified Commands {{{1

syn cluster vimUserCmdList  contains=vimCall,vimAddress,vimSyntax,vimHighlight,vimAutoCmd,vimCmplxRepeat,vimComment,vimCtrlChar,vimEscapeBrace,vimFilter,vimMark,vimNotation,vimNumber,vimOper,vimRegion,vimRegister,vimLet,vimSet,vimSetEqual,vimSetString,vimSpecFile,vimString,vimSubst,vimSubstRep,vimSubstRange,vimSynLine
syn keyword vimUserCommand  contained com[mand]
syn match vimUserCmd  "\<com\%[mand]!\=\>.*$" contains=vimUserAttrb,vimUserCommand,@vimUserCmdList
syn match vimUserAttrb  contained "-b\%[ang]\>"   contains=vimUserAttrbKey
syn match vimUserAttrb  contained "-bu\%[ffer]\>"   contains=vimUserAttrbKey
syn match vimUserAttrb  contained "-r\%[egister]\>"   contains=vimUserAttrbKey
syn match vimUserAttrb  contained "-ba\%[r]\>"    contains=vimUserAttrbKey
syn match vimUserAttrb  contained "-n\%[args]=[01*?+]"  contains=vimUserAttrbKey
syn match vimUserAttrb  contained "-ra\%[nge]\(=%\|=\d\+\)\=" contains=vimNumber,vimUserAttrbKey
syn match vimUserAttrb  contained "-c\%[ount]\(=\d\+\)\=" contains=vimNumber,vimUserAttrbKey
syn match vimUserAttrb  contained "-com\%[plete]="    contains=vimUserAttrbKey nextgroup=vimUserAttrbCmplt,vimUserCmdError
syn match vimUserAttrb  contained "-a\%[ddr]="    contains=vimUserAttrbKey nextgroup=vimUserAttrbAddr,vimUserCmdError
syn case ignore
syn keyword vimUserAttrbKey   contained b[ang] bu[ffer] r[egister] ba[r] n[args] ra[nge] c[ount] com[plete] a[ddr]
syn keyword vimUserAttrbCmplt contained arglist augroup behave buffer color command compiler cscope dir environment event expression file file_in_path filetype function help highlight history locale mapclear mapping menu messages syntax syntime option packadd shellcmd sign tag tag_listfiles user var
syn keyword vimUserAttrbCmplt contained custom customlist nextgroup=vimUserAttrbCmpltFunc,vimUserCmdError
syn match vimUserAttrbCmpltFunc contained ",\%([sS]:\|<[sS][iI][dD]>\)\=\%(\h\w*\%(#\h\w*\)\+\|\h\w*\)"hs=s+1 nextgroup=vimUserCmdError
syn keyword vimUserAttrbAddr  contained lines arguments buffers loaded_buffers windows tabs

syn case match
syn match vimUserAttrbCmplt contained "custom,\u\w*"

" Strings, Maps, etc {{{1

" Try to catch strings, if nothing else matches (therefore it must precede the others!)
"  vimEscapeBrace handles ["]  []"] (ie. "s don't terminate string inside [])
syn region  vimEscapeBrace  oneline   contained transparent start="[^\\]\(\\\\\)*\[\zs\^\=\]\=" skip="\\\\\|\\\]" end="]"me=e-1
syn match vimPatSepErr  contained "\\)"
syn match vimPatSep contained "\\|"
syn region  vimPatSepZone oneline   contained   matchgroup=vimPatSepZ start="\\%\=\ze(" skip="\\\\" end="\\)\|[^\\]['"]"  contains=@vimStringGroup
syn region  vimPatRegion  contained transparent matchgroup=vimPatSepR start="\\[z%]\=(" end="\\)" contains=@vimSubstList oneline
syn match vimNotPatSep  contained "\\\\"
syn cluster vimStringGroup  contains=vimEscapeBrace,vimPatSep,vimNotPatSep,vimPatSepErr,vimPatSepZone,@Spell

" Substitutions

syn cluster vimSubstList  contains=vimPatSep,vimPatRegion,vimPatSepErr,vimSubstTwoBS,vimSubstRange,vimNotation
syn cluster vimSubstRepList contains=vimSubstSubstr,vimSubstTwoBS,vimNotation
syn cluster vimSubstList  add=vimCollection
syn match vimSubst       containedin=vimIsCommand "\<s\%(\%[ubstitute]\|m\%[agic]\|no\%[magic]\|c[egiInpl]\=\|g[ceiInplr]\=\|i[ceInpr]\=\|I[ceginplr]\=\|r[cgiInpl]\=\)\>"  nextgroup=vimSubstPat
syn region  vimSubstPat     contained matchgroup=vimSubstDelim start="\z([^a-zA-Z( \t[\]&]\)"rs=s+1 skip="\\\\\|\\\z1" end="\z1"re=e-1,me=e-1  contains=@vimSubstList nextgroup=vimSubstRep4  oneline
syn region  vimSubstRep4    contained matchgroup=vimSubstDelim start="\z(.\)" skip="\\\\\|\\\z1" end="\z1" matchgroup=vimNotation end="<[cC][rR]>" contains=@vimSubstRepList  nextgroup=vimSubstFlagErr oneline
syn region  vimCollection   contained transparent start="\\\@<!\[" skip="\\\[" end="\]" contains=vimCollClass
syn match vimCollClassErr contained "\[:.\{-\}:\]"
syn match vimCollClass    contained transparent "\%#=1\[:\(alnum\|alpha\|blank\|cntrl\|digit\|graph\|lower\|print\|punct\|space\|upper\|xdigit\|return\|tab\|escape\|backspace\):\]"
syn match vimSubstSubstr  contained "\\z\=\d"
syn match vimSubstTwoBS   contained "\\\\"
syn match vimSubstFlagErr contained "[^< \t\r|]\+" contains=vimSubstFlags
syn match vimSubstFlags   contained "[&cegiIpr]\+"

" put here for precedence
syn match vimScope "\<[bwglstav]:" nextgroup=vimVar,vimScopedFunc

" Environment Variables

syn match vimEnvvar "\$\u\i*"
syn match vimEnvvar "\${\u\i*}"

" Abbreviations

syn keyword vimAbb ab[breviate] ca[bbrev] cnorea[bbrev] ia[bbrev] inorea[bbrev] norea[bbrev] skipwhite nextgroup=vimMapMod,vimMapLhs

" Strings

syn region vimString   start=+'+ skip=+\\\\\|\\$+ end=+'+ end=+$+ keepend
syn region vimString   start=+"+ skip=+\\\\\|\\"\|\\$+ end=+"+ end=+$+ keepend

" Registers

syn match vimPlainRegister contained  '"[a-zA-Z0-9\-:.%#*+=]'
syn match vimRegister '@[a-zA-Z0-9\-:.%#*+="]'

" Set command and associated set-options (vimOptions) with comment

syn region  vimSet    matchgroup=vimCommand start="\<\%(setl\%[ocal]\|setg\%[lobal]\|se\%[t]\)\>" skip="\%(\\\\\)*\\." end="$" end="|" matchgroup=vimNotation end="<[cC][rR]>" keepend oneline contains=vimSetEqual,vimOption,vimErrSetting,vimComment,vimSetString,vimSetMod
syn region  vimSetEqual contained start="[=:]\|[-+^]=" skip="\\\\\|\\\s" end="[| \t]\|$"me=e-1  contains=vimCtrlChar,vimSetSep,vimNotation,vimEnvvar oneline
syn region  vimSetString  contained start=+="+hs=s+1  skip=+\\\\\|\\"+  end=+"+   contains=vimCtrlChar
syn match vimSetSep contained "[,:]" skipwhite nextgroup=vimCommand
syn match vimSetMod contained "&vim\=\|[!&?<]\|all&"

" Echo and Execute

syn keyword vimEcho echo echoe[rr] echom[sg] echon skipwhite nextgroup=vimString,vimVar,vimFunc,vimScope
syn keyword vimEchoHL echohl skipwhite nextgroup=vimGroup,vimHLGroup,vimEchoHLNone
syn region  vimExecute  oneline excludenl contained matchgroup=vimCommand start="\<exe\%[cute]\>" skip="\(\\\\\)*\\|" end="$\|<[cC][rR]>\|\(.\ze|\)" contains=vimIsCommand,vimOper,vimNotation,vimOperParen,vimString,vimVar
syn case ignore
syn keyword vimEchoHLNone none
syn case match

" Maps

syn match vimMap    "\<map\>!\=\ze\s*[^(]" skipwhite nextgroup=vimMapMod,vimMapLhs
syn keyword vimMap cm[ap] cno[remap] im[ap] ino[remap] lm[ap] ln[oremap] nm[ap] nn[oremap] no[remap] om[ap] ono[remap] smap snor[emap] vm[ap] vn[oremap] xm[ap] xn[oremap] skipwhite nextgroup=vimMapBang,vimMapMod,vimMapLhs
syn keyword vimMap cmapc[lear] imapc[lear] lmapc[lear] mapc[lear] nmapc[lear] omapc[lear] smapc[lear] vmapc[lear] xmapc[lear]
syn keyword vimUnmap cu[nmap] iu[nmap] lu[nmap] nun[map] ou[nmap] sunm[ap] unm[ap] vu[nmap] xu[nmap] skipwhite nextgroup=vimMapBang,vimMapMod,vimMapLhs
syn match vimMapLhs contained "\S\+"      contains=vimNotation,vimCtrlChar skipwhite nextgroup=vimMapRhs
syn match vimMapBang  contained "!"     skipwhite nextgroup=vimMapMod,vimMapLhs
syn match vimMapMod contained "\%#=1\c<\(buffer\|expr\|\(local\)\=leader\|nowait\|plug\|script\|sid\|unique\|silent\)\+>" contains=vimMapModKey,vimMapModErr skipwhite nextgroup=vimMapMod,vimMapLhs
syn match vimMapRhs contained ".*" contains=vimNotation,vimCtrlChar skipnl nextgroup=vimMapRhsExtend
syn match vimMapRhsExtend contained "^\s*\\.*$"     contains=vimContinue,vimNotation
syn case ignore
syn keyword vimMapModKey  contained buffer  expr  leader  localleader nowait  plug  script  sid silent  unique
syn case match

" Menus

syn cluster vimMenuList contains=vimMenuBang,vimMenuPriority,vimMenuName,vimMenuMod
syn keyword vimCommand am[enu] an[oremenu] aun[menu] cme[nu] cnoreme[nu] cunme[nu] ime[nu] inoreme[nu] iunme[nu] me[nu] nme[nu] nnoreme[nu] noreme[nu] nunme[nu] ome[nu] onoreme[nu] ounme[nu] sme[nu] snoreme[nu] sunme[nu] unme[nu] vme[nu] vnoreme[nu] vunme[nu] xme[nu] xnoreme[nu] xunme[nu] skipwhite nextgroup=@vimMenuList
syn match vimMenuName "[^ \t\\<]\+" contained nextgroup=vimMenuNameMore,vimMenuMap
syn match vimMenuPriority "\d\+\(\.\d\+\)*" contained skipwhite nextgroup=vimMenuName
syn match vimMenuNameMore "\c\\\s\|<tab>\|\\\." contained nextgroup=vimMenuName,vimMenuNameMore contains=vimNotation
syn match vimMenuMod    contained "\c<\(script\|silent\)\+>"  skipwhite contains=vimMapModKey,vimMapModErr nextgroup=@vimMenuList
syn match vimMenuMap  "\s"  contained skipwhite nextgroup=vimMenuRhs
syn match vimMenuRhs  ".*$" contained contains=vimString,vimComment,vimIsCommand
syn match vimMenuBang "!" contained skipwhite nextgroup=@vimMenuList

" Angle-Bracket Notation

syn match vimNotation "<\([^ \t<>]\+\|<lt>\)\+>"

" Control Characters

syn match vimCtrlChar "[
--]"

" Normal

syn match vimNorm   "\<norm\%[al]!\=" contains=vimExclam skipwhite nextgroup=vimNormCmds
syn match vimNormCmds contained ".*$" contains=vimPlainRegister,vimRegister,vimCtrlChar

" Syntax {{{1

syn match vimGroupList  contained "@\=[^ \t,]*" contains=vimGroupSpecial,vimPatSep
syn match vimGroupList  contained "@\=[^ \t,]*,"  nextgroup=vimGroupList contains=vimGroupSpecial,vimPatSep
syn keyword vimGroupSpecial contained ALL ALLBUT  CONTAINED TOP
syn match vimSynContains  contained "\<contain\(s\|edin\)=" nextgroup=vimGroupList
syn match vimSynKeyContainedin  contained "\<containedin="  nextgroup=vimGroupList
syn match vimSynNextgroup contained "nextgroup="  nextgroup=vimGroupList

syn match vimSyntax "\<sy\%[ntax]\>"  contains=vimCommand skipwhite nextgroup=vimSynType,vimComment
syn match vimAuSyntax contained "\s+sy\%[ntax]" contains=vimCommand skipwhite nextgroup=vimSynType,vimComment
syn cluster vimFuncBodyList add=vimSyntax

" Syntax: case {{{2
syn keyword vimSynType  contained case  skipwhite nextgroup=vimSynCase
syn keyword vimSynCase  contained ignore  match

" Syntax: clear {{{2
syn keyword vimSynType  contained clear skipwhite nextgroup=vimGroupList

" Syntax: cluster {{{2
syn keyword vimSynType  contained cluster skipwhite nextgroup=vimClusterName
syn region  vimClusterName  contained matchgroup=vimGroupName start="\h\w*" skip="\\\\\|\\|" matchgroup=vimSep end="$\||" contains=vimGroupAdd,vimGroupRem,vimSynContains
syn match vimGroupAdd contained "add="  nextgroup=vimGroupList
syn match vimGroupRem contained "remove=" nextgroup=vimGroupList
syn cluster vimFuncBodyList add=vimSynType,vimGroupAdd,vimGroupRem

" Syntax: iskeyword {{{2
syn keyword vimSynType  contained iskeyword skipwhite nextgroup=vimIskList
syn match vimIskList  contained '\S\+'  contains=vimIskSep
syn match vimIskSep contained ','

" Syntax: include {{{2
syn keyword vimSynType  contained include skipwhite nextgroup=vimGroupList
syn cluster vimFuncBodyList add=vimSynType

" Syntax: keyword {{{2
syn cluster vimSynKeyGroup  contains=vimSynNextgroup,vimSynKeyOpt,vimSynKeyContainedin
syn keyword vimSynType  contained keyword skipwhite nextgroup=vimSynKeyRegion
syn region  vimSynKeyRegion contained oneline keepend matchgroup=vimGroupName start="\h\w*" skip="\\\\\|\\|" matchgroup=vimSep end="|\|$" contains=@vimSynKeyGroup
syn match vimSynKeyOpt  contained "\%#=1\<\(conceal\|contained\|transparent\|skipempty\|skipwhite\|skipnl\)\>"
syn cluster vimFuncBodyList add=vimSynType

" Syntax: match {{{2
syn cluster vimSynMtchGroup contains=vimMtchComment,vimSynContains,vimSynMtchOpt,vimSynNextgroup,vimSynRegPat
syn keyword vimSynType  contained match skipwhite nextgroup=vimSynMatchRegion
syn region  vimSynMatchRegion contained keepend matchgroup=vimGroupName start="\h\w*" matchgroup=vimSep end="|\|$" contains=@vimSynMtchGroup
syn match vimSynMtchOpt contained "\%#=1\<\(conceal\|transparent\|contained\|excludenl\|keepend\|skipempty\|skipwhite\|display\|extend\|skipnl\|fold\)\>"
if has("conceal")
 syn match  vimSynMtchOpt contained "\<cchar="  nextgroup=vimSynMtchCchar
 syn match  vimSynMtchCchar contained "\S"
endif
syn cluster vimFuncBodyList add=vimSynMtchGroup

" Syntax: off and on {{{2
syn keyword vimSynType  contained enable  list  manual  off on  reset

" Syntax: region {{{2
syn cluster vimSynRegPatGroup contains=vimPatSep,vimNotPatSep,vimSynPatRange,vimSynNotPatRange,vimSubstSubstr,vimPatRegion,vimPatSepErr
syn cluster vimSynRegGroup  contains=vimSynContains,vimSynNextgroup,vimSynRegOpt,vimSynReg,vimSynMtchGrp
syn keyword vimSynType  contained region  skipwhite nextgroup=vimSynRegion
syn region  vimSynRegion  contained keepend matchgroup=vimGroupName start="\h\w*" skip="\\\\\|\\|" end="|\|$" contains=@vimSynRegGroup
syn match vimSynRegOpt  contained "\%#=1\<\(conceal\(ends\)\=\|transparent\|contained\|excludenl\|skipempty\|skipwhite\|display\|keepend\|oneline\|extend\|skipnl\|fold\)\>"
syn match vimSynReg contained "\(start\|skip\|end\)="he=e-1 nextgroup=vimSynRegPat
syn match vimSynMtchGrp contained "matchgroup=" nextgroup=vimGroup,vimHLGroup
syn region  vimSynRegPat  contained extend  start="\z([-`~!@#$%^&*_=+;:'",./?]\)"  skip="\\\\\|\\\z1"  end="\z1"  contains=@vimSynRegPatGroup skipwhite nextgroup=vimSynPatMod,vimSynReg
syn match vimSynPatMod  contained "\%#=1\(hs\|ms\|me\|hs\|he\|rs\|re\)=[se]\([-+]\d\+\)\="
syn match vimSynPatMod  contained "\%#=1\(hs\|ms\|me\|hs\|he\|rs\|re\)=[se]\([-+]\d\+\)\=," nextgroup=vimSynPatMod
syn match vimSynPatMod  contained "lc=\d\+"
syn match vimSynPatMod  contained "lc=\d\+," nextgroup=vimSynPatMod
syn region  vimSynPatRange  contained start="\["  skip="\\\\\|\\]"   end="]"
syn match vimSynNotPatRange contained "\\\\\|\\\["
syn match vimMtchComment  contained '"[^"]\+$'
syn cluster vimFuncBodyList add=vimSynType

" Syntax: sync {{{2

syn keyword vimSynType  contained sync  skipwhite nextgroup=vimSyncC,vimSyncLines,vimSyncMatch,vimSyncError,vimSyncLinebreak,vimSyncLinecont,vimSyncRegion
syn keyword vimSyncC  contained ccomment  clear fromstart
syn keyword vimSyncMatch  contained match skipwhite nextgroup=vimSyncGroupName
syn keyword vimSyncRegion contained region  skipwhite nextgroup=vimSynReg
syn match vimSyncLinebreak  contained "\<linebreaks=" skipwhite nextgroup=vimNumber
syn keyword vimSyncLinecont contained linecont  skipwhite nextgroup=vimSynRegPat
syn match vimSyncLines  contained "\(min\|max\)\=lines="  nextgroup=vimNumber
syn match vimSyncGroupName  contained "\h\w*" skipwhite nextgroup=vimSyncKey
syn match vimSyncKey  contained "\<groupthere\|grouphere\>" skipwhite nextgroup=vimSyncGroup
syn match vimSyncGroup  contained "\h\w*" skipwhite nextgroup=vimSynRegPat,vimSyncNone
syn keyword vimSyncNone contained NONE
"}}}

" Additional IsCommand, here by reasons of precedence {{{1

syn match vimIsCommand  "<Bar>\s*\a\+"  transparent contains=vimCommand,vimNotation,vimConditional,vimRepeat,vimException,vimFunc

" Highlighting {{{1

syn cluster vimHighlightCluster   contains=vimHiLinks,vimHiClear,vimComment,vimHiGroup
syn keyword vimHighlight hi[ghlight] skipwhite nextgroup=@vimHighlightCluster,vimHiBang
syn match vimHiBang contained "!" skipwhite nextgroup=@vimHighlightCluster

syn case ignore
syn keyword vimHiMode   term ctermfg ctermbg guifg guibg guisp cterm gui nextgroup=vimHiEqual
syn match vimHiGroup  contained "\i\+"
syn match vimHiEqual  contained "=" nextgroup=vimHiGuiRgb,vimHiNmbr,vimHiAttrib
syn keyword vimHiAttrib contained none bold inverse italic nocombine reverse standout strikethrough underline undercurl bg background fg foreground
syn keyword vimHiCtermColor contained black blue brown cyan darkblue darkcyan darkgray darkgreen darkgrey darkmagenta darkred darkyellow gray green grey lightblue lightcyan lightgray lightgreen lightgrey lightmagenta lightred magenta red white yellow
syn match vimHiCtermColor contained "\<color\d\{1,3}\>"

syn case match
syn match vimHiFontname contained "[a-zA-Z\-*]\+"
syn match vimHiGuiFontname  contained "'[a-zA-Z\-* ]\+'"
syn match vimHiGuiRgb contained "#\x\{6}"

" hi group key=arg ...
syn cluster vimHiCluster contains=vimGroup,vimHiGroup,vimHiTerm,vimHiCTerm,vimHiStartStop,vimHiCtermFgBg,vimHiGui,vimHiGuiFont,vimHiGuiFgBg,vimNotation
syn match vimHiStartStop  contained "\c\(start\|stop\)="he=e-1  nextgroup=vimHiTermcap,vimOption
syn match vimHiGuiFont  contained "\cfont="he=e-1   nextgroup=vimHiFontname
syn match vimHiTermcap  contained "\S\+"    contains=vimNotation
syn match vimHiNmbr contained '\d\+'

" clear/links
syn keyword vimHiClear  contained clear nextgroup=vimHiGroup
syn match vimHiLinks   contained '\<\(def \|default \)\?link.*' contains=vimHiLink,vimHiGroup
syn keyword vimHiLink   contained def[ault] link

" Line Beginners {{{1

syn match vimLineComment        +^[ \t:]*".*$+  contains=@vimTodoGroup,vimCommentString,vimCommentTitle
syn match vimComment            ' "[^"]\+$'  contains=@vimTodoGroup,vimCommentString,vimCommentTitle
syn match vimCommentTitle       '"\s*\%([sS]:\|\h\w*#\)\=\u\w*\(\s\+\u\w*\)*:'hs=s+1  contained contains=vimCommentTitleLeader,vimTodo,@vimTodoGroup
syn match vimContinue           "^\s*\\" skipwhite nextgroup=vimFunc
syn region  vimString           start="^\s*\\\z(['"]\)" skip='\\\\\|\\\z1' end="\z1" oneline keepend contains=@vimStringGroup,vimContinue
syn match vimCommentTitleLeader '"\s\+'ms=s+1 contained

" Searches And Globals {{{1

syn match vimSearch '^\s*[/?].*'    contains=vimSearchDelim
syn match vimSearchDelim  '^\s*\zs[/?]\|[/?]$'  contained
syn match  vimGlobal containedin=vimIsCommand 'g\%[lobal]!\=/' nextgroup=vimGlobalPat
syn match  vimGlobal containedin=vimIsCommand 'v\%[global]!\=/' nextgroup=vimGlobalPat
syn match  vimGlobalPat contained '\\/\+\|[^/]\+' nextgroup=vimGlobalSep
syn match  vimGlobalSep contained '/' nextgroup=vimGlobalCmd
syn match  vimGlobalCmd contained '.\+\_$'

" Scripts {{{1

" Commands {{{2
com! -nargs=*  VimFolda  <args>
com! -nargs=*  VimFoldf  <args>
com! -nargs=*  VimFoldl  <args>
com! -nargs=*  VimFoldm  <args>
com! -nargs=*  VimFoldp  <args>
com! -nargs=*  VimFoldP  <args>
com! -nargs=*  VimFoldr  <args>
com! -nargs=*  VimFoldt  <args>

if !exists("g:vimsyn_embed")
 let g:vimsyn_embed= "lmpPrt"
endif
"}}}

" [-- lua --] {{{2
let s:luapath= fnameescape(expand("<sfile>:p:h")."/lua.vim")
if !filereadable(s:luapath)
 for s:luapath in split(globpath(&rtp,"syntax/lua.vim"),"\n")
  if filereadable(fnameescape(s:luapath))
   let s:luapath= fnameescape(s:luapath)
   break
  endif
 endfor
endif
if (g:vimsyn_embed =~# 'l' && has("lua")) && filereadable(s:luapath)
 unlet! b:current_syntax
 syn cluster vimFuncBodyList  add=vimLuaRegion
 exe "syn include @vimLuaScript ".s:luapath
 VimFoldl syn region vimLuaRegion matchgroup=vimScriptDelim start=+lua\s*<<\s*\z(.*\)$+ end=+^\z1$+ contains=@vimLuaScript
 VimFoldl syn region vimLuaRegion matchgroup=vimScriptDelim start=+lua\s*<<\s*$+ end=+\.$+    contains=@vimLuaScript
 syn cluster vimFuncBodyList  add=vimLuaRegion
else
 syn region vimEmbedError start=+lua\s*<<\s*\z(.*\)$+ end=+^\z1$+
 syn region vimEmbedError start=+lua\s*<<\s*$+ end=+\.$+
endif
unlet s:luapath

" [-- perl --] {{{2
let s:perlpath= fnameescape(expand("<sfile>:p:h")."/perl.vim")
if !filereadable(s:perlpath)
 for s:perlpath in split(globpath(&rtp,"syntax/perl.vim"),"\n")
  if filereadable(fnameescape(s:perlpath))
   let s:perlpath= fnameescape(s:perlpath)
   break
  endif
 endfor
endif
if (g:vimsyn_embed =~# 'p' && has("perl")) && filereadable(s:perlpath)
 unlet! b:current_syntax
 syn cluster vimFuncBodyList  add=vimPerlRegion
 exe "syn include @vimPerlScript ".s:perlpath
 VimFoldp syn region vimPerlRegion  matchgroup=vimScriptDelim start=+pe\%[rl]\s*<<\s*\z(\S*\)\ze\(\s*["#].*\)\=$+ end=+^\z1\ze\(\s*[#"].*\)\=$+ contains=@vimPerlScript
 VimFoldp syn region vimPerlRegion  matchgroup=vimScriptDelim start=+pe\%[rl]\s*<<\s*$+ end=+\.$+     contains=@vimPerlScript
 syn cluster vimFuncBodyList  add=vimPerlRegion
else
 syn region vimEmbedError start=+pe\%[rl]\s*<<\s*\z(.*\)$+ end=+^\z1$+
 syn region vimEmbedError start=+pe\%[rl]\s*<<\s*$+ end=+\.$+
endif
unlet s:perlpath

" [-- ruby --] {{{2
let s:rubypath= fnameescape(expand("<sfile>:p:h")."/ruby.vim")
if !filereadable(s:rubypath)
 for s:rubypath in split(globpath(&rtp,"syntax/ruby.vim"),"\n")
  if filereadable(fnameescape(s:rubypath))
   let s:rubypath= fnameescape(s:rubypath)
   break
  endif
 endfor
endif
if (g:vimsyn_embed =~# 'r' && has("ruby")) && filereadable(s:rubypath)
 syn cluster vimFuncBodyList  add=vimRubyRegion
 unlet! b:current_syntax
 exe "syn include @vimRubyScript ".s:rubypath
 VimFoldr syn region vimRubyRegion  matchgroup=vimScriptDelim start=+rub[y]\s*<<\s*\z(\S*\)\ze\(\s*#.*\)\=$+ end=+^\z1\ze\(\s*".*\)\=$+ contains=@vimRubyScript
 syn region vimRubyRegion matchgroup=vimScriptDelim start=+rub[y]\s*<<\s*$+ end=+\.$+     contains=@vimRubyScript
 syn cluster vimFuncBodyList  add=vimRubyRegion
else
 syn region vimEmbedError start=+rub[y]\s*<<\s*\z(.*\)$+ end=+^\z1$+
 syn region vimEmbedError start=+rub[y]\s*<<\s*$+ end=+\.$+
endif
unlet s:rubypath

" [-- python --] {{{2
let s:pythonpath= fnameescape(expand("<sfile>:p:h")."/python.vim")
if !filereadable(s:pythonpath)
 for s:pythonpath in split(globpath(&rtp,"syntax/python.vim"),"\n")
  if filereadable(fnameescape(s:pythonpath))
   let s:pythonpath= fnameescape(s:pythonpath)
   break
  endif
 endfor
endif
if g:vimsyn_embed =~# 'P' && (has("pythonx") || has("python") || has("python3")) && filereadable(s:pythonpath)
 unlet! b:current_syntax
 exe "syn include @vimPythonScript ".s:pythonpath
 VimFoldP syn region vimPythonRegion matchgroup=vimScriptDelim start=+py\%[thon]3\=\s*<<\s*\z(\S*\)\ze\(\s*#.*\)\=$+ end=+^\z1\ze\(\s*".*\)\=$+ contains=@vimPythonScript
 VimFoldP syn region vimPythonRegion matchgroup=vimScriptDelim start=+py\%[thon]3\=\s*<<\s*$+ end=+\.$+     contains=@vimPythonScript
 VimFoldP syn region vimPythonRegion matchgroup=vimScriptDelim start=+Py\%[thon]2or3\s*<<\s*\z(\S*\)\ze\(\s*#.*\)\=$+ end=+^\z1\ze\(\s*".*\)\=$+  contains=@vimPythonScript
 VimFoldP syn region vimPythonRegion matchgroup=vimScriptDelim start=+Py\%[thon]2or3\=\s*<<\s*$+ end=+\.$+      contains=@vimPythonScript
 syn cluster vimFuncBodyList  add=vimPythonRegion
else
 syn region vimEmbedError start=+py\%[thon]3\=\s*<<\s*\z(.*\)$+ end=+^\z1$+
 syn region vimEmbedError start=+py\%[thon]3\=\s*<<\s*$+ end=+\.$+
endif
unlet s:pythonpath

" [-- tcl --] {{{2
if has("win32") || has("win95") || has("win64") || has("win16")
 " apparently has("tcl") has been hanging vim on some windows systems with cygwin
 let s:trytcl= (&shell !~ '\<\%(bash\>\|4[nN][tT]\|\<zsh\)\>\%(\.exe\)\=$')
else
 let s:trytcl= 1
endif
if s:trytcl
 let s:tclpath= fnameescape(expand("<sfile>:p:h")."/tcl.vim")
 if !filereadable(s:tclpath)
  for s:tclpath in split(globpath(&rtp,"syntax/tcl.vim"),"\n")
   if filereadable(fnameescape(s:tclpath))
    let s:tclpath= fnameescape(s:tclpath)
    break
   endif
  endfor
 endif
 if (g:vimsyn_embed =~# 't' && has("tcl")) && filereadable(s:tclpath)
  unlet! b:current_syntax
  syn cluster vimFuncBodyList add=vimTclRegion
  exe "syn include @vimTclScript ".s:tclpath
  VimFoldt syn region vimTclRegion matchgroup=vimScriptDelim start=+tc[l]\=\s*<<\s*\z(.*\)$+ end=+^\z1$+  contains=@vimTclScript
  VimFoldt syn region vimTclRegion matchgroup=vimScriptDelim start=+tc[l]\=\s*<<\s*$+ end=+\.$+ contains=@vimTclScript
  syn cluster vimFuncBodyList add=vimTclScript
 else
  syn region vimEmbedError start=+tc[l]\=\s*<<\s*\z(.*\)$+ end=+^\z1$+
  syn region vimEmbedError start=+tc[l]\=\s*<<\s*$+ end=+\.$+
 endif
 unlet s:tclpath
else
 syn region vimEmbedError start=+tc[l]\=\s*<<\s*\z(.*\)$+ end=+^\z1$+
 syn region vimEmbedError start=+tc[l]\=\s*<<\s*$+ end=+\.$+
endif
unlet s:trytcl

" [-- mzscheme --] {{{2
let s:mzschemepath= fnameescape(expand("<sfile>:p:h")."/scheme.vim")
if !filereadable(s:mzschemepath)
 for s:mzschemepath in split(globpath(&rtp,"syntax/mzscheme.vim"),"\n")
  if filereadable(fnameescape(s:mzschemepath))
   let s:mzschemepath= fnameescape(s:mzschemepath)
   break
  endif
 endfor
endif
if (g:vimsyn_embed =~# 'm' && has("mzscheme")) && filereadable(s:mzschemepath)
 unlet! b:current_syntax
 let s:iskKeep= &isk
 syn cluster vimFuncBodyList  add=vimMzSchemeRegion
 exe "syn include @vimMzSchemeScript ".s:mzschemepath
 let &isk= s:iskKeep
 unlet s:iskKeep
 VimFoldm syn region vimMzSchemeRegion matchgroup=vimScriptDelim start=+mz\%[scheme]\s*<<\s*\z(.*\)$+ end=+^\z1$+ contains=@vimMzSchemeScript
 VimFoldm syn region vimMzSchemeRegion matchgroup=vimScriptDelim start=+mz\%[scheme]\s*<<\s*$+ end=+\.$+    contains=@vimMzSchemeScript
 syn cluster vimFuncBodyList  add=vimMzSchemeRegion
else
 syn region vimEmbedError start=+mz\%[scheme]\s*<<\s*\z(.*\)$+ end=+^\z1$+
 syn region vimEmbedError start=+mz\%[scheme]\s*<<\s*$+ end=+\.$+
endif
unlet s:mzschemepath

delcommand VimFolda
delcommand VimFoldf
delcommand VimFoldl
delcommand VimFoldm
delcommand VimFoldp
delcommand VimFoldP
delcommand VimFoldr
delcommand VimFoldt
"}}}

" Highlighting Settings {{{1


command! -nargs=1 HiDefault call s:HiDefault(<q-args>)

function! s:HiDefault(groups)
  try
    let newHi = split(a:groups)[0]
    if match(execute('hi ' . newHi), 'xxx cleared') >= 0
      exe 'hi! default link' a:groups
    endif
  catch
    exe 'hi default link' a:groups
  endtry
endfunction

if !exists("skip_vim_syntax_inits")
 " new groups
 hi def link vimConditional Conditional
 hi def link vimCall vimCommand
 hi def link vimRepeat Conditional
 hi def link vimException Conditional
 hi def link vimFuncDecl vimCommand
 hi def link vimSelf Identifier

 hi def link vimAbb vimCommand
 hi def link vimAddress vimMark
 hi def link vimAugroupKey  vimCommand
 hi def link vimAuHighlight vimHighlight
 hi def link vimAutoCmdOpt  vimOption
 hi def link vimAutoCmd vimCommand
 hi def link vimAutoEvent Type
 hi def link vimAutoSet vimCommand
 hi def link vimBracket Delimiter
 hi def link vimCmplxRepeat SpecialChar
 hi def link vimCommand Keyword
 hi def link vimComment Comment
 hi def link vimCommentString vimString
 hi def link vimCommentTitle  PreProc
 hi def link vimCondHL  vimCommand
 hi def link vimContinue  Special
 hi def link vimCtrlChar  SpecialChar
 hi def link vimEchoHLNone  vimGroup
 hi def link vimEcho vimCommand
 hi def link vimEchoHL  vimCommand
 hi def link vimElseif  vimCondHL
 hi def link vimEnvvar  PreProc
 hi def link vimFBVar vimVar
 hi def link vimFgBgAttrib  vimHiAttrib
 hi def link vimFold  Folded
 hi def link vimFTCmd vimCommand
 hi def link vimFTOption  vimSynType
 hi def link vimFuncKey vimCommand
 hi def link vimFuncName  Function
 hi def link vimFuncSID Special
 hi def link vimGlobal Statement
 hi def link vimGlobalSep Statement
 hi def link vimGroupAdd  vimSynOption
 hi def link vimGroupName vimGroup
 hi def link vimGroupRem  vimSynOption
 hi def link vimGroupSpecial  Special
 hi def link vimGroup Type
 hi def link vimHiAttrib  PreProc
 hi def link vimHiClear vimHighlight
 hi def link vimHiCtermFgBg vimHiTerm
 hi def link vimHiCTerm vimHiTerm
 hi def link vimHighlight vimCommand
 hi def link vimHiGroup vimGroupName
 hi def link vimHiGuiFgBg vimHiTerm
 hi def link vimHiGuiFont vimHiTerm
 hi def link vimHiGuiRgb  vimNumber
 hi def link vimHiGui vimHiTerm
 hi def link vimHiLink vimCommand
 hi def link vimHiMode Function
 hi def link vimHiNmbr  Number
 hi def link vimHiStartStop vimHiTerm
 hi def link vimHiTerm  Type
 hi def link vimHLGroup vimGroup
 hi def link vimHLMod PreProc
 hi def link vimInsert  vimString
 hi def link vimIskSep  Delimiter
 hi def link vimKeyCode vimSpecFile
 hi def link vimKeyword Statement
 hi def link vimLet vimCommand
 hi def link vimLineComment vimComment
 hi def link vimMapBang vimCommand
 hi def link vimMapModKey vimFuncSID
 hi def link vimMapMod  vimBracket
 hi def link vimMap vimCommand
 hi def link vimMark  Number
 hi def link vimMarkNumber  vimNumber
 hi def link vimMenuMod vimMapMod
 hi def link vimMenuNameMore  vimMenuName
 hi def link vimMenuName  PreProc
 hi def link vimMtchComment vimComment
 hi def link vimNorm  vimCommand
 hi def link vimNotation  Special
 hi def link vimNotFunc vimCommand
 hi def link vimNotPatSep vimString
 hi def link vimNumber  Number
 hi def link vimOper  Operator
 hi def link vimOption  PreProc
 hi def link vimParenSep  Delimiter
 hi def link vimPatSepR vimPatSep
 hi def link vimPatSep  SpecialChar
 hi def link vimPatSepZone  vimString
 hi def link vimPatSepZ vimPatSep
 hi def link vimPattern Type
 hi def link vimPlainMark vimMark
 hi def link vimPlainRegister vimRegister
 hi def link vimRegister  SpecialChar
 hi def link vimReturn  vimCommand
 hi def link vimScriptDelim Comment
 hi def link vimSearchDelim Statement
 hi def link vimSearch  vimString
 hi def link vimSep Delimiter
 hi def link vimSetMod  vimOption
 hi def link vimSetSep  Statement
 hi def link vimSetString vimString
 hi def link vimSpecFile  Identifier
 hi def link vimSpecFileMod vimSpecFile
 hi def link vimSpecial Type
 hi def link vimStatement Statement
 hi def link vimStdPlugin           vimCommand
 hi def link vimStringCont  vimString
 hi def link vimString  String
 hi def link vimStringEnd vimString
 hi def link vimSubstDelim  Delimiter
 hi def link vimSubstFlags  Special
 hi def link vimSubstSubstr SpecialChar
 hi def link vimSubstTwoBS  vimString
 hi def link vimSubst vimCommand
 hi def link vimSynCase Type
 hi def link vimSyncC Type
 hi def link vimSyncGroupName vimGroupName
 hi def link vimSyncGroup vimGroupName
 hi def link vimSyncKey Type
 hi def link vimSyncNone  Type
 hi def link vimSynContains vimSynOption
 hi def link vimSynKeyContainedin vimSynContains
 hi def link vimSynKeyOpt vimSynOption
 hi def link vimSynMtchGrp  vimSynOption
 hi def link vimSynMtchOpt  vimSynOption
 hi def link vimSynNextgroup  vimSynOption
 hi def link vimSynNotPatRange  vimSynRegPat
 hi def link vimSynOption Special
 hi def link vimSynPatRange vimString
 hi def link vimSynRegOpt vimSynOption
 hi def link vimSynRegPat vimString
 hi def link vimSynReg  Type
 hi def link vimSyntax  vimCommand
 hi def link vimSynType vimSpecial
 hi def link vimTodo  Todo
 hi def link vimUnmap vimMap
 hi def link vimUserAttrbCmpltFunc  Special
 hi def link vimUserAttrbCmplt  vimSpecial
 hi def link vimUserAttrbKey  vimOption
 hi def link vimUserAttrb vimSpecial
 hi def link vimUserCommand vimCommand
 " hi def link vimVar Identifier
 hi def link vimWarn  WarningMsg
endif

"}}}

let b:current_syntax = "vim"

" ---------------------------------------------------------------------
let &cpo = s:keepcpo
unlet s:keepcpo
" vim:ts=18 fdm=marker ft=vim