| " Vim indent file generic utility functions |
| " Language: * (various) |
| " Maintainer: Dave Silvia <dsilvia@mchsi.com> |
| " Date: 6/30/2004 |
| |
| " SUMMARY: To use GenericIndent, indent/<your_filename>.vim would have the |
| " following general format: |
| " |
| " if exists("b:did_indent") | finish | endif |
| " let b:did_indent = 1 |
| " runtime indent/GenericIndent.vim |
| " let b:indentStmts='' |
| " let b:dedentStmts='' |
| " let b:allStmts='' |
| " setlocal indentexpr=GenericIndent() |
| " setlocal indentkeys=<your_keys> |
| " call GenericIndentStmts(<your_stmts>) |
| " call GenericDedentStmts(<your_stmts>) |
| " call GenericAllStmts() |
| " |
| " END SUMMARY: |
| |
| " NOTE: b:indentStmts, b:dedentStmts, and b:allStmts need to be initialized |
| " to '' before callin the functions because 'indent.vim' explicitly |
| " 'unlet's b:did_indent. This means that the lists will compound if |
| " you change back and forth between buffers. This is true as of |
| " version 6.3, 6/23/2004. |
| " |
| " NOTE: By default, GenericIndent is case sensitive. |
| " let b:case_insensitive=1 if you want to ignore case, e.g. DOS batch files |
| |
| " The function 'GenericIndent' is data driven and handles most all cases of |
| " indent checking if you first set up the data. To use this function follow |
| " the example below (taken from the file indent/MuPAD_source.vim) |
| " |
| " Before you start, source this file in indent/<your_script>.vim to have it |
| " define functions for your use. |
| " |
| "runtime indent/GenericIndent.vim |
| " |
| " The data is in 5 sets: |
| " |
| " First, set the data set 'indentexpr' to GenericIndent(). |
| " |
| "setlocal indentexpr=GenericIndent() |
| " |
| " Second, set the data set 'indentkeys' to the keywords/expressions that need |
| " to be checked for 'indenting' _as_ they typed. |
| " |
| "setlocal indentkeys==end_proc,=else,=then,=elif,=end_if,=end_case,=until,=end_repeat,=end_domain,=end_for,=end_while,=end,o,O |
| " |
| " NOTE: 'o,O' at the end of the previous line says you wish to be called |
| " whenever a newline is placed in the buffer. This allows the previous line |
| " to be checked for indentation parameters. |
| " |
| " Third, set the data set 'b:indentStmts' to the keywords/expressions that, when |
| " they are on a line _when_ you _press_ the _<Enter>_ key, |
| " you wish to have the next line indented. |
| " |
| "call GenericIndentStmts('begin,if,then,else,elif,case,repeat,until,domain,do') |
| " |
| " Fourth, set the data set 'b:dedentStmts' to the keywords/expressions that, when |
| " they are on a line you are currently typing, you wish to have that line |
| " 'dedented' (having already been indented because of the previous line's |
| " indentation). |
| " |
| "call GenericDedentStmts('end_proc,then,else,elif,end_if,end_case,until,end_repeat,end_domain,end_for,end_while,end') |
| " |
| " Fifth, set the data set 'b:allStmts' to the concatenation of the third and |
| " fourth data sets, used for checking when more than one keyword/expression |
| " is on a line. |
| " |
| "call GenericAllStmts() |
| " |
| " NOTE: GenericIndentStmts uses two variables: 'b:indentStmtOpen' and |
| " 'b:indentStmtClose' which default to '\<' and '\>' respectively. You can |
| " set (let) these to any value you wish before calling GenericIndentStmts with |
| " your list. Similarly, GenericDedentStmts uses 'b:dedentStmtOpen' and |
| " 'b:dedentStmtClose'. |
| " |
| " NOTE: Patterns may be used in the lists passed to Generic[In|De]dentStmts |
| " since each element in the list is copied verbatim. |
| " |
| " Optionally, you can set the DEBUGGING flag within your script to have the |
| " debugging messages output. See below for description. This can also be set |
| " (let) from the command line within your editing buffer. |
| " |
| "let b:DEBUGGING=1 |
| " |
| " See: |
| " :h runtime |
| " :set runtimepath ? |
| " to familiarize yourself with how this works and where you should have this |
| " file and your file(s) installed. |
| " |
| " For help with setting 'indentkeys' see: |
| " :h indentkeys |
| " Also, for some good examples see 'indent/sh.vim' and 'indent/vim.vim' as |
| " well as files for other languages you may be familiar with. |
| " |
| " |
| " Alternatively, if you'd rather specify yourself, you can enter |
| " 'b:indentStmts', 'b:dedentStmts', and 'b:allStmts' 'literally': |
| " |
| "let b:indentStmts='\<begin\>\|\<if\>\|\<then\>\|\<else\>\|\<elif\>\|\<case\>\|\<repeat\>\|\<until\>\|\<domain\>\|\<do\>' |
| "let b:dedentStmts='\<end_proc\>\|\<else\>\|\<elif\>\|\<end_if\>\|\<end_case\>\|\<until\>\|\<end_repeat\>\|\<end_domain\>\|\<end_for\>\|\<end_while\>\|\<end\>' |
| "let b:allStmts=b:indentStmts.'\|'.b:dedentStmts |
| " |
| " This is only useful if you have particularly different parameters for |
| " matching each statement. |
| |
| " RECAP: From indent/MuPAD_source.vim |
| " |
| "if exists("b:did_indent") | finish | endif |
| " |
| "let b:did_indent = 1 |
| " |
| "runtime indent/GenericIndent.vim |
| " |
| "setlocal indentexpr=GenericIndent() |
| "setlocal indentkeys==end_proc,=then,=else,=elif,=end_if,=end_case,=until,=end_repeat,=end_domain,=end_for,=end_while,=end,o,O |
| "call GenericIndentStmts('begin,if,then,else,elif,case,repeat,until,domain,do') |
| "call GenericDedentStmts('end_proc,then,else,elif,end_if,end_case,until,end_repeat,end_domain,end_for,end_while,end') |
| "call GenericAllStmts() |
| " |
| " END RECAP: |
| |
| let s:hit=0 |
| let s:lastVlnum=0 |
| let s:myScriptName=expand("<sfile>:t") |
| |
| if exists("*GenericIndent") |
| finish |
| endif |
| |
| function GenericAllStmts() |
| let b:allStmts=b:indentStmts.'\|'.b:dedentStmts |
| call DebugGenericIndent(expand("<sfile>").": "."b:indentStmts: ".b:indentStmts.", b:dedentStmts: ".b:dedentStmts.", b:allStmts: ".b:allStmts) |
| endfunction |
| |
| function GenericIndentStmts(stmts) |
| let Stmts=a:stmts |
| let Comma=match(Stmts,',') |
| if Comma == -1 || Comma == strlen(Stmts)-1 |
| echoerr "Must supply a comma separated list of at least 2 entries." |
| echoerr "Supplied list: <".Stmts.">" |
| return |
| endif |
| |
| if !exists("b:indentStmtOpen") |
| let b:indentStmtOpen='\<' |
| endif |
| if !exists("b:indentStmtClose") |
| let b:indentStmtClose='\>' |
| endif |
| if !exists("b:indentStmts") |
| let b:indentStmts='' |
| endif |
| if b:indentStmts != '' |
| let b:indentStmts=b:indentStmts.'\|' |
| endif |
| call DebugGenericIndent(expand("<sfile>").": "."b:indentStmtOpen: ".b:indentStmtOpen.", b:indentStmtClose: ".b:indentStmtClose.", b:indentStmts: ".b:indentStmts.", Stmts: ".Stmts) |
| let stmtEntryBegin=0 |
| let stmtEntryEnd=Comma |
| let stmtEntry=strpart(Stmts,stmtEntryBegin,stmtEntryEnd-stmtEntryBegin) |
| let Stmts=strpart(Stmts,Comma+1) |
| let Comma=match(Stmts,',') |
| let b:indentStmts=b:indentStmts.b:indentStmtOpen.stmtEntry.b:indentStmtClose |
| while Comma != -1 |
| let stmtEntryEnd=Comma |
| let stmtEntry=strpart(Stmts,stmtEntryBegin,stmtEntryEnd-stmtEntryBegin) |
| let Stmts=strpart(Stmts,Comma+1) |
| let Comma=match(Stmts,',') |
| let b:indentStmts=b:indentStmts.'\|'.b:indentStmtOpen.stmtEntry.b:indentStmtClose |
| endwhile |
| let stmtEntry=Stmts |
| let b:indentStmts=b:indentStmts.'\|'.b:indentStmtOpen.stmtEntry.b:indentStmtClose |
| endfunction |
| |
| function GenericDedentStmts(stmts) |
| let Stmts=a:stmts |
| let Comma=match(Stmts,',') |
| if Comma == -1 || Comma == strlen(Stmts)-1 |
| echoerr "Must supply a comma separated list of at least 2 entries." |
| echoerr "Supplied list: <".Stmts.">" |
| return |
| endif |
| |
| if !exists("b:dedentStmtOpen") |
| let b:dedentStmtOpen='\<' |
| endif |
| if !exists("b:dedentStmtClose") |
| let b:dedentStmtClose='\>' |
| endif |
| if !exists("b:dedentStmts") |
| let b:dedentStmts='' |
| endif |
| if b:dedentStmts != '' |
| let b:dedentStmts=b:dedentStmts.'\|' |
| endif |
| call DebugGenericIndent(expand("<sfile>").": "."b:dedentStmtOpen: ".b:dedentStmtOpen.", b:dedentStmtClose: ".b:dedentStmtClose.", b:dedentStmts: ".b:dedentStmts.", Stmts: ".Stmts) |
| let stmtEntryBegin=0 |
| let stmtEntryEnd=Comma |
| let stmtEntry=strpart(Stmts,stmtEntryBegin,stmtEntryEnd-stmtEntryBegin) |
| let Stmts=strpart(Stmts,Comma+1) |
| let Comma=match(Stmts,',') |
| let b:dedentStmts=b:dedentStmts.b:dedentStmtOpen.stmtEntry.b:dedentStmtClose |
| while Comma != -1 |
| let stmtEntryEnd=Comma |
| let stmtEntry=strpart(Stmts,stmtEntryBegin,stmtEntryEnd-stmtEntryBegin) |
| let Stmts=strpart(Stmts,Comma+1) |
| let Comma=match(Stmts,',') |
| let b:dedentStmts=b:dedentStmts.'\|'.b:dedentStmtOpen.stmtEntry.b:dedentStmtClose |
| endwhile |
| let stmtEntry=Stmts |
| let b:dedentStmts=b:dedentStmts.'\|'.b:dedentStmtOpen.stmtEntry.b:dedentStmtClose |
| endfunction |
| |
| " Debugging function. Displays messages in the command area which can be |
| " reviewed using ':messages'. To turn it on use ':let b:DEBUGGING=1'. Once |
| " on, turn off by using ':let b:DEBUGGING=0. If you don't want it at all and |
| " feel it's slowing down your editing (you must have an _awfully_ slow |
| " machine!;-> ), you can just comment out the calls to it from 'GenericIndent' |
| " below. No need to remove the function or the calls, tho', as you never can |
| " tell when they might come in handy!;-) |
| function DebugGenericIndent(msg) |
| if exists("b:DEBUGGING") && b:DEBUGGING |
| echomsg '['.s:hit.']'.s:myScriptName."::".a:msg |
| endif |
| endfunction |
| |
| function GenericIndent() |
| " save ignore case option. Have to set noignorecase for the match |
| " functions to do their job the way we want them to! |
| " NOTE: if you add a return to this function be sure you do |
| " if IgnoreCase | set ignorecase | endif |
| " before returning. You can just cut and paste from here. |
| let IgnoreCase=&ignorecase |
| " let b:case_insensitive=1 if you want to ignore case, e.g. DOS batch files |
| if !exists("b:case_insensitive") |
| set noignorecase |
| endif |
| " this is used to let DebugGenericIndent display which invocation of the |
| " function goes with which messages. |
| let s:hit=s:hit+1 |
| let lnum=v:lnum |
| let cline=getline(lnum) |
| let lnum=prevnonblank(lnum) |
| if lnum==0 | if IgnoreCase | set ignorecase | endif | return 0 | endif |
| let pline=getline(lnum) |
| let ndnt=indent(lnum) |
| if !exists("b:allStmts") |
| call GenericAllStmts() |
| endif |
| |
| call DebugGenericIndent(expand("<sfile>").": "."cline=<".cline.">, pline=<".pline.">, lnum=".lnum.", v:lnum=".v:lnum.", ndnt=".ndnt) |
| if lnum==v:lnum |
| " current line, only check dedent |
| " |
| " just dedented this line, don't need to do it again. |
| " another dedentStmts was added or an end%[_*] was completed. |
| if s:lastVlnum==v:lnum |
| if IgnoreCase | set ignorecase | endif |
| return ndnt |
| endif |
| let s:lastVlnum=v:lnum |
| call DebugGenericIndent(expand("<sfile>").": "."Checking dedent") |
| let srcStr=cline |
| let dedentKeyBegin=match(srcStr,b:dedentStmts) |
| if dedentKeyBegin != -1 |
| let dedentKeyEnd=matchend(srcStr,b:dedentStmts) |
| let dedentKeyStr=strpart(srcStr,dedentKeyBegin,dedentKeyEnd-dedentKeyBegin) |
| "only dedent if it's the beginning of the line |
| if match(srcStr,'^\s*\<'.dedentKeyStr.'\>') != -1 |
| call DebugGenericIndent(expand("<sfile>").": "."It's the beginning of the line, dedent") |
| let ndnt=ndnt-&shiftwidth |
| endif |
| endif |
| call DebugGenericIndent(expand("<sfile>").": "."dedent - returning ndnt=".ndnt) |
| else |
| " previous line, only check indent |
| call DebugGenericIndent(expand("<sfile>").": "."Checking indent") |
| let srcStr=pline |
| let indentKeyBegin=match(srcStr,b:indentStmts) |
| if indentKeyBegin != -1 |
| " only indent if it's the last indentStmts in the line |
| let allKeyBegin=match(srcStr,b:allStmts) |
| let allKeyEnd=matchend(srcStr,b:allStmts) |
| let allKeyStr=strpart(srcStr,allKeyBegin,allKeyEnd-allKeyBegin) |
| let srcStr=strpart(srcStr,allKeyEnd) |
| let allKeyBegin=match(srcStr,b:allStmts) |
| if allKeyBegin != -1 |
| " not the end of the line, check what is and only indent if |
| " it's an indentStmts |
| call DebugGenericIndent(expand("<sfile>").": "."Multiple words in line, checking if last is indent") |
| while allKeyBegin != -1 |
| let allKeyEnd=matchend(srcStr,b:allStmts) |
| let allKeyStr=strpart(srcStr,allKeyBegin,allKeyEnd-allKeyBegin) |
| let srcStr=strpart(srcStr,allKeyEnd) |
| let allKeyBegin=match(srcStr,b:allStmts) |
| endwhile |
| if match(b:indentStmts,allKeyStr) != -1 |
| call DebugGenericIndent(expand("<sfile>").": "."Last word in line is indent") |
| let ndnt=ndnt+&shiftwidth |
| endif |
| else |
| " it's the last indentStmts in the line, go ahead and indent |
| let ndnt=ndnt+&shiftwidth |
| endif |
| endif |
| call DebugGenericIndent(expand("<sfile>").": "."indent - returning ndnt=".ndnt) |
| endif |
| if IgnoreCase | set ignorecase | endif |
| return ndnt |
| endfunction |
| |
| |
| " TODO: I'm open! |
| " |
| " BUGS: You tell me! Probably. I just haven't found one yet or haven't been |
| " told about one. |
| " |