Hello, Attached is a patch adding runtime files (syntax, indent, ftplugin, and an autoloaded completion script) for the Clojure programming language.
In 2007, Toralf Wittner posted a vim syntax script to the Clojure mailing list, and in 2008 Meikel Brandmeyer included it in VimClojure, a sophisticated Clojure development plugin. Meikel authored indent and ftplugin scripts for VimClojure and developed these files through 2012. Earlier this month¹ I became the maintainer for the static portion of VimClojure and re-released it as vim-clojure-static². I have since refined and prepared it for inclusion into the Vim source tree so that new Clojure users may have builtin support when editing Clojure (*.clj) and ClojureScript (*.cljs) files. I am eager to see Vim ship with Clojure support and am ready to answer any questions about the implementation. Thank you, Sung Pae ¹ https://groups.google.com/forum/?fromgroups=#!topic/vimclojure/B-UU8qctd5A ² https://github.com/guns/vim-clojure-static
diff --git a/runtime/autoload/clojurecomplete.vim b/runtime/autoload/clojurecomplete.vim new file mode 100644 index 0000000..c0ebaea --- /dev/null +++ b/runtime/autoload/clojurecomplete.vim @@ -0,0 +1,20 @@ +" Vim completion script +" Language: Clojure +" Maintainer: Sung Pae <[email protected]> +" URL: https://github.com/guns/vim-clojure-static +" License: Same as Vim +" Last Change: 30 January 2013 + +" Special forms and public vars in clojure.core +" Generated from https://github.com/guns/vim-clojure-static/blob/vim-release-001/vim_clojure_static.clj +" Clojure 1.5.0-RC4 +let s:words = ["*","*'","*1","*2","*3","*agent*","*allow-unresolved-vars*","*assert*","*clojure-version*","*command-line-args*","*compile-files*","*compile-path*","*compiler-options*","*data-readers*","*default-data-reader-fn*","*e","*err*","*file*","*flush-on-newline*","*fn-loader*","*in*","*math-context*","*ns*","*out*","*print-dup*","*print-length*","*print-level*","*print-meta*","*print-readably*","*read-eval*","*source-path*","*unchecked-math*","*use-context-classloader*","*verbose-defrecords*","*warn-on-reflection*","+","+'","-","-'","->","->>","->ArrayChunk","->Vec","->VecNode","->VecSeq","-cache-protocol-fn","-reset-methods",".","..","/","<","<=","=","==",">",">=","EMPTY-NODE","accessor","aclone","add-classpath","add-watch","agent","agent-error","agent-errors","aget","alength","alias","all-ns","alter","alter-meta!","alter-var-root","amap","ancestors","and","apply","areduce","array-map","as->","aset","aset-boolean","aset-byte","aset-char","aset-double","aset-float","aset-int","aset-long","aset-short","assert","assoc!","assoc","assoc-in","associative?","atom","await","await-for","await1","bases","bean","bigdec","bigint","biginteger","binding","bit-and","bit-and-not","bit-clear","bit-flip","bit-not","bit-or","bit-set","bit-shift-left","bit-shift-right","bit-test","bit-xor","boolean","boolean-array","booleans","bound-fn","bound-fn*","bound?","butlast","byte","byte-array","bytes","case","cast","catch","char","char-array","char-escape-string","char-name-string","char?","chars","chunk","chunk-append","chunk-buffer","chunk-cons","chunk-first","chunk-next","chunk-rest","chunked-seq?","class","class?","clear-agent-errors","clojure-version","coll?","comment","commute","comp","comparator","compare","compare-and-set!","compile","complement","concat","cond","cond->","cond->>","condp","conj!","conj","cons","constantly","construct-proxy","contains?","count","counted?","create-ns","create-struct","cycle","dec","dec'","decimal?","declare","def","default-data-readers","definline","definterface","defmacro","defmethod","defmulti","defn","defn-","defonce","defprotocol","defrecord","defstruct","deftype","delay","delay?","deliver","denominator","deref","derive","descendants","destructure","disj!","disj","dissoc!","dissoc","distinct","distinct?","do","doall","dorun","doseq","dosync","dotimes","doto","double","double-array","doubles","drop","drop-last","drop-while","empty","empty?","ensure","enumeration-seq","error-handler","error-mode","eval","even?","every-pred","every?","ex-data","ex-info","extend","extend-protocol","extend-type","extenders","extends?","false?","ffirst","file-seq","filter","filterv","finally","find","find-keyword","find-ns","find-protocol-impl","find-protocol-method","find-var","first","flatten","float","float-array","float?","floats","flush","fn","fn","fn?","fnext","fnil","for","force","format","frequencies","future","future-call","future-cancel","future-cancelled?","future-done?","future?","gen-class","gen-interface","gensym","get","get-in","get-method","get-proxy-class","get-thread-bindings","get-validator","group-by","hash","hash-combine","hash-map","hash-set","identical?","identity","if","if-let","if-not","ifn?","import","in-ns","inc","inc'","init-proxy","instance?","int","int-array","integer?","interleave","intern","interpose","into","into-array","ints","io!","isa?","iterate","iterator-seq","juxt","keep","keep-indexed","key","keys","keyword","keyword?","last","lazy-cat","lazy-seq","let","let","letfn","line-seq","list","list*","list?","load","load-file","load-reader","load-string","loaded-libs","locking","long","long-array","longs","loop","loop","macroexpand","macroexpand-1","make-array","make-hierarchy","map","map-indexed","map?","mapcat","mapv","max","max-key","memfn","memoize","merge","merge-with","meta","method-sig","methods","min","min-key","mod","monitor-enter","monitor-exit","munge","name","namespace","namespace-munge","neg?","new","newline","next","nfirst","nil?","nnext","not","not-any?","not-empty","not-every?","not=","ns","ns-aliases","ns-imports","ns-interns","ns-map","ns-name","ns-publics","ns-refers","ns-resolve","ns-unalias","ns-unmap","nth","nthnext","nthrest","num","number?","numerator","object-array","odd?","or","parents","partial","partition","partition-all","partition-by","pcalls","peek","persistent!","pmap","pop!","pop","pop-thread-bindings","pos?","pr","pr-str","prefer-method","prefers","primitives-classnames","print","print-ctor","print-dup","print-method","print-simple","print-str","printf","println","println-str","prn","prn-str","promise","proxy","proxy-call-with-super","proxy-mappings","proxy-name","proxy-super","push-thread-bindings","pvalues","quot","quote","rand","rand-int","rand-nth","range","ratio?","rational?","rationalize","re-find","re-groups","re-matcher","re-matches","re-pattern","re-seq","read","read-line","read-string","realized?","recur","reduce","reduce-kv","reduced","reduced?","reductions","ref","ref-history-count","ref-max-history","ref-min-history","ref-set","refer","refer-clojure","reify","release-pending-sends","rem","remove","remove-all-methods","remove-method","remove-ns","remove-watch","repeat","repeatedly","replace","replicate","require","reset!","reset-meta!","resolve","rest","restart-agent","resultset-seq","reverse","reversible?","rseq","rsubseq","satisfies?","second","select-keys","send","send-off","send-via","seq","seq?","seque","sequence","sequential?","set!","set","set-agent-send-executor!","set-agent-send-off-executor!","set-error-handler!","set-error-mode!","set-validator!","set?","short","short-array","shorts","shuffle","shutdown-agents","slurp","some","some->","some->>","some-fn","sort","sort-by","sorted-map","sorted-map-by","sorted-set","sorted-set-by","sorted?","special-symbol?","spit","split-at","split-with","str","string?","struct","struct-map","subs","subseq","subvec","supers","swap!","symbol","symbol?","sync","take","take-last","take-nth","take-while","test","the-ns","thread-bound?","throw","time","to-array","to-array-2d","trampoline","transient","tree-seq","true?","try","type","unchecked-add","unchecked-add-int","unchecked-byte","unchecked-char","unchecked-dec","unchecked-dec-int","unchecked-divide-int","unchecked-double","unchecked-float","unchecked-inc","unchecked-inc-int","unchecked-int","unchecked-long","unchecked-multiply","unchecked-multiply-int","unchecked-negate","unchecked-negate-int","unchecked-remainder-int","unchecked-short","unchecked-subtract","unchecked-subtract-int","underive","unquote","unquote-splicing","update-in","update-proxy","use","val","vals","var","var-get","var-set","var?","vary-meta","vec","vector","vector-of","vector?","when","when-first","when-let","when-not","while","with-bindings","with-bindings*","with-in-str","with-loading-context","with-local-vars","with-meta","with-open","with-out-str","with-precision","with-redefs","with-redefs-fn","xml-seq","zero?","zipmap"] + +" Simple word completion omnifunc +function! clojurecomplete#Complete(findstart, base) + if a:findstart + return searchpos('\<', 'bnW', line('.'))[1] - 1 + else + return { 'words': filter(copy(s:words), 'v:val =~ "\\V\\^' . a:base . '"') } + endif +endfunction diff --git a/runtime/doc/indent.txt b/runtime/doc/indent.txt index 6a43896..022e212 100644 --- a/runtime/doc/indent.txt +++ b/runtime/doc/indent.txt @@ -577,6 +577,106 @@ $VIMRUNTIME/indent directory for examples. REMARKS ABOUT SPECIFIC INDENT FILES ~ +CLOJURE *ft-clojure-indent* *clojure-indent* + +Clojure indentation differs somewhat from traditional Lisps, due in part to +the use of square and curly brackets, and otherwise by community convention. +These conventions are not always universally followed, so the Clojure indent +script offers a few configurable options, listed below. + +If the current vim does not include searchpairpos(), the indent script falls +back to normal 'lisp' indenting, and the following options are ignored. + + *g:clojure_maxlines* + +Set maximum scan distance of searchpairpos(). Larger values trade performance +for correctness when dealing with very long forms. A value of 0 will scan +without limits. +> + " Default + let g:clojure_maxlines = 100 +< + + *g:clojure_fuzzy_indent* + *g:clojure_fuzzy_indent_patterns* + *g:clojure_fuzzy_indent_blacklist* + +The 'lispwords' option is a list of comma-separated words that mark special +forms whose subforms must be indented with two spaces. + +For example: +> + (defn bad [] + "Incorrect indentation") + + (defn good [] + "Correct indentation") +< +If you would like to specify 'lispwords' with a |pattern| instead, you can use +the fuzzy indent feature: +> + " Default + let g:clojure_fuzzy_indent = 1 + let g:clojure_fuzzy_indent_patterns = ['^with', '^def', '^let'] + let g:clojure_fuzzy_indent_blacklist = + \ ['-fn$', '\v^with-%(meta|out-str|loading-context)$'] + + " Legacy comma-delimited string version; the list format above is + " recommended. Note that patterns are implicitly anchored with ^ and $ + let g:clojure_fuzzy_indent_patterns = 'with.*,def.*,let.*' +< +|g:clojure_fuzzy_indent_patterns| and |g:clojure_fuzzy_indent_blacklist| are +|Lists| of patterns that will be matched against the unquoted, unqualified +symbol at the head of a list. This means that a pattern like "^foo" will match +all these candidates: "foobar", "my.ns/foobar", and "#'foobar". + +Each candidate word is tested for special treatment in this order: + + 1. Return true if word is literally in 'lispwords' + 2. Return false if word matches a pattern in + |g:clojure_fuzzy_indent_blacklist| + 3. Return true if word matches a pattern in + |g:clojure_fuzzy_indent_patterns| + 4. Return false and indent normally otherwise + + *g:clojure_special_indent_words* + +Some forms in Clojure are indented so that every subform is indented only two +spaces, regardless of 'lispwords'. If you have a custom construct that should +be indented in this idiosyncratic fashion, you can add your symbols to the +default list below. +> + " Default + let g:clojure_special_indent_words = + \ 'deftype,defrecord,reify,proxy,extend-type,extend-protocol,letfn' +< + + *g:clojure_align_multiline_strings* + +Align subsequent lines in multiline strings to the column after the opening +quote, instead of the same column. + +For example: +> + (def default + "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do + eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut + enim ad minim veniam, quis nostrud exercitation ullamco laboris + nisi ut aliquip ex ea commodo consequat.") + + (def aligned + "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do + eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut + enim ad minim veniam, quis nostrud exercitation ullamco laboris + nisi ut aliquip ex ea commodo consequat.") +< +This option is off by default. +> + " Default + let g:clojure_align_multiline_strings = 0 +< + + FORTRAN *ft-fortran-indent* Block if, select case, where, and forall constructs are indented. So are diff --git a/runtime/filetype.vim b/runtime/filetype.vim index 221c0ca..c0019e9 100644 --- a/runtime/filetype.vim +++ b/runtime/filetype.vim @@ -489,6 +489,9 @@ au BufNewFile,BufRead *.prg \ setf clipper | \ endif +" Clojure +au BufNewFile,BufRead *.clj,*.cljs setf clojure + " Cmake au BufNewFile,BufRead CMakeLists.txt,*.cmake,*.cmake.in setf cmake diff --git a/runtime/ftplugin/clojure.vim b/runtime/ftplugin/clojure.vim new file mode 100644 index 0000000..91aba80 --- /dev/null +++ b/runtime/ftplugin/clojure.vim @@ -0,0 +1,79 @@ +" Vim filetype plugin file +" Language: Clojure +" Author: Meikel Brandmeyer <[email protected]> +" +" Maintainer: Sung Pae <[email protected]> +" URL: https://github.com/guns/vim-clojure-static +" License: Same as Vim +" Last Change: 30 January 2013 + +" Only do this when not done yet for this buffer +if exists("b:did_ftplugin") + finish +endif +let b:did_ftplugin = 1 + +let s:cpo_save = &cpo +set cpo&vim + +let b:undo_ftplugin = 'setlocal define< formatoptions< comments< commentstring<' + +" There will be false positives, but this is better than missing the whole set +" of user-defined def* definitions. +setlocal define=\\v[(/]def(ault)@!\\S* + +" Remove 't' from 'formatoptions' to avoid auto-wrapping code. The '+=croql' +" is standard ftplugin boilerplate, although it is arguably intrusive. +setlocal formatoptions-=t formatoptions+=croql + +" Lisp comments are routinely nested (e.g. ;;; SECTION HEADING) +setlocal comments=n:; +setlocal commentstring=;\ %s + +" Provide insert mode completions for special forms and clojure.core. As +" 'omnifunc' is set by popular Clojure REPL client plugins, we also set +" 'completefunc' so that the user has some form of completion available when +" 'omnifunc' is set and no REPL connection exists. +for s:setting in ['omnifunc', 'completefunc'] + if exists('&' . s:setting) && empty(eval('&' . s:setting)) + execute 'setlocal ' . s:setting . '=clojurecomplete#Complete' + let b:undo_ftplugin .= ' | setlocal ' . s:setting . '<' + endif +endfor + +" Take all directories of the CLOJURE_SOURCE_DIRS environment variable +" and add them to the path option. +" +" This is a legacy option for VimClojure users. +if exists('$CLOJURE_SOURCE_DIRS') + for s:dir in split($CLOJURE_SOURCE_DIRS, (has("win32") || has("win64")) ? ';' : ':') + let s:dir = fnameescape(s:dir) + " Whitespace escaping for Windows + let s:dir = substitute(s:dir, '\', '\\\\', 'g') + let s:dir = substitute(s:dir, '\ ', '\\ ', 'g') + execute "setlocal path+=" . s:dir . "/**" + endfor + let b:undo_ftplugin .= ' | setlocal path<' +endif + +" Skip brackets in ignored syntax regions when using the % command +if exists('loaded_matchit') + let b:match_words = &matchpairs + let b:match_skip = 's:comment\|string\|regex\|character' + let b:undo_ftplugin .= ' | unlet! b:match_words b:match_skip' +endif + +" Win32 can filter files in the browse dialog +if has("gui_win32") && !exists("b:browsefilter") + let b:browsefilter = "Clojure Source Files (*.clj)\t*.clj\n" . + \ "ClojureScript Source Files (*.cljs)\t*.cljs\n" . + \ "Java Source Files (*.java)\t*.java\n" . + \ "All Files (*.*)\t*.*\n" + let b:undo_ftplugin .= ' | unlet! b:browsefilter' +endif + +let &cpo = s:cpo_save + +unlet! s:cpo_save s:setting s:dir + +" vim:sts=4 sw=4 et: diff --git a/runtime/indent/clojure.vim b/runtime/indent/clojure.vim new file mode 100644 index 0000000..9a00fb3 --- /dev/null +++ b/runtime/indent/clojure.vim @@ -0,0 +1,398 @@ +" Vim indent file +" Language: Clojure +" Author: Meikel Brandmeyer <[email protected]> +" URL: http://kotka.de/projects/clojure/vimclojure.html +" +" Maintainer: Sung Pae <[email protected]> +" URL: https://github.com/guns/vim-clojure-static +" License: Same as Vim +" Last Change: 30 January 2013 + +" Only load this indent file when no other was loaded. +if exists("b:did_indent") + finish +endif +let b:did_indent = 1 + +let s:save_cpo = &cpo +set cpo&vim + +let b:undo_indent = 'setlocal autoindent< smartindent< lispwords< expandtab< softtabstop< shiftwidth< indentexpr< indentkeys<' + +setlocal noautoindent nosmartindent +setlocal softtabstop=2 shiftwidth=2 expandtab +setlocal indentkeys=!,o,O + +if exists("*searchpairpos") + + if !exists('g:clojure_maxlines') + let g:clojure_maxlines = 100 + endif + + if !exists('g:clojure_fuzzy_indent') + let g:clojure_fuzzy_indent = 1 + endif + + if !exists('g:clojure_fuzzy_indent_patterns') + let g:clojure_fuzzy_indent_patterns = ['^with', '^def', '^let'] + endif + + if !exists('g:clojure_fuzzy_indent_blacklist') + let g:clojure_fuzzy_indent_blacklist = ['-fn$', '\v^with-%(meta|out-str|loading-context)$'] + endif + + if !exists('g:clojure_special_indent_words') + let g:clojure_special_indent_words = 'deftype,defrecord,reify,proxy,extend-type,extend-protocol,letfn' + endif + + if !exists('g:clojure_align_multiline_strings') + let g:clojure_align_multiline_strings = 0 + endif + + function! s:SynIdName() + return synIDattr(synID(line("."), col("."), 0), "name") + endfunction + + function! s:CurrentChar() + return getline('.')[col('.')-1] + endfunction + + function! s:CurrentWord() + return getline('.')[col('.')-1 : searchpos('\v>', 'n', line('.'))[1]-2] + endfunction + + function! s:IsParen() + return s:CurrentChar() =~ '\v[\(\)\[\]\{\}]' && + \ s:SynIdName() !~? '\vstring|comment' + endfunction + + " Returns 1 if string matches a pattern in 'patterns', which may be a + " list of patterns, or a comma-delimited string of implicitly anchored + " patterns. + function! s:MatchesOne(patterns, string) + let list = type(a:patterns) == type([]) + \ ? a:patterns + \ : map(split(a:patterns, ','), '"^" . v:val . "$"') + for pat in list + if a:string =~ pat | return 1 | endif + endfor + endfunction + + function! s:SavePosition() + let [ _b, l, c, _o ] = getpos(".") + let b = bufnr("%") + return [b, l, c] + endfunction + + function! s:RestorePosition(value) + let [b, l, c] = a:value + if bufnr("%") != b + execute b "buffer!" + endif + call setpos(".", [0, l, c, 0]) + endfunction + + function! s:MatchPairs(open, close, stopat) + " Stop only on vector and map [ resp. {. Ignore the ones in strings and + " comments. + if a:stopat == 0 + let stopat = max([line(".") - g:clojure_maxlines, 0]) + else + let stopat = a:stopat + endif + + let pos = searchpairpos(a:open, '', a:close, 'bWn', "!s:IsParen()", stopat) + return [pos[0], virtcol(pos)] + endfunction + + function! s:ClojureCheckForStringWorker() + " Check whether there is the last character of the previous line is + " highlighted as a string. If so, we check whether it's a ". In this + " case we have to check also the previous character. The " might be the + " closing one. In case the we are still in the string, we search for the + " opening ". If this is not found we take the indent of the line. + let nb = prevnonblank(v:lnum - 1) + + if nb == 0 + return -1 + endif + + call cursor(nb, 0) + call cursor(0, col("$") - 1) + if s:SynIdName() !~? "string" + return -1 + endif + + " This will not work for a " in the first column... + if s:CurrentChar() == '"' + call cursor(0, col("$") - 2) + if s:SynIdName() !~? "string" + return -1 + endif + if s:CurrentChar() != '\\' + return -1 + endif + call cursor(0, col("$") - 1) + endif + + let p = searchpos('\(^\|[^\\]\)\zs"', 'bW') + + if p != [0, 0] + return p[1] - 1 + endif + + return indent(".") + endfunction + + function! s:CheckForString() + let pos = s:SavePosition() + try + let val = s:ClojureCheckForStringWorker() + finally + call s:RestorePosition(pos) + endtry + return val + endfunction + + function! s:ClojureIsMethodSpecialCaseWorker(position) + " Find the next enclosing form. + call search('\S', 'Wb') + + " Special case: we are at a '(('. + if s:CurrentChar() == '(' + return 0 + endif + call cursor(a:position) + + let nextParen = s:MatchPairs('(', ')', 0) + + " Special case: we are now at toplevel. + if nextParen == [0, 0] + return 0 + endif + call cursor(nextParen) + + call search('\S', 'W') + if g:clojure_special_indent_words =~ '\<' . s:CurrentWord() . '\>' + return 1 + endif + + return 0 + endfunction + + function! s:IsMethodSpecialCase(position) + let pos = s:SavePosition() + try + let val = s:ClojureIsMethodSpecialCaseWorker(a:position) + finally + call s:RestorePosition(pos) + endtry + return val + endfunction + + function! GetClojureIndent() + " Get rid of special case. + if line(".") == 1 + return 0 + endif + + " We have to apply some heuristics here to figure out, whether to use + " normal lisp indenting or not. + let i = s:CheckForString() + if i > -1 + return i + !!g:clojure_align_multiline_strings + endif + + call cursor(0, 1) + + " Find the next enclosing [ or {. We can limit the second search + " to the line, where the [ was found. If no [ was there this is + " zero and we search for an enclosing {. + let paren = s:MatchPairs('(', ')', 0) + let bracket = s:MatchPairs('\[', '\]', paren[0]) + let curly = s:MatchPairs('{', '}', bracket[0]) + + " In case the curly brace is on a line later then the [ or - in + " case they are on the same line - in a higher column, we take the + " curly indent. + if curly[0] > bracket[0] || curly[1] > bracket[1] + if curly[0] > paren[0] || curly[1] > paren[1] + return curly[1] + endif + endif + + " If the curly was not chosen, we take the bracket indent - if + " there was one. + if bracket[0] > paren[0] || bracket[1] > paren[1] + return bracket[1] + endif + + " There are neither { nor [ nor (, ie. we are at the toplevel. + if paren == [0, 0] + return 0 + endif + + " Now we have to reimplement lispindent. This is surprisingly easy, as + " soon as one has access to syntax items. + " + " - Check whether we are in a special position after a word in + " g:clojure_special_indent_words. These are special cases. + " - Get the next keyword after the (. + " - If its first character is also a (, we have another sexp and align + " one column to the right of the unmatched (. + " - In case it is in lispwords, we indent the next line to the column of + " the ( + sw. + " - If not, we check whether it is last word in the line. In that case + " we again use ( + sw for indent. + " - In any other case we use the column of the end of the word + 2. + call cursor(paren) + + if s:IsMethodSpecialCase(paren) + return paren[1] + &shiftwidth - 1 + endif + + " In case we are at the last character, we use the paren position. + if col("$") - 1 == paren[1] + return paren[1] + endif + + " In case after the paren is a whitespace, we search for the next word. + normal! l + if s:CurrentChar() == ' ' + normal! w + endif + + " If we moved to another line, there is no word after the (. We + " use the ( position for indent. + if line(".") > paren[0] + return paren[1] + endif + + " We still have to check, whether the keyword starts with a (, [ or {. + " In that case we use the ( position for indent. + let w = s:CurrentWord() + if stridx('([{', w[0]) > -1 + return paren[1] + endif + + " Test words without namespace qualifiers and leading reader macro + " metacharacters. + " + " e.g. clojure.core/defn and #'defn should both indent like defn. + let ww = substitute(w, "\\v%(.*/|[#'`~@^,]*)(.*)", '\1', '') + + if &lispwords =~ '\V\<' . ww . '\>' + return paren[1] + &shiftwidth - 1 + endif + + if g:clojure_fuzzy_indent + \ && !s:MatchesOne(g:clojure_fuzzy_indent_blacklist, ww) + \ && s:MatchesOne(g:clojure_fuzzy_indent_patterns, ww) + return paren[1] + &shiftwidth - 1 + endif + + normal! W + if paren[0] < line(".") + return paren[1] + &shiftwidth - 1 + endif + + normal! ge + return virtcol(".") + 1 + endfunction + + setlocal indentexpr=GetClojureIndent() + +else + + " In case we have searchpairpos not available we fall back to + " normal lisp indenting. + setlocal indentexpr= + setlocal lisp + let b:undo_indent .= '| setlocal lisp<' + +endif + +" Specially indented symbols from clojure.core and clojure.test. +" +" Clojure symbols are indented in the defn style when they: +" +" * Define vars and anonymous functions +" * Create new lexical scopes or scopes with altered environments +" * Create conditional branches from a predicate function or value +" +" The arglists for these functions are generally in the form of [x & body]; +" Functions that accept a flat list of forms do not treat the first argument +" specially and hence are not indented specially. + +" Definitions +setlocal lispwords= +setlocal lispwords+=bound-fn +setlocal lispwords+=def +setlocal lispwords+=definline +setlocal lispwords+=definterface +setlocal lispwords+=defmacro +setlocal lispwords+=defmethod +setlocal lispwords+=defmulti +setlocal lispwords+=defn +setlocal lispwords+=defn- +setlocal lispwords+=defonce +setlocal lispwords+=defprotocol +setlocal lispwords+=defrecord +setlocal lispwords+=defstruct +setlocal lispwords+=deftest " clojure.test +setlocal lispwords+=deftest- " clojure.test +setlocal lispwords+=deftype +setlocal lispwords+=extend +setlocal lispwords+=extend-protocol +setlocal lispwords+=extend-type +setlocal lispwords+=fn +setlocal lispwords+=ns +setlocal lispwords+=proxy +setlocal lispwords+=reify +setlocal lispwords+=set-test " clojure.test + +" Binding forms +setlocal lispwords+=as-> +setlocal lispwords+=binding +setlocal lispwords+=doall +setlocal lispwords+=dorun +setlocal lispwords+=doseq +setlocal lispwords+=dotimes +setlocal lispwords+=doto +setlocal lispwords+=for +setlocal lispwords+=if-let +setlocal lispwords+=let +setlocal lispwords+=letfn +setlocal lispwords+=locking +setlocal lispwords+=loop +setlocal lispwords+=testing " clojure.test +setlocal lispwords+=when-first +setlocal lispwords+=when-let +setlocal lispwords+=with-bindings +setlocal lispwords+=with-in-str +setlocal lispwords+=with-local-vars +setlocal lispwords+=with-open +setlocal lispwords+=with-precision +setlocal lispwords+=with-redefs +setlocal lispwords+=with-redefs-fn +setlocal lispwords+=with-test " clojure.test + +" Conditional branching +setlocal lispwords+=case +setlocal lispwords+=cond-> +setlocal lispwords+=cond->> +setlocal lispwords+=condp +setlocal lispwords+=if +setlocal lispwords+=if-not +setlocal lispwords+=when +setlocal lispwords+=when-not +setlocal lispwords+=while + +" Exception handling +setlocal lispwords+=catch +setlocal lispwords+=try " For aesthetics when enclosing single line + +let &cpo = s:save_cpo +unlet! s:save_cpo + +" vim:sts=4 sw=4 et: diff --git a/runtime/syntax/clojure.vim b/runtime/syntax/clojure.vim new file mode 100644 index 0000000..f610ade --- /dev/null +++ b/runtime/syntax/clojure.vim @@ -0,0 +1,127 @@ +" Vim syntax file +" Language: Clojure +" Authors: Toralf Wittner <[email protected]> +" modified by Meikel Brandmeyer <[email protected]> +" URL: http://kotka.de/projects/clojure/vimclojure.html +" +" Maintainer: Sung Pae <[email protected]> +" URL: https://github.com/guns/vim-clojure-static +" License: Same as Vim +" Last Change: 30 January 2013 + +if version < 600 + syntax clear +elseif exists("b:current_syntax") + finish +endif + +setlocal iskeyword+=?,-,*,!,+,/,=,<,>,.,:,$ + +" Highlight superfluous closing parens, brackets and braces. +syntax match clojureError "]\|}\|)" + +" Generated from https://github.com/guns/vim-clojure-static/blob/vim-release-001/vim_clojure_static.clj +" Clojure 1.5.0-RC4 +syntax keyword clojureConstant nil +syntax keyword clojureBoolean false true +syntax keyword clojureSpecial . catch clojure.core/fn clojure.core/let clojure.core/loop def do finally fn if let loop monitor-enter monitor-exit new quote recur set! throw try var +syntax keyword clojureException catch finally throw try +syntax keyword clojureCond case clojure.core/case clojure.core/cond clojure.core/cond-> clojure.core/cond->> clojure.core/condp clojure.core/if-let clojure.core/if-not clojure.core/when clojure.core/when-first clojure.core/when-let clojure.core/when-not cond cond-> cond->> condp if-let if-not when when-first when-let when-not +syntax keyword clojureRepeat clojure.core/doall clojure.core/dorun clojure.core/doseq clojure.core/dotimes clojure.core/while doall dorun doseq dotimes while +syntax keyword clojureDefine clojure.core/definline clojure.core/definterface clojure.core/defmacro clojure.core/defmethod clojure.core/defmulti clojure.core/defn clojure.core/defn- clojure.core/defonce clojure.core/defprotocol clojure.core/defrecord clojure.core/defstruct clojure.core/deftype definline definterface defmacro defmethod defmulti defn defn- defonce defprotocol defrecord defstruct deftype +syntax keyword clojureMacro -> ->> .. amap and areduce as-> assert binding bound-fn clojure.core/-> clojure.core/->> clojure.core/.. clojure.core/amap clojure.core/and clojure.core/areduce clojure.core/as-> clojure.core/assert clojure.core/binding clojure.core/bound-fn clojure.core/comment clojure.core/declare clojure.core/delay clojure.core/dosync clojure.core/doto clojure.core/extend-protocol clojure.core/extend-type clojure.core/for clojure.core/future clojure.core/gen-class clojure.core/gen-interface clojure.core/import clojure.core/io! clojure.core/lazy-cat clojure.core/lazy-seq clojure.core/letfn clojure.core/locking clojure.core/memfn clojure.core/ns clojure.core/or clojure.core/proxy clojure.core/proxy-super clojure.core/pvalues clojure.core/refer-clojure clojure.core/reify clojure.core/some-> clojure.core/some->> clojure.core/sync clojure.core/time clojure.core/with-bindings clojure.core/with-in-str clojure.core/with-loading-context clojure.core/with-local-vars clojure.core/with-open clojure.core/with-out-str clojure.core/with-precision clojure.core/with-redefs comment declare delay dosync doto extend-protocol extend-type for future gen-class gen-interface import io! lazy-cat lazy-seq letfn locking memfn ns or proxy proxy-super pvalues refer-clojure reify some-> some->> sync time with-bindings with-in-str with-loading-context with-local-vars with-open with-out-str with-precision with-redefs +syntax keyword clojureFunc * *' + +' - -' ->ArrayChunk ->Vec ->VecNode ->VecSeq -cache-protocol-fn -reset-methods / < <= = == > >= accessor aclone add-classpath add-watch agent agent-error agent-errors aget alength alias all-ns alter alter-meta! alter-var-root ancestors apply array-map aset aset-boolean aset-byte aset-char aset-double aset-float aset-int aset-long aset-short assoc assoc! assoc-in associative? atom await await-for await1 bases bean bigdec bigint biginteger bit-and bit-and-not bit-clear bit-flip bit-not bit-or bit-set bit-shift-left bit-shift-right bit-test bit-xor boolean boolean-array booleans bound-fn* bound? butlast byte byte-array bytes cast char char-array char? chars chunk chunk-append chunk-buffer chunk-cons chunk-first chunk-next chunk-rest chunked-seq? class class? clear-agent-errors clojure-version clojure.core/* clojure.core/*' clojure.core/+ clojure.core/+' clojure.core/- clojure.core/-' clojure.core/->ArrayChunk clojure.core/->Vec clojure.core/->VecNode clojure.core/->VecSeq clojure.core/-cache-protocol-fn clojure.core/-reset-methods clojure.core// clojure.core/< clojure.core/<= clojure.core/= clojure.core/== clojure.core/> clojure.core/>= clojure.core/accessor clojure.core/aclone clojure.core/add-classpath clojure.core/add-watch clojure.core/agent clojure.core/agent-error clojure.core/agent-errors clojure.core/aget clojure.core/alength clojure.core/alias clojure.core/all-ns clojure.core/alter clojure.core/alter-meta! clojure.core/alter-var-root clojure.core/ancestors clojure.core/apply clojure.core/array-map clojure.core/aset clojure.core/aset-boolean clojure.core/aset-byte clojure.core/aset-char clojure.core/aset-double clojure.core/aset-float clojure.core/aset-int clojure.core/aset-long clojure.core/aset-short clojure.core/assoc clojure.core/assoc! clojure.core/assoc-in clojure.core/associative? clojure.core/atom clojure.core/await clojure.core/await-for clojure.core/await1 clojure.core/bases clojure.core/bean clojure.core/bigdec clojure.core/bigint clojure.core/biginteger clojure.core/bit-and clojure.core/bit-and-not clojure.core/bit-clear clojure.core/bit-flip clojure.core/bit-not clojure.core/bit-or clojure.core/bit-set clojure.core/bit-shift-left clojure.core/bit-shift-right clojure.core/bit-test clojure.core/bit-xor clojure.core/boolean clojure.core/boolean-array clojure.core/booleans clojure.core/bound-fn* clojure.core/bound? clojure.core/butlast clojure.core/byte clojure.core/byte-array clojure.core/bytes clojure.core/cast clojure.core/char clojure.core/char-array clojure.core/char? clojure.core/chars clojure.core/chunk clojure.core/chunk-append clojure.core/chunk-buffer clojure.core/chunk-cons clojure.core/chunk-first clojure.core/chunk-next clojure.core/chunk-rest clojure.core/chunked-seq? clojure.core/class clojure.core/class? clojure.core/clear-agent-errors clojure.core/clojure-version clojure.core/coll? clojure.core/commute clojure.core/comp clojure.core/comparator clojure.core/compare clojure.core/compare-and-set! clojure.core/compile clojure.core/complement clojure.core/concat clojure.core/conj clojure.core/conj! clojure.core/cons clojure.core/constantly clojure.core/construct-proxy clojure.core/contains? clojure.core/count clojure.core/counted? clojure.core/create-ns clojure.core/create-struct clojure.core/cycle clojure.core/dec clojure.core/dec' clojure.core/decimal? clojure.core/delay? clojure.core/deliver clojure.core/denominator clojure.core/deref clojure.core/derive clojure.core/descendants clojure.core/destructure clojure.core/disj clojure.core/disj! clojure.core/dissoc clojure.core/dissoc! clojure.core/distinct clojure.core/distinct? clojure.core/double clojure.core/double-array clojure.core/doubles clojure.core/drop clojure.core/drop-last clojure.core/drop-while clojure.core/empty clojure.core/empty? clojure.core/ensure clojure.core/enumeration-seq clojure.core/error-handler clojure.core/error-mode clojure.core/eval clojure.core/even? clojure.core/every-pred clojure.core/every? clojure.core/ex-data clojure.core/ex-info clojure.core/extend clojure.core/extenders clojure.core/extends? clojure.core/false? clojure.core/ffirst clojure.core/file-seq clojure.core/filter clojure.core/filterv clojure.core/find clojure.core/find-keyword clojure.core/find-ns clojure.core/find-protocol-impl clojure.core/find-protocol-method clojure.core/find-var clojure.core/first clojure.core/flatten clojure.core/float clojure.core/float-array clojure.core/float? clojure.core/floats clojure.core/flush clojure.core/fn? clojure.core/fnext clojure.core/fnil clojure.core/force clojure.core/format clojure.core/frequencies clojure.core/future-call clojure.core/future-cancel clojure.core/future-cancelled? clojure.core/future-done? clojure.core/future? clojure.core/gensym clojure.core/get clojure.core/get-in clojure.core/get-method clojure.core/get-proxy-class clojure.core/get-thread-bindings clojure.core/get-validator clojure.core/group-by clojure.core/hash clojure.core/hash-combine clojure.core/hash-map clojure.core/hash-set clojure.core/identical? clojure.core/identity clojure.core/ifn? clojure.core/in-ns clojure.core/inc clojure.core/inc' clojure.core/init-proxy clojure.core/instance? clojure.core/int clojure.core/int-array clojure.core/integer? clojure.core/interleave clojure.core/intern clojure.core/interpose clojure.core/into clojure.core/into-array clojure.core/ints clojure.core/isa? clojure.core/iterate clojure.core/iterator-seq clojure.core/juxt clojure.core/keep clojure.core/keep-indexed clojure.core/key clojure.core/keys clojure.core/keyword clojure.core/keyword? clojure.core/last clojure.core/line-seq clojure.core/list clojure.core/list* clojure.core/list? clojure.core/load clojure.core/load-file clojure.core/load-reader clojure.core/load-string clojure.core/loaded-libs clojure.core/long clojure.core/long-array clojure.core/longs clojure.core/macroexpand clojure.core/macroexpand-1 clojure.core/make-array clojure.core/make-hierarchy clojure.core/map clojure.core/map-indexed clojure.core/map? clojure.core/mapcat clojure.core/mapv clojure.core/max clojure.core/max-key clojure.core/memoize clojure.core/merge clojure.core/merge-with clojure.core/meta clojure.core/method-sig clojure.core/methods clojure.core/min clojure.core/min-key clojure.core/mod clojure.core/munge clojure.core/name clojure.core/namespace clojure.core/namespace-munge clojure.core/neg? clojure.core/newline clojure.core/next clojure.core/nfirst clojure.core/nil? clojure.core/nnext clojure.core/not clojure.core/not-any? clojure.core/not-empty clojure.core/not-every? clojure.core/not= clojure.core/ns-aliases clojure.core/ns-imports clojure.core/ns-interns clojure.core/ns-map clojure.core/ns-name clojure.core/ns-publics clojure.core/ns-refers clojure.core/ns-resolve clojure.core/ns-unalias clojure.core/ns-unmap clojure.core/nth clojure.core/nthnext clojure.core/nthrest clojure.core/num clojure.core/number? clojure.core/numerator clojure.core/object-array clojure.core/odd? clojure.core/parents clojure.core/partial clojure.core/partition clojure.core/partition-all clojure.core/partition-by clojure.core/pcalls clojure.core/peek clojure.core/persistent! clojure.core/pmap clojure.core/pop clojure.core/pop! clojure.core/pop-thread-bindings clojure.core/pos? clojure.core/pr clojure.core/pr-str clojure.core/prefer-method clojure.core/prefers clojure.core/print clojure.core/print-ctor clojure.core/print-simple clojure.core/print-str clojure.core/printf clojure.core/println clojure.core/println-str clojure.core/prn clojure.core/prn-str clojure.core/promise clojure.core/proxy-call-with-super clojure.core/proxy-mappings clojure.core/proxy-name clojure.core/push-thread-bindings clojure.core/quot clojure.core/rand clojure.core/rand-int clojure.core/rand-nth clojure.core/range clojure.core/ratio? clojure.core/rational? clojure.core/rationalize clojure.core/re-find clojure.core/re-groups clojure.core/re-matcher clojure.core/re-matches clojure.core/re-pattern clojure.core/re-seq clojure.core/read clojure.core/read-line clojure.core/read-string clojure.core/realized? clojure.core/reduce clojure.core/reduce-kv clojure.core/reduced clojure.core/reduced? clojure.core/reductions clojure.core/ref clojure.core/ref-history-count clojure.core/ref-max-history clojure.core/ref-min-history clojure.core/ref-set clojure.core/refer clojure.core/release-pending-sends clojure.core/rem clojure.core/remove clojure.core/remove-all-methods clojure.core/remove-method clojure.core/remove-ns clojure.core/remove-watch clojure.core/repeat clojure.core/repeatedly clojure.core/replace clojure.core/replicate clojure.core/require clojure.core/reset! clojure.core/reset-meta! clojure.core/resolve clojure.core/rest clojure.core/restart-agent clojure.core/resultset-seq clojure.core/reverse clojure.core/reversible? clojure.core/rseq clojure.core/rsubseq clojure.core/satisfies? clojure.core/second clojure.core/select-keys clojure.core/send clojure.core/send-off clojure.core/send-via clojure.core/seq clojure.core/seq? clojure.core/seque clojure.core/sequence clojure.core/sequential? clojure.core/set clojure.core/set-agent-send-executor! clojure.core/set-agent-send-off-executor! clojure.core/set-error-handler! clojure.core/set-error-mode! clojure.core/set-validator! clojure.core/set? clojure.core/short clojure.core/short-array clojure.core/shorts clojure.core/shuffle clojure.core/shutdown-agents clojure.core/slurp clojure.core/some clojure.core/some-fn clojure.core/sort clojure.core/sort-by clojure.core/sorted-map clojure.core/sorted-map-by clojure.core/sorted-set clojure.core/sorted-set-by clojure.core/sorted? clojure.core/special-symbol? clojure.core/spit clojure.core/split-at clojure.core/split-with clojure.core/str clojure.core/string? clojure.core/struct clojure.core/struct-map clojure.core/subs clojure.core/subseq clojure.core/subvec clojure.core/supers clojure.core/swap! clojure.core/symbol clojure.core/symbol? clojure.core/take clojure.core/take-last clojure.core/take-nth clojure.core/take-while clojure.core/test clojure.core/the-ns clojure.core/thread-bound? clojure.core/to-array clojure.core/to-array-2d clojure.core/trampoline clojure.core/transient clojure.core/tree-seq clojure.core/true? clojure.core/type clojure.core/unchecked-add clojure.core/unchecked-add-int clojure.core/unchecked-byte clojure.core/unchecked-char clojure.core/unchecked-dec clojure.core/unchecked-dec-int clojure.core/unchecked-divide-int clojure.core/unchecked-double clojure.core/unchecked-float clojure.core/unchecked-inc clojure.core/unchecked-inc-int clojure.core/unchecked-int clojure.core/unchecked-long clojure.core/unchecked-multiply clojure.core/unchecked-multiply-int clojure.core/unchecked-negate clojure.core/unchecked-negate-int clojure.core/unchecked-remainder-int clojure.core/unchecked-short clojure.core/unchecked-subtract clojure.core/unchecked-subtract-int clojure.core/underive clojure.core/update-in clojure.core/update-proxy clojure.core/use clojure.core/val clojure.core/vals clojure.core/var-get clojure.core/var-set clojure.core/var? clojure.core/vary-meta clojure.core/vec clojure.core/vector clojure.core/vector-of clojure.core/vector? clojure.core/with-bindings* clojure.core/with-meta clojure.core/with-redefs-fn clojure.core/xml-seq clojure.core/zero? clojure.core/zipmap coll? commute comp comparator compare compare-and-set! compile complement concat conj conj! cons constantly construct-proxy contains? count counted? create-ns create-struct cycle dec dec' decimal? delay? deliver denominator deref derive descendants destructure disj disj! dissoc dissoc! distinct distinct? double double-array doubles drop drop-last drop-while empty empty? ensure enumeration-seq error-handler error-mode eval even? every-pred every? ex-data ex-info extend extenders extends? false? ffirst file-seq filter filterv find find-keyword find-ns find-protocol-impl find-protocol-method find-var first flatten float float-array float? floats flush fn? fnext fnil force format frequencies future-call future-cancel future-cancelled? future-done? future? gensym get get-in get-method get-proxy-class get-thread-bindings get-validator group-by hash hash-combine hash-map hash-set identical? identity ifn? in-ns inc inc' init-proxy instance? int int-array integer? interleave intern interpose into into-array ints isa? iterate iterator-seq juxt keep keep-indexed key keys keyword keyword? last line-seq list list* list? load load-file load-reader load-string loaded-libs long long-array longs macroexpand macroexpand-1 make-array make-hierarchy map map-indexed map? mapcat mapv max max-key memoize merge merge-with meta method-sig methods min min-key mod munge name namespace namespace-munge neg? newline next nfirst nil? nnext not not-any? not-empty not-every? not= ns-aliases ns-imports ns-interns ns-map ns-name ns-publics ns-refers ns-resolve ns-unalias ns-unmap nth nthnext nthrest num number? numerator object-array odd? parents partial partition partition-all partition-by pcalls peek persistent! pmap pop pop! pop-thread-bindings pos? pr pr-str prefer-method prefers print print-ctor print-simple print-str printf println println-str prn prn-str promise proxy-call-with-super proxy-mappings proxy-name push-thread-bindings quot rand rand-int rand-nth range ratio? rational? rationalize re-find re-groups re-matcher re-matches re-pattern re-seq read read-line read-string realized? reduce reduce-kv reduced reduced? reductions ref ref-history-count ref-max-history ref-min-history ref-set refer release-pending-sends rem remove remove-all-methods remove-method remove-ns remove-watch repeat repeatedly replace replicate require reset! reset-meta! resolve rest restart-agent resultset-seq reverse reversible? rseq rsubseq satisfies? second select-keys send send-off send-via seq seq? seque sequence sequential? set set-agent-send-executor! set-agent-send-off-executor! set-error-handler! set-error-mode! set-validator! set? short short-array shorts shuffle shutdown-agents slurp some some-fn sort sort-by sorted-map sorted-map-by sorted-set sorted-set-by sorted? special-symbol? spit split-at split-with str string? struct struct-map subs subseq subvec supers swap! symbol symbol? take take-last take-nth take-while test the-ns thread-bound? to-array to-array-2d trampoline transient tree-seq true? type unchecked-add unchecked-add-int unchecked-byte unchecked-char unchecked-dec unchecked-dec-int unchecked-divide-int unchecked-double unchecked-float unchecked-inc unchecked-inc-int unchecked-int unchecked-long unchecked-multiply unchecked-multiply-int unchecked-negate unchecked-negate-int unchecked-remainder-int unchecked-short unchecked-subtract unchecked-subtract-int underive update-in update-proxy use val vals var-get var-set var? vary-meta vec vector vector-of vector? with-bindings* with-meta with-redefs-fn xml-seq zero? zipmap +syntax keyword clojureVariable *1 *2 *3 *agent* *allow-unresolved-vars* *assert* *clojure-version* *command-line-args* *compile-files* *compile-path* *compiler-options* *data-readers* *default-data-reader-fn* *e *err* *file* *flush-on-newline* *fn-loader* *in* *math-context* *ns* *out* *print-dup* *print-length* *print-level* *print-meta* *print-readably* *read-eval* *source-path* *unchecked-math* *use-context-classloader* *verbose-defrecords* *warn-on-reflection* EMPTY-NODE char-escape-string char-name-string clojure.core/*1 clojure.core/*2 clojure.core/*3 clojure.core/*agent* clojure.core/*allow-unresolved-vars* clojure.core/*assert* clojure.core/*clojure-version* clojure.core/*command-line-args* clojure.core/*compile-files* clojure.core/*compile-path* clojure.core/*compiler-options* clojure.core/*data-readers* clojure.core/*default-data-reader-fn* clojure.core/*e clojure.core/*err* clojure.core/*file* clojure.core/*flush-on-newline* clojure.core/*fn-loader* clojure.core/*in* clojure.core/*math-context* clojure.core/*ns* clojure.core/*out* clojure.core/*print-dup* clojure.core/*print-length* clojure.core/*print-level* clojure.core/*print-meta* clojure.core/*print-readably* clojure.core/*read-eval* clojure.core/*source-path* clojure.core/*unchecked-math* clojure.core/*use-context-classloader* clojure.core/*verbose-defrecords* clojure.core/*warn-on-reflection* clojure.core/EMPTY-NODE clojure.core/char-escape-string clojure.core/char-name-string clojure.core/default-data-readers clojure.core/primitives-classnames clojure.core/print-dup clojure.core/print-method clojure.core/unquote clojure.core/unquote-splicing default-data-readers primitives-classnames print-dup print-method unquote unquote-splicing + +syntax cluster clojureAtomCluster contains=clojureError,clojureFunc,clojureMacro,clojureCond,clojureDefine,clojureRepeat,clojureException,clojureConstant,clojureVariable,clojureSpecial,clojureKeyword,clojureString,clojureCharacter,clojureNumber,clojureBoolean,clojureQuote,clojureUnquote,clojureDispatch,clojureRegexp +syntax cluster clojureTopCluster contains=@NoSpell,@clojureAtomCluster,clojureComment,clojureSexp,clojureAnonFn,clojureVector,clojureMap,clojureSet + +syntax match clojureKeyword "\c:\{1,2}[a-z0-9?!\-_+*.=<>#$]\+\(/[a-z0-9?!\-_+*.=<>#$]\+\)\?" + +syntax region clojureString start=/L\="/ skip=/\\\\\|\\"/ end=/"/ + +syntax match clojureCharacter "\\." +syntax match clojureCharacter "\\[0-7]\{3\}" +syntax match clojureCharacter "\\u[0-9]\{4\}" +syntax match clojureCharacter "\\space" +syntax match clojureCharacter "\\tab" +syntax match clojureCharacter "\\newline" +syntax match clojureCharacter "\\return" +syntax match clojureCharacter "\\backspace" +syntax match clojureCharacter "\\formfeed" + +let s:radixChars = "0123456789abcdefghijklmnopqrstuvwxyz" +for s:radix in range(2, 36) + execute 'syntax match clojureNumber "\c\<-\?' . s:radix . 'r[' . strpart(s:radixChars, 0, s:radix) . ']\+\>"' +endfor +unlet! s:radixChars s:radix + +syntax match clojureNumber "\<-\=[0-9]\+\(\.[0-9]*\)\=\(M\|\([eE][-+]\?[0-9]\+\)\)\?\>" +syntax match clojureNumber "\<-\=[0-9]\+N\?\>" +syntax match clojureNumber "\<-\=0x[0-9a-fA-F]\+\>" +syntax match clojureNumber "\<-\=[0-9]\+/[0-9]\+\>" + +syntax match clojureQuote "\('\|`\)" +syntax match clojureUnquote "\(\~@\|\~\)" +syntax match clojureDispatch "\(#^\|#'\)" +syntax match clojureDispatch "\^" + +syntax match clojureAnonArg contained "%\(\d\|&\)\?" +syntax match clojureVarArg "&" + +syntax region clojureSexp matchgroup=clojureParen start="(" matchgroup=clojureParen end=")" contains=@clojureTopCluster +syntax region clojureAnonFn matchgroup=clojureParen start="#(" matchgroup=clojureParen end=")" contains=@clojureTopCluster,clojureAnonArg,clojureSexp +syntax region clojureVector matchgroup=clojureParen start="\[" matchgroup=clojureParen end="\]" contains=@clojureTopCluster,clojureVarArg,clojureSexp +syntax region clojureMap matchgroup=clojureParen start="{" matchgroup=clojureParen end="}" contains=@clojureTopCluster,clojureSexp +syntax region clojureSet matchgroup=clojureParen start="#{" matchgroup=clojureParen end="}" contains=@clojureTopCluster,clojureSexp + +syntax region clojureRegexp start=/L\=\#"/ skip=/\\\\\|\\"/ end=/"/ + +syntax keyword clojureTodo contained FIXME XXX TODO FIXME: XXX: TODO: +syntax match clojureComment contains=@Spell,clojureTodo ";.*$" +syntax match clojureComment "#!.*$" +syntax match clojureComment "#_" + +syntax sync fromstart + +if version >= 600 + command -nargs=+ HiLink highlight default link <args> +else + command -nargs=+ HiLink highlight link <args> +endif + +HiLink clojureConstant Constant +HiLink clojureBoolean Boolean +HiLink clojureCharacter Character +HiLink clojureKeyword Operator +HiLink clojureNumber Number +HiLink clojureString String +HiLink clojureRegexp Constant + +HiLink clojureVariable Identifier +HiLink clojureCond Conditional +HiLink clojureDefine Define +HiLink clojureException Exception +HiLink clojureFunc Function +HiLink clojureMacro Macro +HiLink clojureRepeat Repeat + +HiLink clojureQuote Special +HiLink clojureUnquote Special +HiLink clojureDispatch Special +HiLink clojureAnonArg Special +HiLink clojureVarArg Special +HiLink clojureSpecial Special + +HiLink clojureComment Comment +HiLink clojureTodo Todo + +HiLink clojureError Error + +HiLink clojureParen Delimiter + +delcommand HiLink + +let b:current_syntax = "clojure" + +" vim:sts=4 sw=4 et:
pgpGk04wwAwor.pgp
Description: PGP signature
