Skip to content

Instantly share code, notes, and snippets.

@mg979

mg979/vim.vim

Last active January 17, 2020 05:51
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save mg979/47b72ec3366ca482f85dbebe42caef6a to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save mg979/47b72ec3366ca482f85dbebe42caef6a to your computer and use it in GitHub Desktop.
Download ZIP
vim syntax file
Raw
vim.vim
" Vim reduced (and faster) syntax file
" Language: Vim 8.1 script
" Edits By: Gianmaria Bajo <[email protected]>
" Base File Author: Charles E. Campbell <[email protected]>
" 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
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment