<h2>Edit File - sqlanywhere.vim</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/usr/share/vim/vim80/indent/sqlanywhere.vim">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">&quot; Vim indent file
&quot; Language:    SQL
&quot; Maintainer:  David Fishburn &lt;dfishburn dot vim at gmail dot com&gt;
&quot; Last Change: 2017 Jun 13
&quot; Version:     3.0
&quot; Download:    http://vim.sourceforge.net/script.php?script_id=495

&quot; Notes:
&quot;    Indenting keywords are based on Oracle and Sybase Adaptive Server
&quot;    Anywhere (ASA).  Test indenting was done with ASA stored procedures and
&quot;    fuctions and Oracle packages which contain stored procedures and
&quot;    functions.
&quot;    This has not been tested against Microsoft SQL Server or
&quot;    Sybase Adaptive Server Enterprise (ASE) which use the Transact-SQL
&quot;    syntax.  That syntax does not have end tags for IF&#039;s, which makes
&quot;    indenting more difficult.
&quot;
&quot; Known Issues:
&quot;    The Oracle MERGE statement does not have an end tag associated with
&quot;    it, this can leave the indent hanging to the right one too many.
&quot;
&quot; History:
&quot;    3.0 (Dec 2012)
&quot;        Added cpo check
&quot;
&quot;    2.0
&quot;        Added the FOR keyword to SQLBlockStart to handle (Alec Tica):
&quot;            for i in 1..100 loop
&quot;              |&lt;-- I expect to have indentation here
&quot;            end loop;
&quot;

&quot; Only load this indent file when no other was loaded.
if exists(&quot;b:did_indent&quot;)
    finish
endif
let b:did_indent     = 1
let b:current_indent = &quot;sqlanywhere&quot;

setlocal indentkeys-=0{
setlocal indentkeys-=0}
setlocal indentkeys-=:
setlocal indentkeys-=0#
setlocal indentkeys-=e

&quot; This indicates formatting should take place when one of these
&quot; expressions is used.  These expressions would normally be something
&quot; you would type at the BEGINNING of a line
&quot; SQL is generally case insensitive, so this files assumes that
&quot; These keywords are something that would trigger an indent LEFT, not
&quot; an indent right, since the SQLBlockStart is used for those keywords
setlocal indentkeys+==~end,=~else,=~elseif,=~elsif,0=~when,0=)

&quot; GetSQLIndent is executed whenever one of the expressions
&quot; in the indentkeys is typed
setlocal indentexpr=GetSQLIndent()

&quot; Only define the functions once.
if exists(&quot;*GetSQLIndent&quot;)
    finish
endif
let s:keepcpo= &amp;cpo
set cpo&amp;vim

&quot; List of all the statements that start a new block.
&quot; These are typically words that start a line.
&quot; IS is excluded, since it is difficult to determine when the
&quot; ending block is (especially for procedures/functions).
let s:SQLBlockStart = &#039;^\s*\%(&#039;.
                \ &#039;if\|else\|elseif\|elsif\|&#039;.
                \ &#039;while\|loop\|do\|for\|&#039;.
                \ &#039;begin\|&#039;.
                \ &#039;case\|when\|merge\|exception&#039;.
                \ &#039;\)\&gt;&#039;
let s:SQLBlockEnd = &#039;^\s*\(end\)\&gt;&#039;

&quot; The indent level is also based on unmatched paranethesis
&quot; If a line has an extra &quot;(&quot; increase the indent
&quot; If a line has an extra &quot;)&quot; decrease the indent
function! s:CountUnbalancedParan( line, paran_to_check )
    let l = a:line
    let lp = substitute(l, &#039;[^(]&#039;, &#039;&#039;, &#039;g&#039;)
    let l = a:line
    let rp = substitute(l, &#039;[^)]&#039;, &#039;&#039;, &#039;g&#039;)

    if a:paran_to_check =~ &#039;)&#039;
        &quot; echom &#039;CountUnbalancedParan ) returning: &#039; .
        &quot; \ (strlen(rp) - strlen(lp))
        return (strlen(rp) - strlen(lp))
    elseif a:paran_to_check =~ &#039;(&#039;
        &quot; echom &#039;CountUnbalancedParan ( returning: &#039; .
        &quot; \ (strlen(lp) - strlen(rp))
        return (strlen(lp) - strlen(rp))
    else
        &quot; echom &#039;CountUnbalancedParan unknown paran to check: &#039; .
        &quot; \ a:paran_to_check
        return 0
    endif
endfunction

&quot; Unindent commands based on previous indent level
function! s:CheckToIgnoreRightParan( prev_lnum, num_levels )
    let lnum = a:prev_lnum
    let line = getline(lnum)
    let ends = 0
    let num_right_paran = a:num_levels
    let ignore_paran = 0
    let vircol = 1

    while num_right_paran &gt; 0
        silent! exec &#039;norm! &#039;.lnum.&quot;G\&lt;bar&gt;&quot;.vircol.&quot;\&lt;bar&gt;&quot;
        let right_paran = search( &#039;)&#039;, &#039;W&#039; )
        if right_paran != lnum
            &quot; This should not happen since there should be at least
            &quot; num_right_paran matches for this line
            break
        endif
        let vircol      = virtcol(&quot;.&quot;)

        &quot; if getline(&quot;.&quot;) =~ &#039;^)&#039;
        let matching_paran = searchpair(&#039;(&#039;, &#039;&#039;, &#039;)&#039;, &#039;bW&#039;,
                    \ &#039;s:IsColComment(line(&quot;.&quot;), col(&quot;.&quot;))&#039;)

        if matching_paran &lt; 1
            &quot; No match found
            &quot; echom &#039;CTIRP - no match found, ignoring&#039;
            break
        endif

        if matching_paran == lnum
            &quot; This was not an unmatched parantenses, start the search again
            &quot; again after this column
            &quot; echom &#039;CTIRP - same line match, ignoring&#039;
            continue
        endif

        &quot; echom &#039;CTIRP - match: &#039; . line(&quot;.&quot;) . &#039;  &#039; . getline(&quot;.&quot;)

        if getline(matching_paran) =~? &#039;\(if\|while\)\&gt;&#039;
            &quot; echom &#039;CTIRP - if/while ignored: &#039; . line(&quot;.&quot;) . &#039;  &#039; . getline(&quot;.&quot;)
            let ignore_paran = ignore_paran + 1
        endif

        &quot; One match found, decrease and check for further matches
        let num_right_paran = num_right_paran - 1

    endwhile

    &quot; Fallback - just move back one
    &quot; return a:prev_indent - shiftwidth()
    return ignore_paran
endfunction

&quot; Based on the keyword provided, loop through previous non empty
&quot; non comment lines to find the statement that initated the keyword.
&quot; Return its indent level
&quot;    CASE ..
&quot;    WHEN ...
&quot; Should return indent level of CASE
&quot;    EXCEPTION ..
&quot;    WHEN ...
&quot;         something;
&quot;    WHEN ...
&quot; Should return indent level of exception.
function! s:GetStmtStarterIndent( keyword, curr_lnum )
    let lnum  = a:curr_lnum

    &quot; Default - reduce indent by 1
    let ind = indent(a:curr_lnum) - shiftwidth()

    if a:keyword =~? &#039;end&#039;
        exec &#039;normal! ^&#039;
        let stmts = &#039;^\s*\%(&#039;.
                    \ &#039;\&lt;begin\&gt;\|&#039; .
                    \ &#039;\%(\%(\&lt;end\s\+\)\@&lt;!\&lt;loop\&gt;\)\|&#039; .
                    \ &#039;\%(\%(\&lt;end\s\+\)\@&lt;!\&lt;case\&gt;\)\|&#039; .
                    \ &#039;\%(\%(\&lt;end\s\+\)\@&lt;!\&lt;for\&gt;\)\|&#039; .
                    \ &#039;\%(\%(\&lt;end\s\+\)\@&lt;!\&lt;if\&gt;\)&#039;.
                    \ &#039;\)&#039;
        let matching_lnum = searchpair(stmts, &#039;&#039;, &#039;\&lt;end\&gt;\zs&#039;, &#039;bW&#039;,
                    \ &#039;s:IsColComment(line(&quot;.&quot;), col(&quot;.&quot;)) == 1&#039;)
        exec &#039;normal! $&#039;
        if matching_lnum &gt; 0 &amp;&amp; matching_lnum &lt; a:curr_lnum
            let ind = indent(matching_lnum)
        endif
    elseif a:keyword =~? &#039;when&#039;
        exec &#039;normal! ^&#039;
        let matching_lnum = searchpair(
                    \ &#039;\%(\&lt;end\s\+\)\@&lt;!\&lt;case\&gt;\|\&lt;exception\&gt;\|\&lt;merge\&gt;&#039;,
                    \ &#039;&#039;,
                    \ &#039;\%(\%(\&lt;when\s\+others\&gt;\)\|\%(\&lt;end\s\+case\&gt;\)\)&#039;,
                    \ &#039;bW&#039;,
                    \ &#039;s:IsColComment(line(&quot;.&quot;), col(&quot;.&quot;)) == 1&#039;)
        exec &#039;normal! $&#039;
        if matching_lnum &gt; 0 &amp;&amp; matching_lnum &lt; a:curr_lnum
            let ind = indent(matching_lnum)
        else
            let ind = indent(a:curr_lnum)
        endif
    endif

    return ind
endfunction


&quot; Check if the line is a comment
function! s:IsLineComment(lnum)
    let rc = synIDattr(
                \ synID(a:lnum,
                \     match(getline(a:lnum), &#039;\S&#039;)+1, 0)
                \ , &quot;name&quot;)
                \ =~? &quot;comment&quot;

    return rc
endfunction


&quot; Check if the column is a comment
function! s:IsColComment(lnum, cnum)
    let rc = synIDattr(synID(a:lnum, a:cnum, 0), &quot;name&quot;)
                \           =~? &quot;comment&quot;

    return rc
endfunction


&quot; Instead of returning a column position, return
&quot; an appropriate value as a factor of shiftwidth.
function! s:ModuloIndent(ind)
    let ind = a:ind

    if ind &gt; 0
        let modulo = ind % shiftwidth()

        if modulo &gt; 0
            let ind = ind - modulo
        endif
    endif

    return ind
endfunction


&quot; Find correct indent of a new line based upon the previous line
function! GetSQLIndent()
    let lnum = v:lnum
    let ind = indent(lnum)

    &quot; If the current line is a comment, leave the indent as is
    &quot; Comment out this additional check since it affects the
    &quot; indenting of =, and will not reindent comments as it should
    &quot; if s:IsLineComment(lnum) == 1
    &quot;     return ind
    &quot; endif

    &quot; Get previous non-blank line
    let prevlnum = prevnonblank(lnum - 1)
    if prevlnum &lt;= 0
        return ind
    endif

    if s:IsLineComment(prevlnum) == 1
        if getline(v:lnum) =~ &#039;^\s*\*&#039;
            let ind = s:ModuloIndent(indent(prevlnum))
            return ind + 1
        endif
        &quot; If the previous line is a comment, then return -1
        &quot; to tell Vim to use the formatoptions setting to determine
        &quot; the indent to use
        &quot; But only if the next line is blank.  This would be true if
        &quot; the user is typing, but it would not be true if the user
        &quot; is reindenting the file
        if getline(v:lnum) =~ &#039;^\s*$&#039;
            return -1
        endif
    endif

    &quot; echom &#039;PREVIOUS INDENT: &#039; . indent(prevlnum) . &#039;  LINE: &#039; . getline(prevlnum)

    &quot; This is the line you just hit return on, it is not the current line
    &quot; which is new and empty
    &quot; Based on this line, we can determine how much to indent the new
    &quot; line

    &quot; Get default indent (from prev. line)
    let ind      = indent(prevlnum)
    let prevline = getline(prevlnum)

    &quot; Now check what&#039;s on the previous line to determine if the indent
    &quot; should be changed, for example IF, BEGIN, should increase the indent
    &quot; where END IF, END, should decrease the indent.
    if prevline =~? s:SQLBlockStart
        &quot; Move indent in
        let ind = ind + shiftwidth()
        &quot; echom &#039;prevl - SQLBlockStart - indent &#039; . ind . &#039;  line: &#039; . prevline
    elseif prevline =~ &#039;[()]&#039;
        if prevline =~ &#039;(&#039;
            let num_unmatched_left = s:CountUnbalancedParan( prevline, &#039;(&#039; )
        else
            let num_unmatched_left = 0
        endif
        if prevline =~ &#039;)&#039;
            let num_unmatched_right  = s:CountUnbalancedParan( prevline, &#039;)&#039; )
        else
            let num_unmatched_right  = 0
            &quot; let num_unmatched_right  = s:CountUnbalancedParan( prevline, &#039;)&#039; )
        endif
        if num_unmatched_left &gt; 0
            &quot; There is a open left paranethesis
            &quot; increase indent
            let ind = ind + ( shiftwidth() * num_unmatched_left )
        elseif num_unmatched_right &gt; 0
            &quot; if it is an unbalanced paranethesis only unindent if
            &quot; it was part of a command (ie create table(..)  )
            &quot; instead of part of an if (ie if (....) then) which should
            &quot; maintain the indent level
            let ignore = s:CheckToIgnoreRightParan( prevlnum, num_unmatched_right )
            &quot; echom &#039;prevl - ) unbalanced - CTIRP - ignore: &#039; . ignore

            if prevline =~ &#039;^\s*)&#039;
                let ignore = ignore + 1
                &quot; echom &#039;prevl - begins ) unbalanced ignore: &#039; . ignore
            endif

            if (num_unmatched_right - ignore) &gt; 0
                let ind = ind - ( shiftwidth() * (num_unmatched_right - ignore) )
            endif

        endif
    endif


    &quot; echom &#039;CURRENT INDENT: &#039; . ind . &#039;  LINE: &#039;  . getline(v:lnum)

    &quot; This is a new blank line since we just typed a carriage return
    &quot; Check current line; search for simplistic matching start-of-block
    let line = getline(v:lnum)

    if line =~? &#039;^\s*els&#039;
        &quot; Any line when you type else will automatically back up one
        &quot; ident level  (ie else, elseif, elsif)
        let ind = ind - shiftwidth()
        &quot; echom &#039;curr - else - indent &#039; . ind
    elseif line =~? &#039;^\s*end\&gt;&#039;
        let ind = s:GetStmtStarterIndent(&#039;end&#039;, v:lnum)
        &quot; General case for end
        &quot; let ind = ind - shiftwidth()
        &quot; echom &#039;curr - end - indent &#039; . ind
    elseif line =~? &#039;^\s*when\&gt;&#039;
        let ind = s:GetStmtStarterIndent(&#039;when&#039;, v:lnum)
        &quot; If the WHEN clause is used with a MERGE or EXCEPTION
        &quot; clause, do not change the indent level, since these
        &quot; statements do not have a corresponding END statement.
        &quot; if stmt_starter =~? &#039;case&#039;
        &quot;    let ind = ind - shiftwidth()
        &quot; endif
        &quot; elseif line =~ &#039;^\s*)\s*;\?\s*$&#039;
        &quot; elseif line =~ &#039;^\s*)&#039;
    elseif line =~ &#039;^\s*)&#039;
        let num_unmatched_right  = s:CountUnbalancedParan( line, &#039;)&#039; )
        let ignore = s:CheckToIgnoreRightParan( v:lnum, num_unmatched_right )
        &quot; If the line ends in a ), then reduce the indent
        &quot; This catches items like:
        &quot; CREATE TABLE T1(
        &quot;    c1 int,
        &quot;    c2 int
        &quot;    );
        &quot; But we do not want to unindent a line like:
        &quot; IF ( c1 = 1
        &quot; AND  c2 = 3 ) THEN
        &quot; let num_unmatched_right  = s:CountUnbalancedParan( line, &#039;)&#039; )
        &quot; if num_unmatched_right &gt; 0
        &quot; elseif strpart( line, strlen(line)-1, 1 ) =~ &#039;)&#039;
        &quot; let ind = ind - shiftwidth()
        if line =~ &#039;^\s*)&#039;
            &quot; let ignore = ignore + 1
            &quot; echom &#039;curr - begins ) unbalanced ignore: &#039; . ignore
        endif

        if (num_unmatched_right - ignore) &gt; 0
            let ind = ind - ( shiftwidth() * (num_unmatched_right - ignore) )
        endif
        &quot; endif
    endif

    &quot; echom &#039;final - indent &#039; . ind
    return s:ModuloIndent(ind)
endfunction

&quot;  Restore:
let &amp;cpo= s:keepcpo
unlet s:keepcpo
&quot; vim: ts=4 fdm=marker sw=4
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>