File Manager

X7ROOT File Manager

Current Path: /usr/share/vim/vim80/indent

?? ..
?? README.txt(1.6 KB)
?? aap.vim(265 B)
?? ada.vim(10.97 KB)
?? ant.vim(290 B)
?? automake.vim(243 B)
?? awk.vim(7.59 KB)
?? bib.vim(346 B)
?? bst.vim(1.89 KB)
?? bzl.vim(2.43 KB)
?? c.vim(325 B)
?? cdl.vim(4.15 KB)
?? ch.vim(470 B)
?? chaiscript.vim(1.11 KB)
?? changelog.vim(264 B)
?? clojure.vim(10.2 KB)
?? cmake.vim(2.62 KB)
?? cobol.vim(8.11 KB)
?? config.vim(2.13 KB)
?? context.vim(752 B)
?? cpp.vim(329 B)
?? cs.vim(327 B)
?? css.vim(1.75 KB)
?? cucumber.vim(2.62 KB)
?? cuda.vim(305 B)
?? d.vim(510 B)
?? dictconf.vim(337 B)
?? dictdconf.vim(338 B)
?? docbk.vim(336 B)
?? dtd.vim(11.59 KB)
?? dtrace.vim(451 B)
?? dylan.vim(2.64 KB)
?? eiffel.vim(3.24 KB)
?? erlang.vim(45.29 KB)
?? eruby.vim(2.74 KB)
?? eterm.vim(668 B)
?? falcon.vim(13.72 KB)
?? fortran.vim(7.27 KB)
?? framescript.vim(816 B)
?? gitconfig.vim(841 B)
?? gitolite.vim(1.25 KB)
?? go.vim(1.63 KB)
?? haml.vim(2.16 KB)
?? hamster.vim(1.39 KB)
?? hog.vim(1.85 KB)
?? html.vim(32.47 KB)
?? htmldjango.vim(273 B)
?? idlang.vim(1.58 KB)
?? ishd.vim(1.83 KB)
?? j.vim(1.77 KB)
?? java.vim(4.19 KB)
?? javascript.vim(15 KB)
?? json.vim(4.32 KB)
?? jsp.vim(462 B)
?? ld.vim(1.75 KB)
?? less.vim(243 B)
?? lifelines.vim(637 B)
?? liquid.vim(1.85 KB)
?? lisp.vim(353 B)
?? logtalk.vim(1.7 KB)
?? lua.vim(1.88 KB)
?? mail.vim(308 B)
?? make.vim(3.41 KB)
?? matlab.vim(1.92 KB)
?? mf.vim(156 B)
?? mma.vim(2.18 KB)
?? mp.vim(11.06 KB)
?? nsis.vim(3.18 KB)
?? objc.vim(1.61 KB)
?? ocaml.vim(8.94 KB)
?? occam.vim(4.53 KB)
?? pascal.vim(5.52 KB)
?? perl.vim(5.76 KB)
?? perl6.vim(3.46 KB)
?? php.vim(21.91 KB)
?? postscr.vim(1.61 KB)
?? pov.vim(2.6 KB)
?? prolog.vim(1.46 KB)
?? pyrex.vim(326 B)
?? python.vim(5.61 KB)
?? r.vim(13.58 KB)
?? readline.vim(711 B)
?? rhelp.vim(2.77 KB)
?? rmd.vim(1.17 KB)
?? rnoweb.vim(1.06 KB)
?? rpl.vim(1.82 KB)
?? rrst.vim(1.17 KB)
?? rst.vim(1.37 KB)
?? ruby.vim(22.43 KB)
?? rust.vim(6.35 KB)
?? sas.vim(5.01 KB)
?? sass.vim(950 B)
?? scala.vim(18.97 KB)
?? scheme.vim(372 B)
?? scss.vim(191 B)
?? sdl.vim(2.73 KB)
?? sh.vim(5.58 KB)
?? sml.vim(6.33 KB)
?? sql.vim(1.18 KB)
?? sqlanywhere.vim(12.86 KB)
?? systemd.vim(205 B)
?? systemverilog.vim(8.38 KB)
?? tcl.vim(1.59 KB)
?? tcsh.vim(1.24 KB)
?? teraterm.vim(1.33 KB)
?? tex.vim(13.18 KB)
?? tf.vim(1.51 KB)
?? tilde.vim(1012 B)
?? treetop.vim(707 B)
?? vb.vim(2.04 KB)
?? verilog.vim(7.97 KB)
?? vhdl.vim(14.32 KB)
?? vim.vim(2.92 KB)
?? vroom.vim(379 B)
?? xf86conf.vim(709 B)
?? xhtml.vim(269 B)
?? xinetd.vim(1.2 KB)
?? xml.vim(2.78 KB)
?? xsd.vim(253 B)
?? xslt.vim(297 B)
?? yacc.vim(781 B)
?? yaml.vim(5.34 KB)
?? zimbu.vim(3.84 KB)
?? zsh.vim(411 B)

Editing: yaml.vim

" Vim indent file
" Language:         YAML
" Maintainer:       Nikolai Pavlov <zyx.vim@gmail.com>
" Last Change:	    2017 Jun 13

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

let s:save_cpo = &cpo
set cpo&vim

let b:did_indent = 1

setlocal indentexpr=GetYAMLIndent(v:lnum)
setlocal indentkeys=!^F,o,O,0#,0},0],<:>,0-
setlocal nosmartindent

let b:undo_indent = 'setlocal indentexpr< indentkeys< smartindent<'

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

function s:FindPrevLessIndentedLine(lnum, ...)
    let prevlnum = prevnonblank(a:lnum-1)
    let curindent = a:0 ? a:1 : indent(a:lnum)
    while           prevlnum
                \&&  indent(prevlnum) >=  curindent
                \&& getline(prevlnum) =~# '^\s*#'
        let prevlnum = prevnonblank(prevlnum-1)
    endwhile
    return prevlnum
endfunction

function s:FindPrevLEIndentedLineMatchingRegex(lnum, regex)
    let plilnum = s:FindPrevLessIndentedLine(a:lnum, indent(a:lnum)+1)
    while plilnum && getline(plilnum) !~# a:regex
        let plilnum = s:FindPrevLessIndentedLine(plilnum)
    endwhile
    return plilnum
endfunction

let s:mapkeyregex='\v^\s*\#@!\S@=%(\''%([^'']|\''\'')*\'''.
                \                 '|\"%([^"\\]|\\.)*\"'.
                \                 '|%(%(\:\ )@!.)*)\:%(\ |$)'
let s:liststartregex='\v^\s*%(\-%(\ |$))'

let s:c_ns_anchor_char = '\v%([\n\r\uFEFF \t,[\]{}]@!\p)'
let s:c_ns_anchor_name = s:c_ns_anchor_char.'+'
let s:c_ns_anchor_property =  '\v\&'.s:c_ns_anchor_name

let s:ns_word_char = '\v[[:alnum:]_\-]'
let s:ns_tag_char  = '\v%(%\x\x|'.s:ns_word_char.'|[#/;?:@&=+$.~*''()])'
let s:c_named_tag_handle     = '\v\!'.s:ns_word_char.'+\!'
let s:c_secondary_tag_handle = '\v\!\!'
let s:c_primary_tag_handle   = '\v\!'
let s:c_tag_handle = '\v%('.s:c_named_tag_handle.
            \            '|'.s:c_secondary_tag_handle.
            \            '|'.s:c_primary_tag_handle.')'
let s:c_ns_shorthand_tag = '\v'.s:c_tag_handle . s:ns_tag_char.'+'
let s:c_non_specific_tag = '\v\!'
let s:ns_uri_char  = '\v%(%\x\x|'.s:ns_word_char.'\v|[#/;?:@&=+$,.!~*''()[\]])'
let s:c_verbatim_tag = '\v\!\<'.s:ns_uri_char.'+\>'
let s:c_ns_tag_property = '\v'.s:c_verbatim_tag.
            \               '\v|'.s:c_ns_shorthand_tag.
            \               '\v|'.s:c_non_specific_tag

let s:block_scalar_header = '\v[|>]%([+-]?[1-9]|[1-9]?[+-])?'

function GetYAMLIndent(lnum)
    if a:lnum == 1 || !prevnonblank(a:lnum-1)
        return 0
    endif

let prevlnum = prevnonblank(a:lnum-1)
    let previndent = indent(prevlnum)

let line = getline(a:lnum)
    if line =~# '^\s*#' && getline(a:lnum-1) =~# '^\s*#'
        " Comment blocks should have identical indent
        return previndent
    elseif line =~# '^\s*[\]}]'
        " Lines containing only closing braces should have previous indent
        return indent(s:FindPrevLessIndentedLine(a:lnum))
    endif

" Ignore comment lines when calculating indent
    while getline(prevlnum) =~# '^\s*#'
        let prevlnum = prevnonblank(prevlnum-1)
        if !prevlnum
            return previndent
        endif
    endwhile

let prevline = getline(prevlnum)
    let previndent = indent(prevlnum)

" Any examples below assume that shiftwidth=2
    if prevline =~# '\v[{[:]$|[:-]\ [|>][+\-]?%(\s+\#.*|\s*)$'
        " Mapping key:
        "     nested mapping: ...
        "
        " - {
        "     key: [
        "         list value
        "     ]
        " }
        "
        " - |-
        "     Block scalar without indentation indicator
        return previndent+shiftwidth()
    elseif prevline =~# '\v[:-]\ [|>]%(\d+[+\-]?|[+\-]?\d+)%(\#.*|\s*)$'
        " - |+2
        "   block scalar with indentation indicator
        "#^^ indent+2, not indent+shiftwidth
        return previndent + str2nr(matchstr(prevline,
                    \'\v([:-]\ [|>])@<=[+\-]?\d+%([+\-]?%(\s+\#.*|\s*)$)@='))
    elseif prevline =~# '\v\"%([^"\\]|\\.)*\\$'
        "    "Multiline string \
        "     with escaped end"
        let qidx = match(prevline, '\v\"%([^"\\]|\\.)*\\')
        return virtcol([prevlnum, qidx+1])
    elseif line =~# s:liststartregex
        " List line should have indent equal to previous list line unless it was 
        " caught by one of the previous rules
        return indent(s:FindPrevLEIndentedLineMatchingRegex(a:lnum,
                    \                                       s:liststartregex))
    elseif line =~# s:mapkeyregex
        " Same for line containing mapping key
        let prevmapline = s:FindPrevLEIndentedLineMatchingRegex(a:lnum,
                    \                                           s:mapkeyregex)
        if getline(prevmapline) =~# '^\s*- '
            return indent(prevmapline) + 2
        else
            return indent(prevmapline)
        endif
    elseif prevline =~# '^\s*- '
        " - List with
        "   multiline scalar
        return previndent+2
    elseif prevline =~# s:mapkeyregex . '\v\s*%(%('.s:c_ns_tag_property.
                \                              '\v|'.s:c_ns_anchor_property.
                \                              '\v|'.s:block_scalar_header.
                \                             '\v)%(\s+|\s*%(\#.*)?$))*'
        " Mapping with: value
        "     that is multiline scalar
        return previndent+shiftwidth()
    endif
    return previndent
endfunction

let &cpo = s:save_cpo

X7ROOT File Manager

Editing: yaml.vim

Upload File

Create Folder