Mercurial > vim
annotate runtime/indent/sqlanywhere.vim @ 20753:661eb972cb22
Update runtime files
Commit: https://github.com/vim/vim/commit/acc224064033e5cea21ef7f1eefb356ca06ff11d
Author: Bram Moolenaar <Bram@vim.org>
Date: Sun Jun 7 21:07:18 2020 +0200
Update runtime files
| author | Bram Moolenaar <Bram@vim.org> |
|---|---|
| date | Sun, 07 Jun 2020 21:15:04 +0200 |
| parents | 63b0b7b79b25 |
| children | 11b656e74444 |
| rev | line source |
|---|---|
| 718 | 1 " Vim indent file |
| 856 | 2 " Language: SQL |
| 3996 | 3 " Maintainer: David Fishburn <dfishburn dot vim at gmail dot com> |
| 20753 | 4 " Last Change By Maintainer: 2017 Jun 13 |
| 5 " Last Change: by Stephen Wall, #5578, 2020 Jun 07 | |
| 3996 | 6 " Version: 3.0 |
| 718 | 7 " Download: http://vim.sourceforge.net/script.php?script_id=495 |
| 8 | |
| 9 " Notes: | |
| 10 " Indenting keywords are based on Oracle and Sybase Adaptive Server | |
| 11 " Anywhere (ASA). Test indenting was done with ASA stored procedures and | |
| 12 " fuctions and Oracle packages which contain stored procedures and | |
| 13 " functions. | |
| 856 | 14 " This has not been tested against Microsoft SQL Server or |
| 718 | 15 " Sybase Adaptive Server Enterprise (ASE) which use the Transact-SQL |
| 16 " syntax. That syntax does not have end tags for IF's, which makes | |
| 17 " indenting more difficult. | |
| 18 " | |
| 19 " Known Issues: | |
| 20 " The Oracle MERGE statement does not have an end tag associated with | |
| 21 " it, this can leave the indent hanging to the right one too many. | |
| 3996 | 22 " |
| 23 " History: | |
| 24 " 3.0 (Dec 2012) | |
| 25 " Added cpo check | |
| 26 " | |
| 27 " 2.0 | |
| 28 " Added the FOR keyword to SQLBlockStart to handle (Alec Tica): | |
| 29 " for i in 1..100 loop | |
| 30 " |<-- I expect to have indentation here | |
| 31 " end loop; | |
| 32 " | |
| 718 | 33 |
| 34 " Only load this indent file when no other was loaded. | |
| 35 if exists("b:did_indent") | |
| 36 finish | |
| 37 endif | |
| 38 let b:did_indent = 1 | |
| 39 let b:current_indent = "sqlanywhere" | |
| 40 | |
| 41 setlocal indentkeys-=0{ | |
| 42 setlocal indentkeys-=0} | |
| 43 setlocal indentkeys-=: | |
| 44 setlocal indentkeys-=0# | |
| 45 setlocal indentkeys-=e | |
| 46 | |
| 856 | 47 " This indicates formatting should take place when one of these |
| 718 | 48 " expressions is used. These expressions would normally be something |
| 49 " you would type at the BEGINNING of a line | |
| 50 " SQL is generally case insensitive, so this files assumes that | |
| 51 " These keywords are something that would trigger an indent LEFT, not | |
| 52 " an indent right, since the SQLBlockStart is used for those keywords | |
| 53 setlocal indentkeys+==~end,=~else,=~elseif,=~elsif,0=~when,0=) | |
| 54 | |
| 856 | 55 " GetSQLIndent is executed whenever one of the expressions |
| 718 | 56 " in the indentkeys is typed |
| 57 setlocal indentexpr=GetSQLIndent() | |
| 58 | |
| 4073 | 59 " Only define the functions once. |
| 60 if exists("*GetSQLIndent") | |
| 61 finish | |
| 62 endif | |
| 63 let s:keepcpo= &cpo | |
| 64 set cpo&vim | |
| 65 | |
| 718 | 66 " List of all the statements that start a new block. |
| 67 " These are typically words that start a line. | |
| 856 | 68 " IS is excluded, since it is difficult to determine when the |
| 718 | 69 " ending block is (especially for procedures/functions). |
| 70 let s:SQLBlockStart = '^\s*\%('. | |
| 20753 | 71 \ 'if\>.*\<then\|'. |
| 72 \ 'then\|else\>\|'. | |
| 73 \ 'elseif\>.*\<then\|'. | |
| 74 \ 'elsif\>.(\<then\|'. | |
| 75 \ 'while\>.*\<loop\|'. | |
| 76 \ 'for\>.*\<loop\|'. | |
| 77 \ 'foreach\>.*\<loop\|'. | |
| 78 \ 'loop\|do\|declare\|begin\|'. | |
| 718 | 79 \ 'case\|when\|merge\|exception'. |
| 80 \ '\)\>' | |
| 81 let s:SQLBlockEnd = '^\s*\(end\)\>' | |
| 82 | |
| 20753 | 83 " The indent level is also based on unmatched parentheses |
| 718 | 84 " If a line has an extra "(" increase the indent |
| 85 " If a line has an extra ")" decrease the indent | |
| 20753 | 86 function! s:CountUnbalancedParen( line, paren_to_check ) |
| 718 | 87 let l = a:line |
| 88 let lp = substitute(l, '[^(]', '', 'g') | |
| 89 let l = a:line | |
| 90 let rp = substitute(l, '[^)]', '', 'g') | |
| 91 | |
| 20753 | 92 if a:paren_to_check =~ ')' |
| 93 " echom 'CountUnbalancedParen ) returning: ' . | |
| 718 | 94 " \ (strlen(rp) - strlen(lp)) |
| 95 return (strlen(rp) - strlen(lp)) | |
| 20753 | 96 elseif a:paren_to_check =~ '(' |
| 97 " echom 'CountUnbalancedParen ( returning: ' . | |
| 718 | 98 " \ (strlen(lp) - strlen(rp)) |
| 99 return (strlen(lp) - strlen(rp)) | |
| 100 else | |
| 20753 | 101 " echom 'CountUnbalancedParen unknown paren to check: ' . |
| 102 " \ a:paren_to_check | |
| 718 | 103 return 0 |
| 104 endif | |
| 105 endfunction | |
| 106 | |
| 107 " Unindent commands based on previous indent level | |
| 20753 | 108 function! s:CheckToIgnoreRightParen( prev_lnum, num_levels ) |
| 718 | 109 let lnum = a:prev_lnum |
| 110 let line = getline(lnum) | |
| 111 let ends = 0 | |
| 20753 | 112 let num_right_paren = a:num_levels |
| 113 let ignore_paren = 0 | |
| 718 | 114 let vircol = 1 |
| 115 | |
| 20753 | 116 while num_right_paren > 0 |
| 718 | 117 silent! exec 'norm! '.lnum."G\<bar>".vircol."\<bar>" |
| 20753 | 118 let right_paren = search( ')', 'W' ) |
| 119 if right_paren != lnum | |
| 718 | 120 " This should not happen since there should be at least |
| 20753 | 121 " num_right_paren matches for this line |
| 718 | 122 break |
| 123 endif | |
| 124 let vircol = virtcol(".") | |
| 125 | |
| 126 " if getline(".") =~ '^)' | |
| 20753 | 127 let matching_paren = searchpair('(', '', ')', 'bW', |
| 1619 | 128 \ 's:IsColComment(line("."), col("."))') |
| 718 | 129 |
| 20753 | 130 if matching_paren < 1 |
| 718 | 131 " No match found |
| 132 " echom 'CTIRP - no match found, ignoring' | |
| 133 break | |
| 134 endif | |
| 135 | |
| 20753 | 136 if matching_paren == lnum |
| 137 " This was not an unmatched parentheses, start the search again | |
| 718 | 138 " again after this column |
| 139 " echom 'CTIRP - same line match, ignoring' | |
| 140 continue | |
| 141 endif | |
| 142 | |
| 143 " echom 'CTIRP - match: ' . line(".") . ' ' . getline(".") | |
| 144 | |
| 20753 | 145 if getline(matching_paren) =~? '\(if\|while\)\>' |
| 718 | 146 " echom 'CTIRP - if/while ignored: ' . line(".") . ' ' . getline(".") |
| 20753 | 147 let ignore_paren = ignore_paren + 1 |
| 718 | 148 endif |
| 149 | |
| 150 " One match found, decrease and check for further matches | |
| 20753 | 151 let num_right_paren = num_right_paren - 1 |
| 718 | 152 |
| 153 endwhile | |
| 154 | |
| 155 " Fallback - just move back one | |
| 11518 | 156 " return a:prev_indent - shiftwidth() |
| 20753 | 157 return ignore_paren |
| 718 | 158 endfunction |
| 159 | |
| 160 " Based on the keyword provided, loop through previous non empty | |
| 20753 | 161 " non comment lines to find the statement that initiated the keyword. |
| 718 | 162 " Return its indent level |
| 163 " CASE .. | |
| 164 " WHEN ... | |
| 165 " Should return indent level of CASE | |
| 166 " EXCEPTION .. | |
| 167 " WHEN ... | |
| 168 " something; | |
| 169 " WHEN ... | |
| 170 " Should return indent level of exception. | |
| 3996 | 171 function! s:GetStmtStarterIndent( keyword, curr_lnum ) |
| 718 | 172 let lnum = a:curr_lnum |
| 173 | |
| 174 " Default - reduce indent by 1 | |
| 11518 | 175 let ind = indent(a:curr_lnum) - shiftwidth() |
| 718 | 176 |
| 177 if a:keyword =~? 'end' | |
| 178 exec 'normal! ^' | |
| 179 let stmts = '^\s*\%('. | |
| 180 \ '\<begin\>\|' . | |
| 181 \ '\%(\%(\<end\s\+\)\@<!\<loop\>\)\|' . | |
| 182 \ '\%(\%(\<end\s\+\)\@<!\<case\>\)\|' . | |
| 183 \ '\%(\%(\<end\s\+\)\@<!\<for\>\)\|' . | |
| 184 \ '\%(\%(\<end\s\+\)\@<!\<if\>\)'. | |
| 185 \ '\)' | |
| 186 let matching_lnum = searchpair(stmts, '', '\<end\>\zs', 'bW', | |
| 1619 | 187 \ 's:IsColComment(line("."), col(".")) == 1') |
| 718 | 188 exec 'normal! $' |
| 189 if matching_lnum > 0 && matching_lnum < a:curr_lnum | |
| 190 let ind = indent(matching_lnum) | |
| 191 endif | |
| 192 elseif a:keyword =~? 'when' | |
| 193 exec 'normal! ^' | |
| 194 let matching_lnum = searchpair( | |
| 856 | 195 \ '\%(\<end\s\+\)\@<!\<case\>\|\<exception\>\|\<merge\>', |
| 196 \ '', | |
| 197 \ '\%(\%(\<when\s\+others\>\)\|\%(\<end\s\+case\>\)\)', | |
| 718 | 198 \ 'bW', |
| 1619 | 199 \ 's:IsColComment(line("."), col(".")) == 1') |
| 718 | 200 exec 'normal! $' |
| 201 if matching_lnum > 0 && matching_lnum < a:curr_lnum | |
| 202 let ind = indent(matching_lnum) | |
| 203 else | |
| 204 let ind = indent(a:curr_lnum) | |
| 205 endif | |
| 206 endif | |
| 207 | |
| 208 return ind | |
| 209 endfunction | |
| 210 | |
| 211 | |
| 212 " Check if the line is a comment | |
| 3996 | 213 function! s:IsLineComment(lnum) |
| 718 | 214 let rc = synIDattr( |
| 856 | 215 \ synID(a:lnum, |
| 718 | 216 \ match(getline(a:lnum), '\S')+1, 0) |
| 856 | 217 \ , "name") |
| 218 \ =~? "comment" | |
| 718 | 219 |
| 220 return rc | |
| 221 endfunction | |
| 222 | |
| 223 | |
| 224 " Check if the column is a comment | |
| 3996 | 225 function! s:IsColComment(lnum, cnum) |
| 856 | 226 let rc = synIDattr(synID(a:lnum, a:cnum, 0), "name") |
| 227 \ =~? "comment" | |
| 718 | 228 |
| 229 return rc | |
| 230 endfunction | |
| 231 | |
| 232 | |
| 1619 | 233 " Instead of returning a column position, return |
| 234 " an appropriate value as a factor of shiftwidth. | |
| 3996 | 235 function! s:ModuloIndent(ind) |
| 718 | 236 let ind = a:ind |
| 856 | 237 |
| 718 | 238 if ind > 0 |
| 11518 | 239 let modulo = ind % shiftwidth() |
| 718 | 240 |
| 241 if modulo > 0 | |
| 242 let ind = ind - modulo | |
| 243 endif | |
| 244 endif | |
| 245 | |
| 246 return ind | |
| 247 endfunction | |
| 248 | |
| 249 | |
| 250 " Find correct indent of a new line based upon the previous line | |
| 3996 | 251 function! GetSQLIndent() |
| 856 | 252 let lnum = v:lnum |
| 718 | 253 let ind = indent(lnum) |
| 254 | |
| 255 " If the current line is a comment, leave the indent as is | |
| 256 " Comment out this additional check since it affects the | |
| 257 " indenting of =, and will not reindent comments as it should | |
| 1619 | 258 " if s:IsLineComment(lnum) == 1 |
| 718 | 259 " return ind |
| 260 " endif | |
| 261 | |
| 3996 | 262 " Get previous non-blank line |
| 263 let prevlnum = prevnonblank(lnum - 1) | |
| 264 if prevlnum <= 0 | |
| 265 return ind | |
| 266 endif | |
| 718 | 267 |
| 3996 | 268 if s:IsLineComment(prevlnum) == 1 |
| 269 if getline(v:lnum) =~ '^\s*\*' | |
| 270 let ind = s:ModuloIndent(indent(prevlnum)) | |
| 271 return ind + 1 | |
| 718 | 272 endif |
| 3996 | 273 " If the previous line is a comment, then return -1 |
| 274 " to tell Vim to use the formatoptions setting to determine | |
| 275 " the indent to use | |
| 276 " But only if the next line is blank. This would be true if | |
| 277 " the user is typing, but it would not be true if the user | |
| 278 " is reindenting the file | |
| 279 if getline(v:lnum) =~ '^\s*$' | |
| 280 return -1 | |
| 281 endif | |
| 282 endif | |
| 718 | 283 |
| 856 | 284 " echom 'PREVIOUS INDENT: ' . indent(prevlnum) . ' LINE: ' . getline(prevlnum) |
| 718 | 285 |
| 286 " This is the line you just hit return on, it is not the current line | |
| 287 " which is new and empty | |
| 288 " Based on this line, we can determine how much to indent the new | |
| 289 " line | |
| 856 | 290 |
| 718 | 291 " Get default indent (from prev. line) |
| 292 let ind = indent(prevlnum) | |
| 293 let prevline = getline(prevlnum) | |
| 294 | |
| 295 " Now check what's on the previous line to determine if the indent | |
| 296 " should be changed, for example IF, BEGIN, should increase the indent | |
| 297 " where END IF, END, should decrease the indent. | |
| 298 if prevline =~? s:SQLBlockStart | |
| 299 " Move indent in | |
| 11518 | 300 let ind = ind + shiftwidth() |
| 718 | 301 " echom 'prevl - SQLBlockStart - indent ' . ind . ' line: ' . prevline |
| 302 elseif prevline =~ '[()]' | |
| 303 if prevline =~ '(' | |
| 20753 | 304 let num_unmatched_left = s:CountUnbalancedParen( prevline, '(' ) |
| 718 | 305 else |
| 306 let num_unmatched_left = 0 | |
| 307 endif | |
| 308 if prevline =~ ')' | |
| 20753 | 309 let num_unmatched_right = s:CountUnbalancedParen( prevline, ')' ) |
| 718 | 310 else |
| 311 let num_unmatched_right = 0 | |
| 20753 | 312 " let num_unmatched_right = s:CountUnbalancedParen( prevline, ')' ) |
| 718 | 313 endif |
| 314 if num_unmatched_left > 0 | |
| 20753 | 315 " There is a open left parenthesis |
| 718 | 316 " increase indent |
| 11518 | 317 let ind = ind + ( shiftwidth() * num_unmatched_left ) |
| 718 | 318 elseif num_unmatched_right > 0 |
| 20753 | 319 " if it is an unbalanced parenthesis only unindent if |
| 718 | 320 " it was part of a command (ie create table(..) ) |
| 321 " instead of part of an if (ie if (....) then) which should | |
| 322 " maintain the indent level | |
| 20753 | 323 let ignore = s:CheckToIgnoreRightParen( prevlnum, num_unmatched_right ) |
| 718 | 324 " echom 'prevl - ) unbalanced - CTIRP - ignore: ' . ignore |
| 325 | |
| 326 if prevline =~ '^\s*)' | |
| 327 let ignore = ignore + 1 | |
| 328 " echom 'prevl - begins ) unbalanced ignore: ' . ignore | |
| 329 endif | |
| 330 | |
| 331 if (num_unmatched_right - ignore) > 0 | |
| 11518 | 332 let ind = ind - ( shiftwidth() * (num_unmatched_right - ignore) ) |
| 718 | 333 endif |
| 334 | |
| 335 endif | |
| 336 endif | |
| 337 | |
| 338 | |
| 339 " echom 'CURRENT INDENT: ' . ind . ' LINE: ' . getline(v:lnum) | |
| 340 | |
| 341 " This is a new blank line since we just typed a carriage return | |
| 342 " Check current line; search for simplistic matching start-of-block | |
| 343 let line = getline(v:lnum) | |
| 344 | |
| 345 if line =~? '^\s*els' | |
| 856 | 346 " Any line when you type else will automatically back up one |
| 718 | 347 " ident level (ie else, elseif, elsif) |
| 11518 | 348 let ind = ind - shiftwidth() |
| 718 | 349 " echom 'curr - else - indent ' . ind |
| 350 elseif line =~? '^\s*end\>' | |
| 351 let ind = s:GetStmtStarterIndent('end', v:lnum) | |
| 352 " General case for end | |
| 11518 | 353 " let ind = ind - shiftwidth() |
| 718 | 354 " echom 'curr - end - indent ' . ind |
| 355 elseif line =~? '^\s*when\>' | |
| 356 let ind = s:GetStmtStarterIndent('when', v:lnum) | |
| 357 " If the WHEN clause is used with a MERGE or EXCEPTION | |
| 358 " clause, do not change the indent level, since these | |
| 359 " statements do not have a corresponding END statement. | |
| 360 " if stmt_starter =~? 'case' | |
| 11518 | 361 " let ind = ind - shiftwidth() |
| 718 | 362 " endif |
| 363 " elseif line =~ '^\s*)\s*;\?\s*$' | |
| 364 " elseif line =~ '^\s*)' | |
| 365 elseif line =~ '^\s*)' | |
| 20753 | 366 let num_unmatched_right = s:CountUnbalancedParen( line, ')' ) |
| 367 let ignore = s:CheckToIgnoreRightParen( v:lnum, num_unmatched_right ) | |
| 718 | 368 " If the line ends in a ), then reduce the indent |
| 369 " This catches items like: | |
| 370 " CREATE TABLE T1( | |
| 856 | 371 " c1 int, |
| 718 | 372 " c2 int |
| 373 " ); | |
| 374 " But we do not want to unindent a line like: | |
| 856 | 375 " IF ( c1 = 1 |
| 718 | 376 " AND c2 = 3 ) THEN |
| 20753 | 377 " let num_unmatched_right = s:CountUnbalancedParen( line, ')' ) |
| 718 | 378 " if num_unmatched_right > 0 |
| 379 " elseif strpart( line, strlen(line)-1, 1 ) =~ ')' | |
| 11518 | 380 " let ind = ind - shiftwidth() |
| 718 | 381 if line =~ '^\s*)' |
| 382 " let ignore = ignore + 1 | |
| 383 " echom 'curr - begins ) unbalanced ignore: ' . ignore | |
| 384 endif | |
| 385 | |
| 386 if (num_unmatched_right - ignore) > 0 | |
| 11518 | 387 let ind = ind - ( shiftwidth() * (num_unmatched_right - ignore) ) |
| 718 | 388 endif |
| 389 " endif | |
| 390 endif | |
| 391 | |
| 392 " echom 'final - indent ' . ind | |
| 1619 | 393 return s:ModuloIndent(ind) |
| 718 | 394 endfunction |
| 395 | |
| 3996 | 396 " Restore: |
| 397 let &cpo= s:keepcpo | |
|
3526
dd6c2497c997
Fix more 'cpo' issues in runtime files.
Bram Moolenaar <bram@vim.org>
parents:
1619
diff
changeset
|
398 unlet s:keepcpo |
| 3996 | 399 " vim: ts=4 fdm=marker sw=4 |