1" Vim indent file 2" Language: Julia 3" Maintainer: Carlo Baldassi <[email protected]> 4" Homepage: https://github.com/JuliaEditorSupport/julia-vim 5" Last Change: 2016 jun 16 6" Notes: originally based on Bram Molenaar's indent file for vim 7 8setlocal autoindent 9 10setlocal indentexpr=GetJuliaIndent() 11setlocal indentkeys+==end,=else,=catch,=finally,),],} 12setlocal indentkeys-=0# 13setlocal indentkeys-=: 14setlocal indentkeys-=0{ 15setlocal indentkeys-=0} 16setlocal nosmartindent 17 18" Only define the function once. 19if exists("*GetJuliaIndent") 20 finish 21endif 22 23let s:skipPatternsBasic = '\<julia\%(Comment\%([LM]\|Delim\)\)\>' 24let s:skipPatterns = '\<julia\%(Comprehension\%(For\|If\)\|RangeKeyword\|Comment\%([LM]\|Delim\)\|\%([bs]\|Shell\|Printf\|Doc\)\?String\|StringPrefixed\|DocStringM\(Raw\)\?\|RegEx\|SymbolS\?\|Macro\|Dotted\)\>' 25 26function JuliaMatch(lnum, str, regex, st, ...) 27 let s = a:st 28 let e = a:0 > 0 ? a:1 : -1 29 let basic_skip = a:0 > 1 ? a:2 : 'all' 30 let skip = basic_skip ==# 'basic' ? s:skipPatternsBasic : s:skipPatterns 31 while 1 32 let f = match(a:str, '\C' . a:regex, s) 33 if e >= 0 && f >= e 34 return -1 35 endif 36 if f >= 0 37 let attr = synIDattr(synID(a:lnum,f+1,1),"name") 38 let attrT = synIDattr(synID(a:lnum,f+1,0),"name") 39 if attr =~# skip || attrT =~# skip 40 let s = f+1 41 continue 42 endif 43 endif 44 break 45 endwhile 46 return f 47endfunction 48 49function GetJuliaNestingStruct(lnum, ...) 50 " Auxiliary function to inspect the block structure of a line 51 let line = getline(a:lnum) 52 let s = a:0 > 0 ? a:1 : 0 53 let e = a:0 > 1 ? a:2 : -1 54 let blocks_stack = [] 55 let num_closed_blocks = 0 56 while 1 57 let fb = JuliaMatch(a:lnum, line, '\<\%(if\|else\%(if\)\?\|while\|for\|try\|catch\|finally\|\%(staged\)\?function\|macro\|begin\|mutable\s\+struct\|\%(mutable\s\+\)\@<!struct\|\%(abstract\|primitive\)\s\+type\|let\|\%(bare\)\?module\|quote\|do\)\>', s, e) 58 let fe = JuliaMatch(a:lnum, line, '\<end\>', s, e) 59 60 if fb < 0 && fe < 0 61 " No blocks found 62 break 63 end 64 65 if fb >= 0 && (fb < fe || fe < 0) 66 " The first occurrence is an opening block keyword 67 " Note: some keywords (elseif,else,catch,finally) are both 68 " closing blocks and opening new ones 69 70 let i = JuliaMatch(a:lnum, line, '\<if\>', s) 71 if i >= 0 && i == fb 72 let s = i+1 73 call add(blocks_stack, 'if') 74 continue 75 endif 76 let i = JuliaMatch(a:lnum, line, '\<elseif\>', s) 77 if i >= 0 && i == fb 78 let s = i+1 79 if len(blocks_stack) > 0 && blocks_stack[-1] == 'if' 80 let blocks_stack[-1] = 'elseif' 81 elseif (len(blocks_stack) > 0 && blocks_stack[-1] != 'elseif') || len(blocks_stack) == 0 82 call add(blocks_stack, 'elseif') 83 let num_closed_blocks += 1 84 endif 85 continue 86 endif 87 let i = JuliaMatch(a:lnum, line, '\<else\>', s) 88 if i >= 0 && i == fb 89 let s = i+1 90 if len(blocks_stack) > 0 && blocks_stack[-1] =~# '\<\%(else\)\=if\>' 91 let blocks_stack[-1] = 'else' 92 else 93 call add(blocks_stack, 'else') 94 let num_closed_blocks += 1 95 endif 96 continue 97 endif 98 99 let i = JuliaMatch(a:lnum, line, '\<try\>', s) 100 if i >= 0 && i == fb 101 let s = i+1 102 call add(blocks_stack, 'try') 103 continue 104 endif 105 let i = JuliaMatch(a:lnum, line, '\<catch\>', s) 106 if i >= 0 && i == fb 107 let s = i+1 108 if len(blocks_stack) > 0 && blocks_stack[-1] == 'try' 109 let blocks_stack[-1] = 'catch' 110 else 111 call add(blocks_stack, 'catch') 112 let num_closed_blocks += 1 113 endif 114 continue 115 endif 116 let i = JuliaMatch(a:lnum, line, '\<finally\>', s) 117 if i >= 0 && i == fb 118 let s = i+1 119 if len(blocks_stack) > 0 && (blocks_stack[-1] == 'try' || blocks_stack[-1] == 'catch') 120 let blocks_stack[-1] = 'finally' 121 else 122 call add(blocks_stack, 'finally') 123 let num_closed_blocks += 1 124 endif 125 continue 126 endif 127 128 let i = JuliaMatch(a:lnum, line, '\<\%(bare\)\?module\>', s) 129 if i >= 0 && i == fb 130 let s = i+1 131 if i == 0 132 call add(blocks_stack, 'col1module') 133 else 134 call add(blocks_stack, 'other') 135 endif 136 continue 137 endif 138 139 let i = JuliaMatch(a:lnum, line, '\<\%(while\|for\|function\|macro\|begin\|\%(mutable\s\+\)\?struct\|\%(abstract\|primitive\)\s\+type\|let\|quote\|do\)\>', s) 140 if i >= 0 && i == fb 141 if match(line, '\C\<\%(mutable\|abstract\|primitive\)', i) != -1 142 let s = i+11 143 else 144 let s = i+1 145 endif 146 call add(blocks_stack, 'other') 147 continue 148 endif 149 150 " Note: it should be impossible to get here 151 break 152 153 else 154 " The first occurrence is an 'end' 155 156 let s = fe+1 157 if len(blocks_stack) == 0 158 let num_closed_blocks += 1 159 else 160 call remove(blocks_stack, -1) 161 endif 162 continue 163 164 endif 165 166 " Note: it should be impossible to get here 167 break 168 endwhile 169 let num_open_blocks = len(blocks_stack) - count(blocks_stack, 'col1module') 170 return [num_open_blocks, num_closed_blocks] 171endfunction 172 173function GetJuliaNestingBrackets(lnum, c) 174 " Auxiliary function to inspect the brackets structure of a line 175 let line = getline(a:lnum)[0 : (a:c - 1)] 176 let s = 0 177 let brackets_stack = [] 178 let last_closed_bracket = -1 179 while 1 180 let fb = JuliaMatch(a:lnum, line, '[([{]', s) 181 let fe = JuliaMatch(a:lnum, line, '[])}]', s) 182 183 if fb < 0 && fe < 0 184 " No brackets found 185 break 186 end 187 188 if fb >= 0 && (fb < fe || fe < 0) 189 " The first occurrence is an opening bracket 190 191 let i = JuliaMatch(a:lnum, line, '(', s) 192 if i >= 0 && i == fb 193 let s = i+1 194 call add(brackets_stack, ['par',i]) 195 continue 196 endif 197 198 let i = JuliaMatch(a:lnum, line, '\[', s) 199 if i >= 0 && i == fb 200 let s = i+1 201 call add(brackets_stack, ['sqbra',i]) 202 continue 203 endif 204 205 let i = JuliaMatch(a:lnum, line, '{', s) 206 if i >= 0 && i == fb 207 let s = i+1 208 call add(brackets_stack, ['curbra',i]) 209 continue 210 endif 211 212 " Note: it should be impossible to get here 213 break 214 215 else 216 " The first occurrence is a closing bracket 217 218 let i = JuliaMatch(a:lnum, line, ')', s) 219 if i >= 0 && i == fe 220 let s = i+1 221 if len(brackets_stack) > 0 && brackets_stack[-1][0] == 'par' 222 call remove(brackets_stack, -1) 223 else 224 let last_closed_bracket = i + 1 225 endif 226 continue 227 endif 228 229 let i = JuliaMatch(a:lnum, line, ']', s) 230 if i >= 0 && i == fe 231 let s = i+1 232 if len(brackets_stack) > 0 && brackets_stack[-1][0] == 'sqbra' 233 call remove(brackets_stack, -1) 234 else 235 let last_closed_bracket = i + 1 236 endif 237 continue 238 endif 239 240 let i = JuliaMatch(a:lnum, line, '}', s) 241 if i >= 0 && i == fe 242 let s = i+1 243 if len(brackets_stack) > 0 && brackets_stack[-1][0] == 'curbra' 244 call remove(brackets_stack, -1) 245 else 246 let last_closed_bracket = i + 1 247 endif 248 continue 249 endif 250 251 " Note: it should be impossible to get here 252 break 253 254 endif 255 256 " Note: it should be impossible to get here 257 break 258 endwhile 259 let first_open_bracket = -1 260 let last_open_bracket = -1 261 let infuncargs = 0 262 if len(brackets_stack) > 0 263 let first_open_bracket = brackets_stack[0][1] 264 let last_open_bracket = brackets_stack[-1][1] 265 if brackets_stack[-1][0] == 'par' && IsFunctionArgPar(a:lnum, last_open_bracket+1) 266 let infuncargs = 1 267 endif 268 endif 269 return [first_open_bracket, last_open_bracket, last_closed_bracket, infuncargs] 270endfunction 271 272let s:bracketBlocks = '\<julia\%(\%(\%(Printf\)\?Par\|SqBra\%(Idx\)\?\|CurBra\)Block\|ParBlockInRange\|StringVars\%(Par\|SqBra\|CurBra\)\|Dollar\%(Par\|SqBra\)\|QuotedParBlockS\?\)\>' 273 274function IsInBrackets(lnum, c) 275 let stack = map(synstack(a:lnum, a:c), 'synIDattr(v:val, "name")') 276 call filter(stack, 'v:val =~# s:bracketBlocks') 277 return len(stack) > 0 278endfunction 279 280function IsInDocString(lnum) 281 let stack = map(synstack(a:lnum, 1), 'synIDattr(v:val, "name")') 282 call filter(stack, 'v:val =~# "\\<juliaDocString\\(Delim\\|M\\\(Raw\\)\\?\\)\\?\\>"') 283 return len(stack) > 0 284endfunction 285 286function IsInContinuationImportLine(lnum) 287 let stack = map(synstack(a:lnum, 1), 'synIDattr(v:val, "name")') 288 call filter(stack, 'v:val =~# "\\<juliaImportLine\\>"') 289 if len(stack) == 0 290 return 0 291 endif 292 return JuliaMatch(a:lnum, getline(a:lnum), '\<\%(import\|using\|export\)\>', indent(a:lnum)) == -1 293endfunction 294 295function IsFunctionArgPar(lnum, c) 296 if a:c == 0 297 return 0 298 endif 299 let stack = map(synstack(a:lnum, a:c-1), 'synIDattr(v:val, "name")') 300 return len(stack) >= 2 && stack[-2] ==# 'juliaFunctionDef' 301endfunction 302 303function JumpToMatch(lnum, last_closed_bracket) 304 " we use the % command to skip back (tries to ues matchit if possible, 305 " otherwise resorts to vim's default, which is buggy but better than 306 " nothing) 307 call cursor(a:lnum, a:last_closed_bracket) 308 let percmap = maparg("%", "n") 309 if exists("g:loaded_matchit") && percmap =~# 'Match\%(it\|_wrapper\)' 310 normal % 311 else 312 normal! % 313 end 314endfunction 315 316" Auxiliary function to find a line which does not start in the middle of a 317" multiline bracketed expression, to be used as reference for block 318" indentation. 319function LastBlockIndent(lnum) 320 let lnum = a:lnum 321 let ind = 0 322 while lnum > 0 323 let ind = indent(lnum) 324 if ind == 0 325 return [lnum, 0] 326 endif 327 if !IsInBrackets(lnum, 1) 328 break 329 endif 330 let lnum = prevnonblank(lnum - 1) 331 endwhile 332 return [max([lnum,1]), ind] 333endfunction 334 335function GetJuliaIndent() 336 " Do not alter doctrings indentation 337 if IsInDocString(v:lnum) 338 return -1 339 endif 340 341 " Find a non-blank line above the current line. 342 let lnum = prevnonblank(v:lnum - 1) 343 344 " At the start of the file use zero indent. 345 if lnum == 0 346 return 0 347 endif 348 349 let ind = -1 350 let st = -1 351 let lim = -1 352 353 " Multiline bracketed expressions take precedence 354 let align_brackets = get(g:, "julia_indent_align_brackets", 1) 355 let align_funcargs = get(g:, "julia_indent_align_funcargs", 0) 356 let c = len(getline(lnum)) + 1 357 while IsInBrackets(lnum, c) 358 let [first_open_bracket, last_open_bracket, last_closed_bracket, infuncargs] = GetJuliaNestingBrackets(lnum, c) 359 360 " First scenario: the previous line has a hanging open bracket: 361 " set the indentation to match the opening bracket (plus an extra space) 362 " unless we're in a function arguments list or alignment is disabled, in 363 " which case we just add an extra indent 364 if last_open_bracket != -1 365 if (!infuncargs && align_brackets) || (infuncargs && align_funcargs) 366 let st = last_open_bracket 367 let ind = virtcol([lnum, st + 1]) 368 else 369 let ind = indent(lnum) + shiftwidth() 370 endif 371 372 " Second scenario: some multiline bracketed expression was closed in the 373 " previous line. But since we know we are still in a bracketed expression, 374 " we need to find the line where the bracket was opened 375 elseif last_closed_bracket != -1 376 call JumpToMatch(lnum, last_closed_bracket) 377 if line(".") == lnum 378 " something wrong here, give up 379 let ind = indent(lnum) 380 else 381 let lnum = line(".") 382 let c = col(".") - 1 383 if c == 0 384 " uhm, give up 385 let ind = 0 386 else 387 " we skipped a bracket set, keep searching for an opening bracket 388 let lim = c 389 continue 390 endif 391 endif 392 393 " Third scenario: nothing special: keep the indentation 394 else 395 let ind = indent(lnum) 396 endif 397 398 " Does the current line start with a closing bracket? Then depending on 399 " the situation we align it with the opening one, or we let the rest of 400 " the code figure it out (the case in which we're closing a function 401 " argument list is special-cased) 402 if JuliaMatch(v:lnum, getline(v:lnum), '[])}]', indent(v:lnum)) == indent(v:lnum) && ind > 0 403 if !align_brackets && !align_funcargs 404 call JumpToMatch(v:lnum, indent(v:lnum)) 405 return indent(line(".")) 406 elseif (align_brackets && getline(v:lnum)[indent(v:lnum)] != ')') || align_funcargs 407 return ind - 1 408 else " must be a ')' and align_brackets==1 and align_funcargs==0 409 call JumpToMatch(v:lnum, indent(v:lnum)) 410 if IsFunctionArgPar(line("."), col(".")) 411 let ind = -1 412 else 413 return ind - 1 414 endif 415 endif 416 endif 417 418 break 419 endwhile 420 421 if ind == -1 422 " We are not in a multiline bracketed expression. Thus we look for a 423 " previous line to use as a reference 424 let [lnum,ind] = LastBlockIndent(lnum) 425 let c = len(getline(lnum)) + 1 426 if IsInBrackets(lnum, c) 427 let [first_open_bracket, last_open_bracket, last_closed_bracket, infuncargs] = GetJuliaNestingBrackets(lnum, c) 428 let lim = first_open_bracket 429 endif 430 end 431 432 " Analyse the reference line 433 let [num_open_blocks, num_closed_blocks] = GetJuliaNestingStruct(lnum, st, lim) 434 " Increase indentation for each newly opened block in the reference line 435 let ind += shiftwidth() * num_open_blocks 436 437 " Analyse the current line 438 let [num_open_blocks, num_closed_blocks] = GetJuliaNestingStruct(v:lnum) 439 " Decrease indentation for each closed block in the current line 440 let ind -= shiftwidth() * num_closed_blocks 441 442 " Additional special case: multiline import/using/export statements 443 444 let prevline = getline(lnum) 445 " Are we in a multiline import/using/export statement, right below the 446 " opening line? 447 if IsInContinuationImportLine(v:lnum) && !IsInContinuationImportLine(lnum) 448 if get(g:, 'julia_indent_align_import', 1) 449 " if the opening line has a colon followed by non-comments, use it as 450 " reference point 451 let cind = JuliaMatch(lnum, prevline, ':', indent(lnum), lim) 452 if cind >= 0 453 let nonwhiteind = JuliaMatch(lnum, prevline, '\S', cind+1, -1, 'basic') 454 if nonwhiteind >= 0 455 " return match(prevline, '\S', cind+1) " a bit overkill... 456 return cind + 2 457 endif 458 else 459 " if the opening line is not a naked import/using/export statement, use 460 " it as reference 461 let iind = JuliaMatch(lnum, prevline, '\<import\|using\|export\>', indent(lnum), lim) 462 if iind >= 0 463 " assuming whitespace after using... so no `using(XYZ)` please! 464 let nonwhiteind = JuliaMatch(lnum, prevline, '\S', iind+6, -1, 'basic') 465 if nonwhiteind >= 0 466 return match(prevline, '\S', iind+6) 467 endif 468 endif 469 endif 470 endif 471 let ind += shiftwidth() 472 473 " Or did we just close a multiline import/using/export statement? 474 elseif !IsInContinuationImportLine(v:lnum) && IsInContinuationImportLine(lnum) 475 " find the starting line of the statement 476 let ilnum = 0 477 for iln in range(lnum-1, 1, -1) 478 if !IsInContinuationImportLine(iln) 479 let ilnum = iln 480 break 481 endif 482 endfor 483 if ilnum == 0 484 " something went horribly wrong, give up 485 let ind = indent(lnum) 486 endif 487 let ind = indent(ilnum) 488 endif 489 490 return ind 491endfunction 492