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: awk.vim

"  vim: set sw=3 sts=3:

" Awk indent script. It can handle multi-line statements and expressions.
" It works up to the point where the distinction between correct/incorrect
" and personal taste gets fuzzy. Drop me an e-mail for bug reports and
" reasonable style suggestions.
"
" Bugs:
" =====
" - Some syntax errors may cause erratic indentation.
" - Same for very unusual but syntacticly correct use of { }
" - In some cases it's confused by the use of ( and { in strings constants
" - This version likes the closing brace of a multiline pattern-action be on
"   character position 1 before the following pattern-action combination is
"   formatted

" Author:
" =======
" Erik Janssen, ejanssen@itmatters.nl
"
" History:
" ========
" 26-04-2002 Got initial version working reasonably well
" 29-04-2002 Fixed problems in function headers and max line width
"	     Added support for two-line if's without curly braces
" Fixed hang: 2011 Aug 31

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

let b:did_indent = 1

setlocal indentexpr=GetAwkIndent()
" Mmm, copied from the tcl indent program. Is this okay?
setlocal indentkeys-=:,0#

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

" This function contains a lot of exit points. It checks for simple cases
" first to get out of the function as soon as possible, thereby reducing the
" number of possibilities later on in the difficult parts

function! GetAwkIndent()

" Find previous line and get it's indentation
   let prev_lineno = s:Get_prev_line( v:lnum )
   if prev_lineno == 0
      return 0
   endif
   let prev_data = getline( prev_lineno )
   let ind = indent( prev_lineno )

" Increase indent if the previous line contains an opening brace. Search
   " for this brace the hard way to prevent errors if the previous line is a
   " 'pattern { action }' (simple check match on /{/ increases the indent then)

if s:Get_brace_balance( prev_data, '{', '}' ) > 0
      return ind + shiftwidth()
   endif

let brace_balance = s:Get_brace_balance( prev_data, '(', ')' )

" If prev line has positive brace_balance and starts with a word (keyword
   " or function name), align the current line on the first '(' of the prev
   " line

if brace_balance > 0 && s:Starts_with_word( prev_data )
      return s:Safe_indent( ind, s:First_word_len(prev_data), getline(v:lnum))
   endif

" If this line starts with an open brace bail out now before the line
   " continuation checks.

if getline( v:lnum ) =~ '^\s*{'
      return ind
   endif

" If prev line seems to be part of multiline statement:
   " 1. Prev line is first line of a multiline statement
   "    -> attempt to indent on first ' ' or '(' of prev line, just like we
   "       indented the positive brace balance case above
   " 2. Prev line is not first line of a multiline statement
   "    -> copy indent of prev line

let continue_mode = s:Seems_continuing( prev_data )
   if continue_mode > 0
     if s:Seems_continuing( getline(s:Get_prev_line( prev_lineno )) )
       " Case 2
       return ind
     else
       " Case 1
       if continue_mode == 1
	  " Need continuation due to comma, backslash, etc
	  return s:Safe_indent( ind, s:First_word_len(prev_data), getline(v:lnum))
       else
	 " if/for/while without '{'
	 return ind + shiftwidth()
       endif
     endif
   endif

" If the previous line doesn't need continuation on the current line we are
   " on the start of a new statement.  We have to make sure we align with the
   " previous statement instead of just the previous line. This is a bit
   " complicated because the previous statement might be multi-line.
   "
   " The start of a multiline statement can be found by:
   "
   " 1 If the previous line contains closing braces and has negative brace
   "   balance, search backwards until cumulative brace balance becomes zero,
   "   take indent of that line
   " 2 If the line before the previous needs continuation search backward
   "   until that's not the case anymore. Take indent of one line down.

" Case 1
   if prev_data =~ ')' && brace_balance < 0
      while brace_balance != 0 && prev_lineno > 0
	 let prev_lineno = s:Get_prev_line( prev_lineno )
	 let prev_data = getline( prev_lineno )
	 let brace_balance=brace_balance+s:Get_brace_balance(prev_data,'(',')' )
      endwhile
      let ind = indent( prev_lineno )
   else
      " Case 2
      if s:Seems_continuing( getline( prev_lineno - 1 ) )
	 let prev_lineno = prev_lineno - 2
	 let prev_data = getline( prev_lineno )
	 while prev_lineno > 0 && (s:Seems_continuing( prev_data ) > 0)
	    let prev_lineno = s:Get_prev_line( prev_lineno )
	    let prev_data = getline( prev_lineno )
	 endwhile
	 let ind = indent( prev_lineno + 1 )
      endif
   endif

" Decrease indent if this line contains a '}'.
   if getline(v:lnum) =~ '^\s*}'
      let ind = ind - shiftwidth()
   endif

return ind
endfunction

" Find the open and close braces in this line and return how many more open-
" than close braces there are. It's also used to determine cumulative balance
" across multiple lines.

function! s:Get_brace_balance( line, b_open, b_close )
   let line2 = substitute( a:line, a:b_open, "", "g" )
   let openb = strlen( a:line ) - strlen( line2 )
   let line3 = substitute( line2, a:b_close, "", "g" )
   let closeb = strlen( line2 ) - strlen( line3 )
   return openb - closeb
endfunction

" Find out whether the line starts with a word (i.e. keyword or function
" call). Might need enhancements here.

function! s:Starts_with_word( line )
  if a:line =~ '^\s*[a-zA-Z_0-9]\+\s*('
     return 1
  endif
  return 0
endfunction

" Find the length of the first word in a line. This is used to be able to
" align a line relative to the 'print ' or 'if (' on the previous line in case
" such a statement spans multiple lines.
" Precondition: only to be used on lines where 'Starts_with_word' returns 1.

function! s:First_word_len( line )
   let white_end = matchend( a:line, '^\s*' )
   if match( a:line, '^\s*func' ) != -1
     let word_end = matchend( a:line, '[a-z]\+\s\+[a-zA-Z_0-9]\+[ (]*' )
   else
     let word_end = matchend( a:line, '[a-zA-Z_0-9]\+[ (]*' )
   endif
   return word_end - white_end
endfunction

" Determine if 'line' completes a statement or is continued on the next line.
" This one is far from complete and accepts illegal code. Not important for
" indenting, however.

function! s:Seems_continuing( line )
  " Unfinished lines
  if a:line =~ '$--\|++$\s*$'
    return 0
  endif
  if a:line =~ '[\\,\|\&\+\-\*\%\^]\s*$'
    return 1
  endif
  " if/for/while (cond) eol
  if a:line =~ '^\s*$if\|while\|for$\s*(.*)\s*$' || a:line =~ '^\s*else\s*'
      return 2
   endif
  return 0
endfunction

" Get previous relevant line. Search back until a line is that is no
" comment or blank and return the line number

function! s:Get_prev_line( lineno )
   let lnum = a:lineno - 1
   let data = getline( lnum )
   while lnum > 0 && (data =~ '^\s*#' || data =~ '^\s*$')
      let lnum = lnum - 1
      let data = getline( lnum )
   endwhile
   return lnum
endfunction

" This function checks whether an indented line exceeds a maximum linewidth
" (hardcoded 80). If so and it is possible to stay within 80 positions (or
" limit num of characters beyond linewidth) by decreasing the indent (keeping
" it > base_indent), do so.

function! s:Safe_indent( base, wordlen, this_line )
   let line_base = matchend( a:this_line, '^\s*' )
   let line_len = strlen( a:this_line ) - line_base
   let indent = a:base
   if (indent + a:wordlen + line_len) > 80
     " Simple implementation good enough for the time being
     let indent = indent + 3
   endif
   return indent + a:wordlen
endfunction

X7ROOT File Manager

Editing: awk.vim

Upload File

Create Folder