Gecko [ edgpens.lpkmn.gov.my ]

Name	Size	Permission
README.txt	1.65 KB	-rw-rw-rw-
aap.vim	265 B	-rw-rw-rw-
ada.vim	11.06 KB	-rw-rw-rw-
ant.vim	290 B	-rw-rw-rw-
automake.vim	243 B	-rw-rw-rw-
awk.vim	7.68 KB	-rw-rw-rw-
bash.vim	350 B	-rw-rw-rw-
basic.vim	250 B	-rw-rw-rw-
bib.vim	346 B	-rw-rw-rw-
bst.vim	1.86 KB	-rw-rw-rw-
bzl.vim	2.86 KB	-rw-rw-rw-
c.vim	325 B	-rw-rw-rw-
cdl.vim	4.26 KB	-rw-rw-rw-
ch.vim	470 B	-rw-rw-rw-
chaiscript.vim	1.18 KB	-rw-rw-rw-
changelog.vim	264 B	-rw-rw-rw-
clojure.vim	11.29 KB	-rw-rw-rw-
cmake.vim	2.66 KB	-rw-rw-rw-
cobol.vim	8.63 KB	-rw-rw-rw-
config.vim	2.17 KB	-rw-rw-rw-
confini.vim	196 B	-rw-rw-rw-
context.vim	752 B	-rw-rw-rw-
cpp.vim	329 B	-rw-rw-rw-
cs.vim	1.88 KB	-rw-rw-rw-
css.vim	1.77 KB	-rw-rw-rw-
cucumber.vim	2.62 KB	-rw-rw-rw-
cuda.vim	305 B	-rw-rw-rw-
d.vim	605 B	-rw-rw-rw-
dictconf.vim	411 B	-rw-rw-rw-
dictdconf.vim	414 B	-rw-rw-rw-
docbk.vim	336 B	-rw-rw-rw-
dosbatch.vim	1.35 KB	-rw-rw-rw-
dtd.vim	11.79 KB	-rw-rw-rw-
dtrace.vim	451 B	-rw-rw-rw-
dune.vim	332 B	-rw-rw-rw-
dylan.vim	2.75 KB	-rw-rw-rw-
eiffel.vim	3.24 KB	-rw-rw-rw-
elm.vim	3.2 KB	-rw-rw-rw-
erlang.vim	48.89 KB	-rw-rw-rw-
eruby.vim	2.95 KB	-rw-rw-rw-
eterm.vim	743 B	-rw-rw-rw-
falcon.vim	13.84 KB	-rw-rw-rw-
fennel.vim	273 B	-rw-rw-rw-
fortran.vim	7.54 KB	-rw-rw-rw-
framescript.vim	891 B	-rw-rw-rw-
freebasic.vim	237 B	-rw-rw-rw-
gitconfig.vim	841 B	-rw-rw-rw-
gitolite.vim	1.29 KB	-rw-rw-rw-
go.vim	1.63 KB	-rw-rw-rw-
haml.vim	2.19 KB	-rw-rw-rw-
hamster.vim	1.65 KB	-rw-rw-rw-
hog.vim	1.85 KB	-rw-rw-rw-
html.vim	33.11 KB	-rw-rw-rw-
htmldjango.vim	273 B	-rw-rw-rw-
idlang.vim	1.68 KB	-rw-rw-rw-
ishd.vim	1.83 KB	-rw-rw-rw-
j.vim	1.77 KB	-rw-rw-rw-
java.vim	4.19 KB	-rw-rw-rw-
javascript.vim	15 KB	-rw-rw-rw-
javascriptreact.vim	109 B	-rw-rw-rw-
json.vim	4.42 KB	-rw-rw-rw-
jsonc.vim	4.62 KB	-rw-rw-rw-
jsp.vim	462 B	-rw-rw-rw-
julia.vim	15.2 KB	-rw-rw-rw-
krl.vim	4.26 KB	-rw-rw-rw-
ld.vim	1.82 KB	-rw-rw-rw-
less.vim	243 B	-rw-rw-rw-
lifelines.vim	638 B	-rw-rw-rw-
liquid.vim	2.03 KB	-rw-rw-rw-
lisp.vim	353 B	-rw-rw-rw-
logtalk.vim	1.82 KB	-rw-rw-rw-
lua.vim	1.88 KB	-rw-rw-rw-
mail.vim	355 B	-rw-rw-rw-
make.vim	3.48 KB	-rw-rw-rw-
matlab.vim	4.81 KB	-rw-rw-rw-
meson.vim	5.19 KB	-rw-rw-rw-
mf.vim	156 B	-rw-rw-rw-
mma.vim	2.31 KB	-rw-rw-rw-
mp.vim	11.06 KB	-rw-rw-rw-
nginx.vim	407 B	-rw-rw-rw-
nsis.vim	3.23 KB	-rw-rw-rw-
objc.vim	1.65 KB	-rw-rw-rw-
ocaml.vim	8.98 KB	-rw-rw-rw-
occam.vim	4.63 KB	-rw-rw-rw-
pascal.vim	5.66 KB	-rw-rw-rw-
perl.vim	5.85 KB	-rw-rw-rw-
php.vim	25.29 KB	-rw-rw-rw-
postscr.vim	1.64 KB	-rw-rw-rw-
pov.vim	2.71 KB	-rw-rw-rw-
prolog.vim	1.91 KB	-rw-rw-rw-
ps1.vim	410 B	-rw-rw-rw-
pyrex.vim	326 B	-rw-rw-rw-
python.vim	6.82 KB	-rw-rw-rw-
qb64.vim	232 B	-rw-rw-rw-
r.vim	13.71 KB	-rw-rw-rw-
raku.vim	3.34 KB	-rw-rw-rw-
raml.vim	285 B	-rw-rw-rw-
readline.vim	786 B	-rw-rw-rw-
rhelp.vim	2.77 KB	-rw-rw-rw-
rmd.vim	2.14 KB	-rw-rw-rw-
rnoweb.vim	1.06 KB	-rw-rw-rw-
rpl.vim	1.82 KB	-rw-rw-rw-
rrst.vim	1.17 KB	-rw-rw-rw-
rst.vim	1.78 KB	-rw-rw-rw-
ruby.vim	30.32 KB	-rw-rw-rw-
rust.vim	6.35 KB	-rw-rw-rw-
sas.vim	5.18 KB	-rw-rw-rw-
sass.vim	994 B	-rw-rw-rw-
scala.vim	19.2 KB	-rw-rw-rw-
scheme.vim	372 B	-rw-rw-rw-
scss.vim	191 B	-rw-rw-rw-
sdl.vim	2.76 KB	-rw-rw-rw-
sh.vim	9.04 KB	-rw-rw-rw-
sml.vim	6.42 KB	-rw-rw-rw-
sql.vim	1.18 KB	-rw-rw-rw-
sqlanywhere.vim	12.96 KB	-rw-rw-rw-
sshconfig.vim	796 B	-rw-rw-rw-
systemd.vim	205 B	-rw-rw-rw-
systemverilog.vim	8.51 KB	-rw-rw-rw-
tcl.vim	2.48 KB	-rw-rw-rw-
tcsh.vim	1.35 KB	-rw-rw-rw-
teraterm.vim	1.38 KB	-rw-rw-rw-
tex.vim	13.37 KB	-rw-rw-rw-
tf.vim	1.57 KB	-rw-rw-rw-
tilde.vim	1.11 KB	-rw-rw-rw-
treetop.vim	785 B	-rw-rw-rw-
typescript.vim	14.14 KB	-rw-rw-rw-
vb.vim	2.04 KB	-rw-rw-rw-
verilog.vim	7.98 KB	-rw-rw-rw-
vhdl.vim	14.32 KB	-rw-rw-rw-
vim.vim	5.91 KB	-rw-rw-rw-
vroom.vim	379 B	-rw-rw-rw-
wast.vim	458 B	-rw-rw-rw-
xf86conf.vim	786 B	-rw-rw-rw-
xhtml.vim	269 B	-rw-rw-rw-
xinetd.vim	1.28 KB	-rw-rw-rw-
xml.vim	7.6 KB	-rw-rw-rw-
xsd.vim	253 B	-rw-rw-rw-
xslt.vim	297 B	-rw-rw-rw-
yacc.vim	858 B	-rw-rw-rw-
yaml.vim	5.35 KB	-rw-rw-rw-
zimbu.vim	3.85 KB	-rw-rw-rw-
zsh.vim	411 B	-rw-rw-rw-

Code Editor : julia.vim

" Vim indent file
" Language:	Julia
" Maintainer:	Carlo Baldassi <carlobaldassi@gmail.com>
" Homepage:	https://github.com/JuliaEditorSupport/julia-vim
" Last Change:	2022 Jun 14
" Notes:        originally based on Bram Molenaar's indent file for vim

" Only load this indent file when no other was loaded.
if exists("b:did_indent")
  finish
endif
let b:did_indent = 1

setlocal autoindent

setlocal indentexpr=GetJuliaIndent()
setlocal indentkeys+==end,=else,=catch,=finally,),],}
setlocal indentkeys-=0#
setlocal indentkeys-=:
setlocal indentkeys-=0{
setlocal indentkeys-=0}
setlocal nosmartindent

" Only define the function once.
if exists("*GetJuliaIndent")
  finish
endif

function JuliaMatch(lnum, str, regex, st, ...)
  let s = a:st
  let e = a:0 > 0 ? a:1 : -1
  let basic_skip = a:0 > 1 ? a:2 : 'all'
  let skip = basic_skip ==# 'basic' ? s:skipPatternsBasic : s:skipPatterns
  while 1
    let f = match(a:str, '\C' . a:regex, s)
    if e >= 0 && f >= e
      return -1
    endif
    if f >= 0
      let attr = synIDattr(synID(a:lnum,f+1,1),"name")
      let attrT = synIDattr(synID(a:lnum,f+1,0),"name")
      if attr =~# skip || attrT =~# skip
        let s = f+1
        continue
      endif
    endif
    break
  endwhile
  return f
endfunction

if fb < 0 && fe < 0
      " No blocks found
      break
    end

if fb >= 0 && (fb < fe || fe < 0)
      " The first occurrence is an opening block keyword
      " Note: some keywords (elseif,else,catch,finally) are both
      "       closing blocks and opening new ones

let i = JuliaMatch(a:lnum, line, '\<if\>', s)
      if i >= 0 && i == fb
        let s = i+1
        call add(blocks_stack, 'if')
        continue
      endif
      let i = JuliaMatch(a:lnum, line, '\<elseif\>', s)
      if i >= 0 && i == fb
        let s = i+1
        if len(blocks_stack) > 0 && blocks_stack[-1] == 'if'
          let blocks_stack[-1] = 'elseif'
        elseif (len(blocks_stack) > 0 && blocks_stack[-1] != 'elseif') || len(blocks_stack) == 0
          call add(blocks_stack, 'elseif')
          let num_closed_blocks += 1
        endif
        continue
      endif
      let i = JuliaMatch(a:lnum, line, '\<else\>', s)
      if i >= 0 && i == fb
        let s = i+1
        if len(blocks_stack) > 0 && blocks_stack[-1] =~# '\<\%(else\)\=if\>'
          let blocks_stack[-1] = 'else'
        else
          call add(blocks_stack, 'else')
          let num_closed_blocks += 1
        endif
        continue
      endif

let i = JuliaMatch(a:lnum, line, '\<try\>', s)
      if i >= 0 && i == fb
        let s = i+1
        call add(blocks_stack, 'try')
        continue
      endif
      let i = JuliaMatch(a:lnum, line, '\<catch\>', s)
      if i >= 0 && i == fb
        let s = i+1
        if len(blocks_stack) > 0 && blocks_stack[-1] == 'try'
          let blocks_stack[-1] = 'catch'
        else
          call add(blocks_stack, 'catch')
          let num_closed_blocks += 1
        endif
        continue
      endif
      let i = JuliaMatch(a:lnum, line, '\<finally\>', s)
      if i >= 0 && i == fb
        let s = i+1
        if len(blocks_stack) > 0 && (blocks_stack[-1] == 'try' || blocks_stack[-1] == 'catch')
          let blocks_stack[-1] = 'finally'
        else
          call add(blocks_stack, 'finally')
          let num_closed_blocks += 1
        endif
        continue
      endif

let i = JuliaMatch(a:lnum, line, '\<\%(bare\)\?module\>', s)
      if i >= 0 && i == fb
        let s = i+1
        if i == 0
          call add(blocks_stack, 'col1module')
        else
          call add(blocks_stack, 'other')
        endif
        continue
      endif

" Note: it should be impossible to get here
      break

else
      " The first occurrence is an 'end'

let s = fe+1
      if len(blocks_stack) == 0
        let num_closed_blocks += 1
      else
        call remove(blocks_stack, -1)
      endif
      continue

endif

" Note: it should be impossible to get here
    break
  endwhile
  let num_open_blocks = len(blocks_stack) - count(blocks_stack, 'col1module')
  return [num_open_blocks, num_closed_blocks]
endfunction

function GetJuliaNestingBrackets(lnum, c)
  " Auxiliary function to inspect the brackets structure of a line
  let line = getline(a:lnum)[0 : (a:c - 1)]
  let s = 0
  let brackets_stack = []
  let last_closed_bracket = -1
  while 1
    let fb = JuliaMatch(a:lnum, line, '[([{]', s)
    let fe = JuliaMatch(a:lnum, line, '[])}]', s)

if fb < 0 && fe < 0
      " No brackets found
      break
    end

if fb >= 0 && (fb < fe || fe < 0)
      " The first occurrence is an opening bracket

let i = JuliaMatch(a:lnum, line, '(', s)
      if i >= 0 && i == fb
        let s = i+1
        call add(brackets_stack, ['par',i])
        continue
      endif

let i = JuliaMatch(a:lnum, line, '\[', s)
      if i >= 0 && i == fb
        let s = i+1
        call add(brackets_stack, ['sqbra',i])
        continue
      endif

let i = JuliaMatch(a:lnum, line, '{', s)
      if i >= 0 && i == fb
        let s = i+1
        call add(brackets_stack, ['curbra',i])
        continue
      endif

" Note: it should be impossible to get here
      break

else
      " The first occurrence is a closing bracket

let i = JuliaMatch(a:lnum, line, ')', s)
      if i >= 0 && i == fe
        let s = i+1
        if len(brackets_stack) > 0 && brackets_stack[-1][0] == 'par'
          call remove(brackets_stack, -1)
        else
          let last_closed_bracket = i + 1
        endif
        continue
      endif

let i = JuliaMatch(a:lnum, line, ']', s)
      if i >= 0 && i == fe
        let s = i+1
        if len(brackets_stack) > 0 && brackets_stack[-1][0] == 'sqbra'
          call remove(brackets_stack, -1)
        else
          let last_closed_bracket = i + 1
        endif
        continue
      endif

let i = JuliaMatch(a:lnum, line, '}', s)
      if i >= 0 && i == fe
        let s = i+1
        if len(brackets_stack) > 0 && brackets_stack[-1][0] == 'curbra'
          call remove(brackets_stack, -1)
        else
          let last_closed_bracket = i + 1
        endif
        continue
      endif

" Note: it should be impossible to get here
      break

endif

" Note: it should be impossible to get here
    break
  endwhile
  let first_open_bracket = -1
  let last_open_bracket = -1
  let infuncargs = 0
  if len(brackets_stack) > 0
    let first_open_bracket = brackets_stack[0][1]
    let last_open_bracket = brackets_stack[-1][1]
    if brackets_stack[-1][0] == 'par' && IsFunctionArgPar(a:lnum, last_open_bracket+1)
      let infuncargs = 1
    endif
  endif
  return [first_open_bracket, last_open_bracket, last_closed_bracket, infuncargs]
endfunction

function IsInBrackets(lnum, c)
  let stack = map(synstack(a:lnum, a:c), 'synIDattr(v:val, "name")')
  call filter(stack, 'v:val =~# s:bracketBlocks')
  return len(stack) > 0
endfunction

function IsInDocString(lnum)
  let stack = map(synstack(a:lnum, 1), 'synIDattr(v:val, "name")')
  call filter(stack, 'v:val =~# "\\<juliaDocString\\(Delim\\|M\\\(Raw\\)\\?\\)\\?\\>"')
  return len(stack) > 0
endfunction

function IsInContinuationImportLine(lnum)
  let stack = map(synstack(a:lnum, 1), 'synIDattr(v:val, "name")')
  call filter(stack, 'v:val =~# "\\<juliaImportLine\\>"')
  if len(stack) == 0
    return 0
  endif
  return JuliaMatch(a:lnum, getline(a:lnum), '\<\%(import\|using\|export\)\>', indent(a:lnum)) == -1
endfunction

function IsFunctionArgPar(lnum, c)
  if a:c == 0
    return 0
  endif
  let stack = map(synstack(a:lnum, a:c-1), 'synIDattr(v:val, "name")')
  return len(stack) >= 2 && stack[-2] ==# 'juliaFunctionDef'
endfunction

function JumpToMatch(lnum, last_closed_bracket)
  " we use the % command to skip back (tries to ues matchit if possible,
  " otherwise resorts to vim's default, which is buggy but better than
  " nothing)
  call cursor(a:lnum, a:last_closed_bracket)
  let percmap = maparg("%", "n") 
  if exists("g:loaded_matchit") && percmap =~# 'Match\%(it\|_wrapper\)'
    normal %
  else
    normal! %
  end
endfunction

" Auxiliary function to find a line which does not start in the middle of a
" multiline bracketed expression, to be used as reference for block
" indentation.
function LastBlockIndent(lnum)
  let lnum = a:lnum
  let ind = 0
  while lnum > 0
    let ind = indent(lnum)
    if ind == 0
      return [lnum, 0]
    endif
    if !IsInBrackets(lnum, 1)
      break
    endif
    let lnum = prevnonblank(lnum - 1)
  endwhile
  return [max([lnum,1]), ind]
endfunction

function GetJuliaIndent()
  " Do not alter doctrings indentation
  if IsInDocString(v:lnum)
    return -1
  endif

" Find a non-blank line above the current line.
  let lnum = prevnonblank(v:lnum - 1)

" At the start of the file use zero indent.
  if lnum == 0
    return 0
  endif

let ind = -1
  let st = -1
  let lim = -1

" Multiline bracketed expressions take precedence
  let align_brackets = get(g:, "julia_indent_align_brackets", 1)
  let align_funcargs = get(g:, "julia_indent_align_funcargs", 0)
  let c = len(getline(lnum)) + 1
  while IsInBrackets(lnum, c)
    let [first_open_bracket, last_open_bracket, last_closed_bracket, infuncargs] = GetJuliaNestingBrackets(lnum, c)

" First scenario: the previous line has a hanging open bracket:
    " set the indentation to match the opening bracket (plus an extra space)
    " unless we're in a function arguments list or alignment is disabled, in
    " which case we just add an extra indent
    if last_open_bracket != -1
      if (!infuncargs && align_brackets) || (infuncargs && align_funcargs)
        let st = last_open_bracket
        let ind = virtcol([lnum, st + 1])
      else
        let ind = indent(lnum) + shiftwidth()
      endif

" Second scenario: some multiline bracketed expression was closed in the
    " previous line. But since we know we are still in a bracketed expression,
    " we need to find the line where the bracket was opened
    elseif last_closed_bracket != -1
      call JumpToMatch(lnum, last_closed_bracket)
      if line(".") == lnum
        " something wrong here, give up
        let ind = indent(lnum)
      else
        let lnum = line(".")
        let c = col(".") - 1
        if c == 0
          " uhm, give up
          let ind = 0
        else
          " we skipped a bracket set, keep searching for an opening bracket
          let lim = c
          continue
        endif
      endif

" Third scenario: nothing special: keep the indentation
    else
      let ind = indent(lnum)
    endif

" Does the current line start with a closing bracket? Then depending on
    " the situation we align it with the opening one, or we let the rest of
    " the code figure it out (the case in which we're closing a function
    " argument list is special-cased)
    if JuliaMatch(v:lnum, getline(v:lnum), '[])}]', indent(v:lnum)) == indent(v:lnum) && ind > 0
      if !align_brackets && !align_funcargs
        call JumpToMatch(v:lnum, indent(v:lnum))
        return indent(line("."))
      elseif (align_brackets && getline(v:lnum)[indent(v:lnum)] != ')') || align_funcargs
        return ind - 1
      else " must be a ')' and align_brackets==1 and align_funcargs==0
        call JumpToMatch(v:lnum, indent(v:lnum))
        if IsFunctionArgPar(line("."), col("."))
          let ind = -1
        else
          return ind - 1
        endif
      endif
    endif

break
  endwhile

if ind == -1
    " We are not in a multiline bracketed expression. Thus we look for a
    " previous line to use as a reference
    let [lnum,ind] = LastBlockIndent(lnum)
    let c = len(getline(lnum)) + 1
    if IsInBrackets(lnum, c)
      let [first_open_bracket, last_open_bracket, last_closed_bracket, infuncargs] = GetJuliaNestingBrackets(lnum, c)
      let lim = first_open_bracket
    endif
  end

" Analyse the reference line
  let [num_open_blocks, num_closed_blocks] = GetJuliaNestingStruct(lnum, st, lim)
  " Increase indentation for each newly opened block in the reference line
  let ind += shiftwidth() * num_open_blocks

" Analyse the current line
  let [num_open_blocks, num_closed_blocks] = GetJuliaNestingStruct(v:lnum)
  " Decrease indentation for each closed block in the current line
  let ind -= shiftwidth() * num_closed_blocks

" Additional special case: multiline import/using/export statements

let prevline = getline(lnum)
  " Are we in a multiline import/using/export statement, right below the
  " opening line?
  if IsInContinuationImportLine(v:lnum) && !IsInContinuationImportLine(lnum)
    if get(g:, 'julia_indent_align_import', 1)
      " if the opening line has a colon followed by non-comments, use it as
      " reference point
      let cind = JuliaMatch(lnum, prevline, ':', indent(lnum), lim)
      if cind >= 0
        let nonwhiteind = JuliaMatch(lnum, prevline, '\S', cind+1, -1, 'basic')
        if nonwhiteind >= 0
          " return match(prevline, '\S', cind+1) " a bit overkill...
          return cind + 2
        endif
      else
        " if the opening line is not a naked import/using/export statement, use
        " it as reference
        let iind = JuliaMatch(lnum, prevline, '\<import\|using\|export\>', indent(lnum), lim)
        if iind >= 0
          " assuming whitespace after using... so no `using(XYZ)` please!
          let nonwhiteind = JuliaMatch(lnum, prevline, '\S', iind+6, -1, 'basic')
          if nonwhiteind >= 0
            return match(prevline, '\S', iind+6)
          endif
        endif
      endif
    endif
    let ind += shiftwidth()

" Or did we just close a multiline import/using/export statement?
  elseif !IsInContinuationImportLine(v:lnum) && IsInContinuationImportLine(lnum)
    " find the starting line of the statement
    let ilnum = 0
    for iln in range(lnum-1, 1, -1)
      if !IsInContinuationImportLine(iln)
        let ilnum = iln
        break
      endif
    endfor
    if ilnum == 0
      " something went horribly wrong, give up
      let ind = indent(lnum)
    endif
    let ind = indent(ilnum)
  endif

return ind
endfunction

${this.title}

Code Editor : julia.vim