| " Vim indent file |
| " Language: PHP |
| " Author: John Wellesz <John.wellesz (AT) teaser (DOT) fr> |
| " URL: http://www.2072productions.com/vim/indent/php.vim |
| " Last Change: 2005 Aug 15 |
| " Version: 1.17 |
| " |
| " For a complete change log and lots of comments in the code, download the script on |
| " 2072productions.com at the URI provided above. |
| " |
| " |
| " |
| " If you find a bug, please e-mail me at John.wellesz (AT) teaser (DOT) fr |
| " with an example of code that break the algorithm. |
| " |
| " |
| " Thanks a lot for using this script. |
| " |
| " |
| " NOTE: This script must be used with PHP syntax ON and with the php syntax |
| " script by Lutz Eymers (http://www.isp.de/data/php.vim ) that's the script bundled with Gvim. |
| " |
| " |
| " In the case you have syntax errors in your script such as end of HereDoc |
| " tags not at col 1 you'll have to indent your file 2 times (This script |
| " will automatically put HereDoc end tags at col 1). |
| " |
| " |
| " NOTE: If you are editing file in Unix file format and that (by accident) |
| " there are '\r' before new lines, this script won't be able to proceed |
| " correctly and will make many mistakes because it won't be able to match |
| " '\s*$' correctly. |
| " So you have to remove those useless characters first with a command like: |
| " |
| " :%s /\r$//g |
| " |
| " or simply 'let' the option PHP_removeCRwhenUnix to 1 and the script will |
| " silently remove them when VIM load this script (at each bufread). |
| |
| " Options: PHP_default_indenting = # of sw (default is 0), # of sw will be |
| " added to the indent of each line of PHP code. |
| " |
| " Options: PHP_removeCRwhenUnix = 1 to make the script automatically remove CR |
| " at end of lines (by default this option is unset), NOTE that you |
| " MUST remove CR when the fileformat is UNIX else the indentation |
| " won't be correct... |
| " |
| " Options: PHP_BracesAtCodeLevel = 1 to indent the '{' and '}' at the same |
| " level than the code they contain. |
| " Exemple: |
| " Instead of: |
| " if ($foo) |
| " { |
| " foo(); |
| " } |
| " |
| " You will write: |
| " if ($foo) |
| " { |
| " foo(); |
| " } |
| " |
| " NOTE: The script will be a bit slower if you use this option because |
| " some optimizations won't be available. |
| |
| |
| if exists("b:did_indent") |
| finish |
| endif |
| let b:did_indent = 1 |
| |
| " This script set the option php_sync_method of PHP syntax script to 0 |
| " (fromstart indenting method) in order to have an accurate syntax. |
| " If you are using very big PHP files (which is a bad idea) you will |
| " experience slowings down while editing, if your code contains only PHP |
| " code you can comment the line below. |
| |
| let php_sync_method = 0 |
| |
| |
| if exists("PHP_default_indenting") |
| let b:PHP_default_indenting = PHP_default_indenting * &sw |
| else |
| let b:PHP_default_indenting = 0 |
| endif |
| |
| if exists("PHP_BracesAtCodeLevel") |
| let b:PHP_BracesAtCodeLevel = PHP_BracesAtCodeLevel |
| else |
| let b:PHP_BracesAtCodeLevel = 0 |
| endif |
| |
| |
| let b:PHP_lastindented = 0 |
| let b:PHP_indentbeforelast = 0 |
| let b:PHP_indentinghuge = 0 |
| let b:PHP_CurrentIndentLevel = b:PHP_default_indenting |
| let b:PHP_LastIndentedWasComment = 0 |
| let b:PHP_InsideMultilineComment = 0 |
| let b:InPHPcode = 0 |
| let b:InPHPcode_checked = 0 |
| let b:InPHPcode_and_script = 0 |
| let b:InPHPcode_tofind = "" |
| let b:PHP_oldchangetick = b:changedtick |
| let b:UserIsTypingComment = 0 |
| let b:optionsset = 0 |
| |
| setlocal nosmartindent |
| setlocal noautoindent |
| setlocal nocindent |
| setlocal nolisp " autoindent must be on, so this line is also useless... |
| |
| setlocal indentexpr=GetPhpIndent() |
| setlocal indentkeys=0{,0},0),:,!^F,o,O,e,*<Return>,=?>,=<?,=*/ |
| |
| |
| if version <= 603 && &encoding == 'utf-8' |
| let s:searchpairflags = 'bW' |
| else |
| let s:searchpairflags = 'bWr' |
| endif |
| |
| if &fileformat == "unix" && exists("PHP_removeCRwhenUnix") && PHP_removeCRwhenUnix |
| silent! %s/\r$//g |
| endif |
| |
| if exists("*GetPhpIndent") |
| finish " XXX |
| endif |
| |
| let s:endline= '\s*\%(//.*\|#.*\|/\*.*\*/\s*\)\=$' |
| let s:PHP_startindenttag = '<?\%(.*?>\)\@!\|<script[^>]*>\%(.*<\/script>\)\@!' |
| "setlocal debug=msg " XXX |
| |
| |
| function! GetLastRealCodeLNum(startline) " {{{ |
| "Inspired from the function SkipJavaBlanksAndComments by Toby Allsopp for indent/java.vim |
| let lnum = a:startline |
| let old_lnum = lnum |
| |
| while lnum > 1 |
| let lnum = prevnonblank(lnum) |
| let lastline = getline(lnum) |
| |
| if b:InPHPcode_and_script && lastline =~ '?>\s*$' |
| let lnum = lnum - 1 |
| elseif lastline =~ '^\s*?>.*<?\%(php\)\=\s*$' |
| let lnum = lnum - 1 |
| elseif lastline =~ '^\s*\%(//\|#\|/\*.*\*/\s*$\)' " if line is under comment |
| let lnum = lnum - 1 |
| elseif lastline =~ '\*/\s*$' " skip multiline comments |
| call cursor(lnum, 1) |
| call search('\*/\zs', 'W') " positition the cursor after the first */ |
| let lnum = searchpair('/\*', '', '\*/\zs', s:searchpairflags) " find the most outside /* |
| |
| let lastline = getline(lnum) |
| if lastline =~ '^\s*/\*' " if line contains nothing but comment |
| let lnum = lnum - 1 " do the job again on the line before (a comment can hide another...) |
| else |
| break |
| endif |
| |
| |
| elseif lastline =~? '\%(//\s*\|?>.*\)\@<!<?\%(php\)\=\s*$\|^\s*<script\>' " skip non php code |
| |
| while lastline !~ '\(<?.*\)\@<!?>' && lnum > 1 |
| let lnum = lnum - 1 |
| let lastline = getline(lnum) |
| endwhile |
| if lastline =~ '^\s*?>' " if line contains nothing but end tag |
| let lnum = lnum - 1 |
| else |
| break " else there is something important before the ?> |
| endif |
| |
| |
| elseif lastline =~? '^\a\w*;$' && lastline !~? s:notPhpHereDoc " match the end of a heredoc |
| let tofind=substitute( lastline, '\([^;]\+\);', '<<<\1$', '') |
| while getline(lnum) !~? tofind && lnum > 1 |
| let lnum = lnum - 1 |
| endwhile |
| else |
| break " if none of these were true then we are done |
| endif |
| endwhile |
| |
| if lnum==1 && getline(lnum)!~ '<?' |
| let lnum=0 |
| endif |
| |
| if b:InPHPcode_and_script && !b:InPHPcode |
| let b:InPHPcode_and_script = 0 |
| endif |
| return lnum |
| endfunction |
| " }}} |
| |
| function! Skippmatch() " {{{ |
| let synname = synIDattr(synID(line("."), col("."), 0), "name") |
| if synname == "Delimiter" || synname == "phpParent" || synname == "javaScriptBraces" || synname == "phpComment" && b:UserIsTypingComment |
| return 0 |
| else |
| return 1 |
| endif |
| endfun |
| " }}} |
| |
| function! FindOpenBracket(lnum) " {{{ |
| call cursor(a:lnum, 1) " set the cursor to the start of the lnum line |
| return searchpair('{', '', '}', 'bW', 'Skippmatch()') |
| endfun |
| " }}} |
| |
| function! FindTheIfOfAnElse (lnum, StopAfterFirstPrevElse) " {{{ |
| " A very clever recoursive function created by me (John Wellesz) that find the "if" corresponding to an |
| " "else". This function can easily be adapted for other languages :) |
| |
| if getline(a:lnum) =~# '^\s*}\s*else\%(if\)\=\>' |
| let beforeelse = a:lnum " we do this so we can find the opened bracket to speed up the process |
| else |
| let beforeelse = GetLastRealCodeLNum(a:lnum - 1) |
| endif |
| |
| if !s:level |
| let s:iftoskip = 0 |
| endif |
| |
| if getline(beforeelse) =~# '^\s*\%(}\s*\)\=else\%(\s*if\)\@!\>' |
| let s:iftoskip = s:iftoskip + 1 |
| endif |
| |
| if getline(beforeelse) =~ '^\s*}' |
| let beforeelse = FindOpenBracket(beforeelse) |
| |
| if getline(beforeelse) =~ '^\s*{' |
| let beforeelse = GetLastRealCodeLNum(beforeelse - 1) |
| endif |
| endif |
| |
| |
| if !s:iftoskip && a:StopAfterFirstPrevElse && getline(beforeelse) =~# '^\s*\%([}]\s*\)\=else\%(if\)\=\>' |
| return beforeelse |
| endif |
| |
| if getline(beforeelse) !~# '^\s*if\>' && beforeelse>1 || s:iftoskip && beforeelse>1 |
| |
| if s:iftoskip && getline(beforeelse) =~# '^\s*if\>' |
| let s:iftoskip = s:iftoskip - 1 |
| endif |
| |
| let s:level = s:level + 1 |
| let beforeelse = FindTheIfOfAnElse(beforeelse, a:StopAfterFirstPrevElse) |
| endif |
| |
| return beforeelse |
| |
| endfunction |
| " }}} |
| |
| function! IslinePHP (lnum, tofind) " {{{ |
| let cline = getline(a:lnum) |
| |
| if a:tofind=="" |
| let tofind = "^\\s*[\"']*\s*\\zs\\S" " This correct the issue where lines beginning by a |
| " single or double quote were not indented in some cases. |
| else |
| let tofind = a:tofind |
| endif |
| |
| let tofind = tofind . '\c' " ignorecase |
| |
| let coltotest = match (cline, tofind) + 1 "find the first non blank char in the current line |
| |
| let synname = synIDattr(synID(a:lnum, coltotest, 0), "name") " ask to syntax what is its name |
| |
| if synname =~ '^php' || synname=="Delimiter" || synname =~? '^javaScript' |
| return synname |
| else |
| return "" |
| endif |
| endfunction |
| " }}} |
| |
| let s:notPhpHereDoc = '\%(break\|return\|continue\|exit\);' |
| let s:blockstart = '\%(\%(\%(}\s*\)\=else\%(\s\+\)\=\)\=if\>\|while\>\|switch\>\|for\%(each\)\=\>\|declare\>\|[|&]\)' |
| |
| let s:autorestoptions = 0 |
| if ! s:autorestoptions |
| au BufWinEnter,Syntax *.php,*.php3,*.php4,*.php5 call ResetOptions() |
| let s:autorestoptions = 1 |
| endif |
| |
| function! ResetOptions() |
| if ! b:optionsset |
| setlocal formatoptions=qroc |
| let b:optionsset = 1 |
| endif |
| endfunc |
| |
| function! GetPhpIndent() |
| "############################################## |
| "########### MAIN INDENT FUNCTION ############# |
| "############################################## |
| |
| let UserIsEditing=0 |
| if b:PHP_oldchangetick != b:changedtick |
| let b:PHP_oldchangetick = b:changedtick |
| let UserIsEditing=1 |
| endif |
| |
| if b:PHP_default_indenting |
| let b:PHP_default_indenting = g:PHP_default_indenting * &sw |
| endif |
| |
| let cline = getline(v:lnum) " current line |
| |
| if !b:PHP_indentinghuge && b:PHP_lastindented > b:PHP_indentbeforelast |
| if b:PHP_indentbeforelast |
| let b:PHP_indentinghuge = 1 |
| echom 'Large indenting detected, speed optimizations engaged' |
| endif |
| let b:PHP_indentbeforelast = b:PHP_lastindented |
| endif |
| |
| if b:InPHPcode_checked && prevnonblank(v:lnum - 1) != b:PHP_lastindented |
| if b:PHP_indentinghuge |
| echom 'Large indenting deactivated' |
| let b:PHP_indentinghuge = 0 |
| let b:PHP_CurrentIndentLevel = b:PHP_default_indenting |
| endif |
| let b:PHP_lastindented = v:lnum |
| let b:PHP_LastIndentedWasComment=0 |
| let b:PHP_InsideMultilineComment=0 |
| let b:PHP_indentbeforelast = 0 |
| |
| let b:InPHPcode = 0 |
| let b:InPHPcode_checked = 0 |
| let b:InPHPcode_and_script = 0 |
| let b:InPHPcode_tofind = "" |
| |
| elseif v:lnum > b:PHP_lastindented " we are indenting line in > order (we can rely on the line before) |
| let real_PHP_lastindented = b:PHP_lastindented |
| let b:PHP_lastindented = v:lnum |
| endif |
| |
| |
| if !b:InPHPcode_checked " {{{ One time check |
| let b:InPHPcode_checked = 1 |
| |
| let synname = IslinePHP (prevnonblank(v:lnum), "") " the line could be blank (if the user presses 'return') |
| |
| if synname!="" |
| if synname != "phpHereDoc" |
| let b:InPHPcode = 1 |
| let b:InPHPcode_tofind = "" |
| |
| if synname == "phpComment" |
| let b:UserIsTypingComment = 1 |
| else |
| let b:UserIsTypingComment = 0 |
| endif |
| |
| if synname =~? '^javaScript' |
| let b:InPHPcode_and_script = 1 |
| endif |
| |
| else |
| let b:InPHPcode = 0 |
| let b:UserIsTypingComment = 0 |
| |
| let lnum = v:lnum - 1 |
| while getline(lnum) !~? '<<<\a\w*$' && lnum > 1 |
| let lnum = lnum - 1 |
| endwhile |
| |
| let b:InPHPcode_tofind = substitute( getline(lnum), '^.*<<<\(\a\w*\)\c', '^\\s*\1;$', '') |
| endif |
| else " IslinePHP returned "" => we are not in PHP or Javascript |
| let b:InPHPcode = 0 |
| let b:UserIsTypingComment = 0 |
| " Then we have to find a php start tag... |
| let b:InPHPcode_tofind = '<?\%(.*?>\)\@!\|<script.*>' |
| endif |
| endif "!b:InPHPcode_checked }}} |
| |
| |
| let lnum = prevnonblank(v:lnum - 1) |
| let last_line = getline(lnum) |
| |
| if b:InPHPcode_tofind!="" |
| if cline =~? b:InPHPcode_tofind |
| let b:InPHPcode = 1 |
| let b:InPHPcode_tofind = "" |
| let b:UserIsTypingComment = 0 |
| if cline =~ '\*/' " End comment tags must be indented like start comment tags |
| call cursor(v:lnum, 1) |
| call search('\*/\zs', 'W') |
| let lnum = searchpair('/\*', '', '\*/\zs', s:searchpairflags) " find the most outside /* |
| |
| let b:PHP_CurrentIndentLevel = b:PHP_default_indenting |
| let b:PHP_LastIndentedWasComment = 0 " prevent a problem if multiline /**/ comment are surounded by |
| " other types of comments |
| |
| if cline =~ '^\s*\*/' |
| return indent(lnum) + 1 |
| else |
| return indent(lnum) |
| endif |
| |
| elseif cline =~? '<script\>' " a more accurate test is useless since there isn't any other possibility |
| let b:InPHPcode_and_script = 1 |
| endif |
| endif |
| endif |
| |
| |
| if b:InPHPcode |
| |
| if !b:InPHPcode_and_script && last_line =~ '\%(<?.*\)\@<!?>\%(.*<?\)\@!' && IslinePHP(lnum, '?>')=="Delimiter" |
| if cline !~? s:PHP_startindenttag |
| let b:InPHPcode = 0 |
| let b:InPHPcode_tofind = s:PHP_startindenttag |
| elseif cline =~? '<script\>' |
| let b:InPHPcode_and_script = 1 |
| endif |
| |
| elseif last_line =~? '<<<\a\w*$' |
| let b:InPHPcode = 0 |
| let b:InPHPcode_tofind = substitute( last_line, '^.*<<<\(\a\w*\)\c', '^\\s*\1;$', '') |
| |
| elseif !UserIsEditing && cline =~ '^\s*/\*\%(.*\*/\)\@!' && getline(v:lnum + 1) !~ '^\s*\*' " XXX indent comments |
| let b:InPHPcode = 0 |
| let b:InPHPcode_tofind = '\*/' |
| |
| elseif cline =~? '^\s*</script>' |
| let b:InPHPcode = 0 |
| let b:InPHPcode_tofind = s:PHP_startindenttag |
| endif |
| endif " }}} |
| |
| if !b:InPHPcode && !b:InPHPcode_and_script |
| return -1 |
| endif |
| |
| |
| " Indent successive // or # comment the same way the first is {{{ |
| if cline =~ '^\s*\%(//\|#\|/\*.*\*/\s*$\)' |
| if b:PHP_LastIndentedWasComment == 1 |
| return indent(real_PHP_lastindented) " line replaced in 1.02 |
| endif |
| let b:PHP_LastIndentedWasComment = 1 |
| else |
| let b:PHP_LastIndentedWasComment = 0 |
| endif |
| " }}} |
| |
| " Indent multiline /* comments correctly {{{ |
| |
| |
| if b:PHP_InsideMultilineComment || b:UserIsTypingComment |
| if cline =~ '^\s*\*\%(\/\)\@!' " if cline == '*' |
| if last_line =~ '^\s*/\*' " if last_line == '/*' |
| return indent(lnum) + 1 |
| else |
| return indent(lnum) |
| endif |
| else |
| let b:PHP_InsideMultilineComment = 0 |
| endif |
| endif |
| |
| if !b:PHP_InsideMultilineComment && cline =~ '^\s*/\*' " if cline == '/*' |
| let b:PHP_InsideMultilineComment = 1 |
| return -1 |
| endif |
| " }}} |
| |
| if cline =~# '^\s*<?' && cline !~ '?>' " Added the ^\s* part in version 1.03 |
| return 0 |
| endif |
| |
| if cline =~ '^\s*?>' && cline !~# '<?' |
| return 0 |
| endif |
| |
| if cline =~? '^\s*\a\w*;$' && cline !~? s:notPhpHereDoc |
| return 0 |
| endif |
| " }}} |
| |
| let s:level = 0 |
| |
| let lnum = GetLastRealCodeLNum(v:lnum - 1) |
| let last_line = getline(lnum) " last line |
| let ind = indent(lnum) " by default |
| let endline= s:endline |
| |
| if ind==0 && b:PHP_default_indenting |
| let ind = b:PHP_default_indenting |
| endif |
| |
| if lnum == 0 |
| return b:PHP_default_indenting |
| endif |
| |
| |
| if cline =~ '^\s*}\%(}}\)\@!' |
| let ind = indent(FindOpenBracket(v:lnum)) |
| let b:PHP_CurrentIndentLevel = b:PHP_default_indenting |
| return ind |
| endif |
| |
| if cline =~ '^\s*\*/' " End comment tags must be indented like start comment tags |
| call cursor(v:lnum, 1) |
| call search('\*/\zs', 'W') |
| let lnum = searchpair('/\*', '', '\*/\zs', s:searchpairflags) " find the most outside /* |
| |
| let b:PHP_CurrentIndentLevel = b:PHP_default_indenting |
| |
| if cline =~ '^\s*\*/' |
| return indent(lnum) + 1 |
| else |
| return indent(lnum) |
| endif |
| endif |
| |
| let defaultORcase = '^\s*\%(default\|case\).*:' |
| |
| if last_line =~ '[;}]'.endline && last_line !~# defaultORcase |
| if ind==b:PHP_default_indenting " if no indentation for the previous line |
| return b:PHP_default_indenting |
| elseif b:PHP_indentinghuge && ind==b:PHP_CurrentIndentLevel && cline !~# '^\s*\%(else\|\%(case\|default\).*:\|[})];\=\)' && last_line !~# '^\s*\%(\%(}\s*\)\=else\)' && getline(GetLastRealCodeLNum(lnum - 1))=~';'.endline |
| return b:PHP_CurrentIndentLevel |
| endif |
| endif |
| |
| let LastLineClosed = 0 " used to prevent redundant tests in the last part of the script |
| |
| let terminated = '\%(;\%(\s*?>\)\=\|<<<\a\w*\|}\)'.endline |
| |
| let unstated = '\%(^\s*'.s:blockstart.'.*)\|\%(//.*\)\@<!\<e'.'lse\>\)'.endline |
| |
| if ind != b:PHP_default_indenting && cline =~# '^\s*else\%(if\)\=\>' |
| let b:PHP_CurrentIndentLevel = b:PHP_default_indenting " prevent optimized to work at next call |
| return indent(FindTheIfOfAnElse(v:lnum, 1)) |
| elseif last_line =~# unstated && cline !~ '^\s*{\|^\s*);\='.endline |
| let ind = ind + &sw |
| return ind |
| |
| |
| elseif ind != b:PHP_default_indenting && last_line =~ terminated |
| let previous_line = last_line |
| let last_line_num = lnum |
| let LastLineClosed = 1 |
| |
| |
| while 1 |
| if previous_line =~ '^\s*}' |
| let last_line_num = FindOpenBracket(last_line_num) |
| |
| if getline(last_line_num) =~ '^\s*{' |
| let last_line_num = GetLastRealCodeLNum(last_line_num - 1) |
| endif |
| |
| let previous_line = getline(last_line_num) |
| |
| continue |
| else |
| if getline(last_line_num) =~# '^\s*else\%(if\)\=\>' |
| let last_line_num = FindTheIfOfAnElse(last_line_num, 0) |
| continue " re-run the loop (we could find a '}' again) |
| endif |
| |
| |
| let last_match = last_line_num " remember the 'topest' line we found so far |
| |
| let one_ahead_indent = indent(last_line_num) |
| let last_line_num = GetLastRealCodeLNum(last_line_num - 1) |
| let two_ahead_indent = indent(last_line_num) |
| let after_previous_line = previous_line |
| let previous_line = getline(last_line_num) |
| |
| |
| if previous_line =~# defaultORcase.'\|{'.endline |
| break |
| endif |
| |
| if after_previous_line=~# '^\s*'.s:blockstart.'.*)'.endline && previous_line =~# '[;}]'.endline |
| break |
| endif |
| |
| if one_ahead_indent == two_ahead_indent || last_line_num < 1 |
| if previous_line =~# '[;}]'.endline || last_line_num < 1 |
| break |
| endif |
| endif |
| endif |
| endwhile |
| |
| if indent(last_match) != ind " if nothing was done lets the old script continue |
| let ind = indent(last_match) " let's use the indent of the last line matched by the alhorithm above |
| let b:PHP_CurrentIndentLevel = b:PHP_default_indenting " line added in version 1.02 to prevent optimized mode |
| " from acting in some special cases |
| |
| if cline =~# defaultORcase |
| let ind = ind - &sw |
| endif |
| return ind |
| endif |
| endif |
| |
| let plinnum = GetLastRealCodeLNum(lnum - 1) |
| let pline = getline(plinnum) " previous to last line |
| |
| let last_line = substitute(last_line,"\\(//\\|#\\)\\(\\(\\([^\"']*\\([\"']\\)[^\"']*\\5\\)\\+[^\"']*$\\)\\|\\([^\"']*$\\)\\)",'','') |
| |
| |
| if ind == b:PHP_default_indenting |
| if last_line =~ terminated |
| let LastLineClosed = 1 |
| endif |
| endif |
| |
| if !LastLineClosed " the last line isn't a .*; or a }$ line |
| if last_line =~# '[{(]'.endline || last_line =~? '\h\w*\s*(.*,$' && pline !~ '[,(]'.endline |
| |
| if !b:PHP_BracesAtCodeLevel || last_line !~# '^\s*{' " XXX mod { |
| let ind = ind + &sw |
| endif |
| |
| if b:PHP_BracesAtCodeLevel || cline !~# defaultORcase " XXX mod (2) { |
| " case and default are not indented inside blocks |
| let b:PHP_CurrentIndentLevel = ind |
| return ind |
| endif |
| |
| elseif last_line =~ '\S\+\s*),'.endline |
| call cursor(lnum, 1) |
| call search('),'.endline, 'W') |
| let openedparent = searchpair('(', '', ')', 'bW', 'Skippmatch()') |
| if openedparent != lnum |
| let ind = indent(openedparent) |
| endif |
| |
| elseif cline !~ '^\s*{' && pline =~ '\%(;\%(\s*?>\)\=\|<<<\a\w*\|{\|^\s*'.s:blockstart.'\s*(.*)\)'.endline.'\|^\s*}\|'.defaultORcase |
| |
| let ind = ind + &sw |
| |
| endif |
| if b:PHP_BracesAtCodeLevel && cline =~# '^\s*{' " XXX mod { |
| let ind = ind + &sw |
| endif |
| |
| elseif last_line =~# defaultORcase |
| let ind = ind + &sw |
| endif |
| |
| if cline =~ '^\s*);\=' |
| let ind = ind - &sw |
| elseif cline =~# defaultORcase |
| let ind = ind - &sw |
| |
| endif |
| |
| let b:PHP_CurrentIndentLevel = ind |
| return ind |
| endfunction |
| |
| " vim: set ts=4 sw=4: |
| " vim: set ff=unix: |