[ADD] conf for archlinux, <init>

[arrow.git] / archlinux_conf / home / .vim / plugin / EnhancedCommentify.vim

" EnhancedCommentify.vim
" Maintainer:   Meikel Brandmeyer <Brandels_Mikesh@web.de>
" Version:      2.3
" Last Change:  Wednesday, February 20th, 2008

" License:
" Copyright (c) 2008 Meikel Brandmeyer, Frankfurt am Main
" All rights reserved.
" 
" Redistribution and use in source and binary form are permitted provided
" that the following conditions are met:
" 
" 1. Redistribition of source code must retain the above copyright
"    notice, this list of conditions and the following disclaimer.
" 
" 2. Redistributions in binary form must reproduce the above copyright
"    notice, this list of conditions and the following disclaimer in the
"    documentation and/or other materials provided with the distribution.
" 
" THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS "AS IS" AND
" ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
" ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
" SUCH DAMAGE.

" Description: 
" This is a (well... more or less) simple script to comment lines in a program.
" Currently supported languages are C, C++, PHP, the vim scripting
" language, python, HTML, Perl, LISP, Tex, Shell, CAOS and others.

" Bugfixes:
"   2.3
"   Fixed type 'apacha' -> 'apache' (thanks to Brian Neu)
"   Fixed nested comment escapes strings. (thanks to Samuel Ferencik)
"   Fixed broken keyboard mappings when wcm was set to <Tab>.
"                                       (thanks to xpatriotx)
"   2.2
"   Fixed problem with UseSyntax (thanks to Pieter Naaijkens) 
"   Fixed typo in ParseCommentsOp (commstr -> commStr). 
"   Fixed support for ocaml (thanks to Zhang Le)
"   2.1
"   Fixed problems with alignement when a line contains tabs 
"   Fixed (resp. cleaned up) issues with overrideEL (thanks to Steve Hall) 
"   Fixed problems with javascript detection (thanks to Brian Neu) 
"   Changed Buffer init to BufWinEnter in order to use the modelines. 
"   2.0
"   Fixed invalid expression '\'' -> "'" (thanks to Zak Beck)
"   Setting AltOpen/AltClose to '' (ie. disabling it) would
"   insert '/*' resp. '*/' for character in a line (thanks to Ben Kibbey)
"   1.8
"   Backslashes in comment symbols should not be escaped.
"   typo (commensSymbol -> commentSymbol) (thanks to Steve Butts) 
"   typo (== -> =) 
"   Fixed hardwired '|+'-'+|' pair. 
"   1.7
"   Lines were not correctly decommentified, when there was whitespace
"   at the beginning of the line.    (thanks to Xiangjiang Ma) 
"   Fixed error detecting '*sh' filetypes. 
"   1.3
"   hlsearch was set unconditionally (thanks to Mary Ellen Foster)
"   made function silent             (thanks to Mare Ellen Foster)

" Changelog:
"   2.3
"   Added support for viki/deplate (thanks to Thomas Link)
"   Added support for xslt/xsd/mail (thanks to Stefano Zacchiroli)
"   Added callback-functionality to enable extensions without the
"   need of modification directly in the script.
"   2.2
"   Added possibility to override the modes, in which keybindings are
"   defined.
"   Keybindings may be defined local to every buffer now.
"   If a filetype is unknown, one can turn off the keybindings now. 
"   2.1
"   Removed any cursor movement. The script should now be free of
"   side-effects.
"   The script now uses &commentstring to determine the right
"   comment strings. Fallback is still the ugly if-thingy.
"   Script can now interpret &comments in order to add a middle
"   string in blocks.
"   Added EnhancedCommentifySet for use by other scripts. (Necessary?) 
"   Added MultiPartBlocks for languages with multipart-comments.
"   Added parsing for comments option if using MultiPartBlocks.
"   2.0
"   IMPORTANT: EnhancedCommentify is now licensed under BSD license
"              for distribution with Cream! However this shouldn't
"              change anything... 
"   useBlockIndent does no longer depend on respectIndent. 
"   Added code to cope with 'C' in '&cpo'. (thanks to Luc Hermitte
"   for pointing this out!)
"   Added EnhCommentifyIdentFrontOnly option.
"   All options are now handled on a per buffer basis. So options
"   can be overriden for different buffers. 
"   1.9
"   Filetype is now recognized via regular expressions.
"   All known filetypes are (more or less) supported.
"   Decomments multipart-block comments.
"   Added RespectIndent, AlignRight and synID-guessing.
"   Switched to buffer variables.
"   1.8
"   Added Ada support. (thanks to Preben Randhol) 
"   Added Latte support.
"   Added blocksupport and possibility to specify action (comment or
"   decomment). It's also possible to guess the action line by line or
"   using the first line of a block.
"   Thanks to Xiangjiang Ma and John Orr for the rich feedback on these
"   issues.
"   Decomments /*foo();*/, when PrettyComments is set.
"   Added 'vhdl' and 'verilog'. (thanks to Steve Butts) 
"   1.7
"   Added different options to control behaviour of the plugin. 
"   Changed default Keybindings to proper plugin settings.
"   1.6
"   Now supports 'm4', 'config', 'automake'
"   'vb', 'aspvbs', 'plsql' (thanks to Zak Beck)
"   1.5
"   Now supports 'java', 'xml', 'jproperties'. (thanks to Scott Stirling)
"   1.4
"   Lines containing only whitespace are now considered empty.
"   Added Tcl support.
"   Multipart comments are now escaped with configurable alternative
"   strings. Prevents nesting errors (eg. /**/*/ in C)
"   1.3
"   Doesn't break lines like
"       foo(); /* bar */
"   when doing commentify.

" Install Details:
" Simply drop this file into your $HOME/.vim/plugin directory.

if exists("DidEnhancedCommentify")
    finish
endif
let DidEnhancedCommentify = 1

let s:savedCpo = &cpo
set cpo-=C

" Note: These must be defined here, since they are used during
"       initialisation.
"
" InitBooleanVariable(confVar, scriptVar, defaultVal)
"       confVar         -- name of the configuration variable
"       scriptVar       -- name of the variable to set
"       defaultVal      -- default value
"
" Tests on existence of configuration variable and sets scriptVar
" according to its contents.
"
function s:InitBooleanVariable(confVar, scriptVar, defaultVal)
    let regex = a:defaultVal ? 'no*' : 'ye*s*'

    if exists(a:confVar) && {a:confVar} =~? regex
        let {a:scriptVar} = !a:defaultVal
    else
        let {a:scriptVar} = a:defaultVal
    endif
endfunction

"
" InitStringVariable(confVar, scriptVar, defaultVal)
"       confVar         -- name of the configuration variable
"       scriptVar       -- name of the variable to set
"       defaultVal      -- default value
"
" Tests on existence of configuration variable and sets scriptVar
" to its contents.
"
function s:InitStringVariable(confVar, scriptVar, defaultVal)
    if exists(a:confVar)
        execute "let ". a:scriptVar ." = ". a:confVar
    else
        let {a:scriptVar} = a:defaultVal
    endif
endfunction

"
" InitScriptVariables(nameSpace)
"       nameSpace       -- may be "g" for global or "b" for local
"
" Initialises the script variables.
"
function s:InitScriptVariables(nameSpace)
    let ns = a:nameSpace        " just for abbreviation
    let lns = (ns == "g") ? "s" : "b" " 'local namespace'

    " Comment escape strings...
    call s:InitStringVariable(ns .":EnhCommentifyAltOpen", lns .":ECaltOpen",
                \ s:ECaltOpen)
    call s:InitStringVariable(ns .":EnhCommentifyAltClose", lns .":ECaltClose",
                \ s:ECaltClose)

    call s:InitBooleanVariable(ns .":EnhCommentifyIgnoreWS", lns .":ECignoreWS",
                \ s:ECignoreWS)

    " Adding a space between comment strings and code...
    if exists(ns .":EnhCommentifyPretty")
        if {ns}:EnhCommentifyPretty =~? 'ye*s*'
            let {lns}:ECprettyComments = ' '
            let {lns}:ECprettyUnComments = ' \='
        else
            let {lns}:ECprettyComments = ''
            let {lns}:ECprettyUnComments = ''
        endif
    else
        let {lns}:ECprettyComments = s:ECprettyComments
        let {lns}:ECprettyUnComments = s:ECprettyUnComments
    endif

    " Identification string settings...
    call s:InitStringVariable(ns .":EnhCommentifyIdentString",
                \ lns .":ECidentFront", s:ECidentFront)
    let {lns}:ECidentBack =
                \ (exists(ns .":EnhCommentifyIdentFrontOnly")
                \           && {ns}:EnhCommentifyIdentFrontOnly =~? 'ye*s*')
                \ ? ''
                \ : {lns}:ECidentFront

    " Wether to use syntax items...
    call s:InitBooleanVariable(ns .":EnhCommentifyUseSyntax",
                \ lns .":ECuseSyntax", s:ECuseSyntax)

    " Should the script respect line indentation, when inserting strings?
    call s:InitBooleanVariable(ns .":EnhCommentifyRespectIndent",
                \ lns .":ECrespectIndent", s:ECrespectIndent)

    " Keybindings...
    call s:InitBooleanVariable(ns .":EnhCommentifyUseAltKeys",
                \ lns .":ECuseAltKeys", s:ECuseAltKeys)
    call s:InitBooleanVariable(ns .":EnhCommentifyBindPerBuffer",
                \ lns .":ECbindPerBuffer", s:ECbindPerBuffer)
    call s:InitBooleanVariable(ns .":EnhCommentifyBindInNormal",
                \ lns .":ECbindInNormal", s:ECbindInNormal)
    call s:InitBooleanVariable(ns .":EnhCommentifyBindInInsert",
                \ lns .":ECbindInInsert", s:ECbindInInsert)
    call s:InitBooleanVariable(ns .":EnhCommentifyBindInVisual",
                \ lns .":ECbindInVisual", s:ECbindInVisual)
    call s:InitBooleanVariable(ns .":EnhCommentifyUserBindings",
                \ lns .":ECuserBindings", s:ECuserBindings)
    call s:InitBooleanVariable(ns .":EnhCommentifyTraditionalMode",
                \ lns .":ECtraditionalMode", s:ECtraditionalMode)
    call s:InitBooleanVariable(ns .":EnhCommentifyFirstLineMode",
                \ lns .":ECfirstLineMode", s:ECfirstLineMode)
    call s:InitBooleanVariable(ns .":EnhCommentifyUserMode",
                \ lns .":ECuserMode", s:ECuserMode)
    call s:InitBooleanVariable(ns .":EnhCommentifyBindUnknown",
                \ lns .":ECbindUnknown", s:ECbindUnknown)

    " Block stuff...
    call s:InitBooleanVariable(ns .":EnhCommentifyAlignRight",
                \ lns .":ECalignRight", s:ECalignRight)
    call s:InitBooleanVariable(ns .":EnhCommentifyUseBlockIndent",
                \ lns .":ECuseBlockIndent", s:ECuseBlockIndent)
    call s:InitBooleanVariable(ns .":EnhCommentifyMultiPartBlocks",
                \ lns .":ECuseMPBlock", s:ECuseMPBlock)
    call s:InitBooleanVariable(ns .":EnhCommentifyCommentsOp",
                \ lns .":ECuseCommentsOp", s:ECuseCommentsOp)

    let {lns}:ECsaveWhite = ({lns}:ECrespectIndent
                \ || {lns}:ECignoreWS || {lns}:ECuseBlockIndent)
                \       ? '\(\s*\)'
                \       : ''

    if !{lns}:ECrespectIndent
        let {lns}:ECuseBlockIndent = 0
    endif

    if {lns}:ECrespectIndent
        let {lns}:ECrespectWhite = '\1'
        let {lns}:ECignoreWhite = ''
    elseif {lns}:ECignoreWS
        let {lns}:ECrespectWhite = ''
        let {lns}:ECignoreWhite = '\1'
    else
        let {lns}:ECrespectWhite = ''
        let {lns}:ECignoreWhite = ''
    endif

    " Using comments option, doesn't make sense without useMPBlock
    "if lns == 'b' && b:ECuseCommentsOp
    "       let b:ECuseMPBlock = 1
    "endif
endfunction

"
" EnhancedCommentifySet(option, value, ...)
"       option  -- which option
"       value   -- value which will be asigned to the option
"
" The purpose of this function is mainly to act as an interface to the
" outer world. It hides the internally used variables.
"
function EnhancedCommentifySet(option, value)
    if a:option == 'AltOpen'
        let oldval = b:ECaltOpen
        let b:ECaltOpen = a:value
    elseif a:option == 'AltClose'
        let oldval = b:ECaltClose
        let b:ECaltClose = a:value
    elseif a:option == 'IdentString'
        let oldval = b:ECidentFront
        let b:ECidentFront = a:value
    elseif a:option == 'IdentFrontOnly'
        let oldval = (b:ECidentBack == '') ? 'Yes' : 'No'
        let b:ECidentBack = (a:value =~? 'ye*s*') ? '' : b:ECidentFront
    elseif a:option == 'RespectIndent'
        let oldval = b:ECrespectIndent
        let b:ECrespectIndent = (a:value =~? 'ye*s*') ? 1 : 0
    elseif a:option == 'IgnoreWS'
        let oldval = b:ECignoreWS
        let b:ECignoreWS = (a:value =~? 'ye*s*') ? 1 : 0
    elseif a:option == 'Pretty'
        let oldval = (b:ECprettyComments == ' ') ? 'Yes' : 'No'
        if a:value =~? 'ye*s*'
            let b:ECprettyComments = ' '
            let b:ECprettyUnComments = ' \='
        else
            let b:ECprettyComments = ''
            let b:ECprettyUnComments = ''
        endif
    elseif a:option == 'MultiPartBlocks'
        let oldval = b:ECuseMPBlock
        let b:ECuseMPBlock = (a:value =~? 'ye*s*') ? 1 : 0
    elseif a:option == 'CommentsOp'
        let oldval = b:ECuseCommentsOp
        let b:ECuseCommentsOp = (a:value =~? 'ye*s*') ? 1 : 0
    elseif a:option == 'UseBlockIndent'
        let oldval = b:ECuseBlockIndent
        let b:ECuseBlockIndent = (a:value =~? 'ye*s*') ? 1 : 0
    elseif a:option == 'AlignRight'
        let oldval = b:ECalignRight
        let b:ECalignRight = (a:value =~? 'ye*s*') ? 1 : 0
    elseif a:option == 'UseSyntax'
        let oldval = b:ECuseSyntax
        let b:ECuseSyntax = (a:value =~? 'ye*s*') ? 1 : 0
    else
        if (has("dialog_gui") && has("gui_running"))
            call confirm("EnhancedCommentifySet: Unknwon option '"
                        \ . option . "'")
        else
            echohl ErrorMsg
            echo "EnhancedCommentifySet: Unknown option '". option ."'"
            echohl None
        endif
    endif

    if oldval == 1
        let oldval = 'Yes'
    elseif oldval == 0
        let oldval = 'No'
    endif

    return oldval
endfunction

" Initial settings.
"
" Setting the default options resp. taking user preferences.
if !exists("g:EnhCommentifyUserMode")
            \ && !exists("g:EnhCommentifyFirstLineMode")
            \ && !exists("g:EnhCommentifyTraditionalMode")
            \ && !exists("g:EnhCommentifyUserBindings")
    let g:EnhCommentifyTraditionalMode = 'Yes'
endif

" These will be the default settings for the script:
let s:ECaltOpen = "|+"
let s:ECaltClose = "+|"
let s:ECignoreWS = 1
let s:ECprettyComments = ''
let s:ECprettyUnComments = ''
let s:ECidentFront = ''
let s:ECuseSyntax = 0
let s:ECrespectIndent = 0
let s:ECalignRight = 0
let s:ECuseBlockIndent = 0
let s:ECuseMPBlock = 0
let s:ECuseCommentsOp = 0
let s:ECuseAltKeys = 0
let s:ECbindPerBuffer = 0
let s:ECbindInNormal = 1
let s:ECbindInInsert = 1
let s:ECbindInVisual = 1
let s:ECuserBindings = 0
let s:ECtraditionalMode = 0
let s:ECfirstLineMode = 0
let s:ECuserMode = 1
let s:ECbindUnknown = 1

" Now initialise the global defaults with the preferences set
" by the user in his .vimrc. Settings local to a buffer will be
" done later on, when the script is first called in a buffer.
"
call s:InitScriptVariables("g")

" Globally used variables with some initialisation.
" FIXME: explain what they are good for
" 
let s:Action = 'guess'
let s:firstOfBlock = 1
let s:blockAction = 'comment'
let s:blockIndentRegex = ''
let s:blockIndent = 0
let s:inBlock = 0
let s:tabConvert = ''
let s:overrideEmptyLines = 0
let s:emptyLines = 'no'
let s:maxLen = 0

function EnhancedCommentifyInitBuffer()
    if !exists("b:ECdidBufferInit")
        call s:InitScriptVariables("b")

        if !exists("b:EnhCommentifyFallbackTest")
            let b:EnhCommentifyFallbackTest = 0
        endif

        call s:GetFileTypeSettings(&ft)
        call s:CheckPossibleEmbedding(&ft)

        "
        " If the filetype is not supported and the user wants us to, we do not
        " add keybindings.
        "
        if s:ECbindPerBuffer
            if b:ECcommentOpen != "" || b:ECbindUnknown
                call s:SetKeybindings("l")
            endif
        endif

        let b:ECdidBufferInit = 1
        let b:ECsyntax = &ft
    endif
endfunction

autocmd BufWinEnter,BufNewFile  *       call EnhancedCommentifyInitBuffer()

"
" EnhancedCommentify(emptyLines, action, ...)
"       overrideEL      -- commentify empty lines
"                          may be 'yes', 'no' or '' for guessing
"       action          -- action which should be executed:
"                           * guess:
"                             toggle commetification (old behaviour)
"                           * comment:
"                             comment lines
"                           * decomment:
"                             decomment lines
"                           * first:
"                             use first line of block to determine action 
"       a:1, a:2        -- first and last line of block, which should be
"                          processed. 
"
" Commentifies the current line.
"
function EnhancedCommentify(overrideEL, action, ...)
    if a:overrideEL != ''
        let s:overrideEmptyLines = 1
    endif

    " Now do the buffer initialisation. Every buffer will get
    " it's pendant to a global variable (eg. s:ECalignRight -> b:ECalignRight).
    " The local variable is actually used, whereas the global variable
    " holds the defaults from the user's .vimrc. In this way the settings
    " can be overriden for single buffers.
    " 
    " NOTE: Buffer init is done by autocommands now.
    "

    let b:ECemptyLines = a:overrideEL

    " The language is not supported.
    if b:ECcommentOpen == ''
        if (has("dialog_gui") && has("gui_running"))
            call confirm("This filetype is currently _not_ supported!\n"
                        \ ."Please consider contacting the author in order"
                        \ ." to add this filetype.", "", 1, "Error")
        else
            echohl ErrorMsg
            echo "This filetype is currently _not_ supported!"
            echo "Please consider contacting the author in order to add"
            echo "this filetype in future releases!"
            echohl None
        endif
        return
    endif

    let lnum = line(".")

    " Now some initialisations...
    let s:Action = a:action

    " FIXME: Is there really _no_ function to simplify this???
    " (Maybe something like 'let foo = 8x" "'?) 
    if s:tabConvert == '' && strlen(s:tabConvert) != &tabstop
        let s:tabConvert = ''
        let i = 0
        while i < &tabstop
            let s:tabConvert = s:tabConvert .' '
            let i = i + 1
        endwhile
    endif

    if a:0 == 2
        let s:startBlock = a:1
        let s:i = a:1
        let s:endBlock = a:2

        let s:inBlock = 1
    else
        let s:startBlock = lnum
        let s:i = lnum
        let s:endBlock = lnum

        let s:inBlock = 0
    endif

    if b:ECuseSyntax && b:ECpossibleEmbedding
        let column = indent(s:startBlock) + 1
        if !&expandtab
                let rem = column % &tabstop
                let column = ((column - rem) / &tabstop) + rem
        endif
        call s:CheckSyntax(s:startBlock, column)
    endif

    " Get the indent of the less indented line of the block.
    if s:inBlock && (b:ECuseBlockIndent || b:ECalignRight)
        call s:DoBlockComputations(s:startBlock, s:endBlock)
    endif

    while s:i <= s:endBlock
        let lineString = getline(s:i)
        let lineString = s:TabsToSpaces(lineString) 

        " If we should comment "empty" lines, we have to add
        " the correct indent, if we use blockIndent.
        if b:ECemptyLines =~? 'ye*s*'
                        \ && b:ECuseBlockIndent
                        \ && lineString =~ "^\s*$"
            let i = 0
            while i < s:blockIndent
                let lineString = " " . lineString
                let i = i + 1
            endwhile
        endif

        " Don't comment empty lines.
        if lineString !~ "^\s*$"
                    \ || b:ECemptyLines =~? 'ye*s*'
            if b:ECcommentClose != ''
                let lineString = s:CommentifyMultiPart(lineString,
                            \ b:ECcommentOpen,
                            \ b:ECcommentClose,
                            \ b:ECcommentMiddle)
            else
                let lineString = s:CommentifySinglePart(lineString,
                            \ b:ECcommentOpen)
            endif
        endif

        " Revert the above: If the line is "empty" and we
        " used blockIndent, we remove the spaces.
        " FIXME: Why does "^\s*$" not work? 
        if b:ECemptyLines =~? 'ye*s*'
                    \ && b:ECuseBlockIndent
                    \ && lineString =~ "^" . s:blockIndentRegex ."\s*$"
            let lineString =
                        \ substitute(lineString, s:blockIndentRegex,
                        \     '', '')
        endif

        let lineString = s:SpacesToTabs(lineString)
        call setline(s:i, lineString)

        let s:i = s:i + 1
        let s:firstOfBlock = 0
    endwhile

    let s:firstOfBlock = 1
endfunction

"
" DoBlockComputations(start, end)
"           start       -- number of first line
"           end         -- number of last line
"
" This function does some computations which are necessary for useBlockIndent
" and alignRight. ie. find smallest indent and longest line.
"
function s:DoBlockComputations(start, end)
    let i = a:start
    let len = 0
    let amount = 100000     " this should be enough ...

    while i <= a:end
        if b:ECuseBlockIndent && getline(i) !~ '^\s*$'
            let cur = indent(i)
            if cur < amount
                let amount = cur
            endif
        endif

        if b:ECalignRight
            let cur = s:GetLineLen(s:TabsToSpaces(getline(i)),
                        \ s:GetLineLen(b:ECcommentOpen, 0)
                        \ + strlen(b:ECprettyComments))
            if b:ECuseMPBlock
                let cur = cur + s:GetLineLen(b:ECcommentOpen, 0)
                            \ + strlen(b:ECprettyComments)
            endif

            if len < cur
                let len = cur
            endif
        endif

        let i = i + 1
    endwhile

    if b:ECuseBlockIndent
        if amount > 0
            let regex = '\( \{'. amount .'}\)'
        else
            let regex = ''
        endif
        let s:blockIndentRegex = regex
        let s:blockIndent = amount
    endif

    if b:ECalignRight
        let s:maxLen = len
    endif
endfunction

"
" CheckSyntax(line, column)
"       line        -- line of line
"       column      -- column of line
" Check what syntax is active during call of main function. First hit
" wins. If the filetype changes during the block, we ignore that.
" Adjust the filetype if necessary.
"
function s:CheckSyntax(line, column)
    let ft = ""
    let synFiletype = synIDattr(synID(a:line, a:column, 1), "name")

    " FIXME: This feature currently relies on a certain format
    " of the names of syntax items: the filetype must be prepended
    " in lowwer case letters, followed by at least one upper case
    " letter.
    if match(synFiletype, '\l\+\u') == 0
        let ft = substitute(synFiletype, '^\(\l\+\)\u.*$', '\1', "")
    endif

    if ft == ""
        execute "let specialCase = ". b:EnhCommentifyFallbackTest

        if specialCase
            let ft = b:EnhCommentifyFallbackValue
        else
            " Fallback: If nothing holds, use normal filetype!
            let ft = &ft
        endif
    endif

    " Nothing changed!
    if ft == b:ECsyntax
        return
    endif

    let b:ECsyntax = ft
    call s:GetFileTypeSettings(ft)
endfunction

"
" GetFileTypeSettings(ft)
"       ft          -- filetype
"
" This functions sets some buffer-variables, which control the comment
" strings and 'empty lines'-handling.
"
function s:GetFileTypeSettings(ft)
    let fileType = a:ft

    " If we find nothing appropriate this is the default.
    let b:ECcommentOpen = ''
    let b:ECcommentClose = ''

    if exists("g:EnhCommentifyCallbackExists")
        call EnhCommentifyCallback(fileType)

        " Check whether the callback did yield a result.
        " If so we use it. The user nows, what he's doing.
        if b:ECcommentOpen != ''
            return
        endif
    endif

    " I learned about the commentstring option. Let's use it.
    " For now we ignore it, if it is "/*%s*/". This is the
    " default. We cannot check wether this is default or C or
    " something other like CSS, etc. We have to wait, until the
    " filetypes adopt this option.
    if &commentstring != "/*%s*/" && !b:ECuseSyntax
        let b:ECcommentOpen =
                    \ substitute(&commentstring, '%s.*', "", "")
        let b:ECcommentClose =
                    \ substitute(&commentstring, '.*%s', "", "")
    " Multipart comments:
    elseif fileType =~ '^\(c\|b\|css\|csc\|cupl\|indent\|jam\|lex\|lifelines\|'.
                \ 'lite\|nqc\|phtml\|progress\|rexx\|rpl\|sas\|sdl\|sl\|'.
                \ 'strace\|xpm\|yacc\)$'
        let b:ECcommentOpen = '/*'
        let b:ECcommentClose = '*/'
    elseif fileType =~ '^\(html\|xhtml\|xml\|xslt\|xsd\|dtd\|sgmllnx\)$'
        let b:ECcommentOpen = '<!--'
        let b:ECcommentClose = '-->'
    elseif fileType =~ '^\(sgml\|smil\)$'
        let b:ECcommentOpen = '<!'
        let b:ECcommentClose = '>'
    elseif fileType == 'atlas'
        let b:ECcommentOpen = 'C'
        let b:ECcommentClose = '$'
    elseif fileType =~ '^\(catalog\|sgmldecl\)$'
        let b:ECcommentOpen = '--'
        let b:ECcommentClose = '--'
    elseif fileType == 'dtml'
        let b:ECcommentOpen = '<dtml-comment>'
        let b:ECcommentClose = '</dtml-comment>'
    elseif fileType == 'htmlos'
        let b:ECcommentOpen = '#'
        let b:ECcommentClose = '/#'
    elseif fileType =~ '^\(jgraph\|lotos\|mma\|modula2\|modula3\|pascal\|'.
                \ 'ocaml\|sml\)$'
        let b:ECcommentOpen = '(*'
        let b:ECcommentClose = '*)'
    elseif fileType == 'jsp'
        let b:ECcommentOpen = '<%--'
        let b:ECcommentClose = '--%>'
    elseif fileType == 'model'
        let b:ECcommentOpen = '$'
        let b:ECcommentClose = '$'
    elseif fileType == 'st'
        let b:ECcommentOpen = '"'
        let b:ECcommentClose = '"'
    elseif fileType =~ '^\(tssgm\|tssop\)$'
        let b:ECcommentOpen = 'comment = "'
        let b:ECcommentClose = '"'
    " Singlepart comments:
    elseif fileType =~ '^\(ox\|cpp\|php\|java\|verilog\|acedb\|ch\|clean\|'.
                \ 'clipper\|cs\|dot\|dylan\|hercules\|idl\|ishd\|javascript\|'.
                \ 'kscript\|mel\|named\|openroad\|pccts\|pfmain\|pike\|'.
                \ 'pilrc\|plm\|pov\|rc\|scilab\|specman\|tads\|tsalt\|uc\|'.
                \ 'xkb\)$'
        let b:ECcommentOpen = '//'
        let b:ECcommentClose = ''
    elseif fileType =~ '^\(vim\|abel\)$'
        let b:ECcommentOpen = '"'
        let b:ECcommentClose = ''
    elseif fileType =~ '^\(lisp\|scheme\|scsh\|amiga\|asm\|asm68k\|bindzone\|'.
                \ 'def\|dns\|dosini\|dracula\|dsl\|idlang\|iss\|jess\|kix\|'.
                \ 'masm\|monk\|nasm\|ncf\|omnimark\|pic\|povini\|rebol\|'.
                \ 'registry\|samba\|skill\|smith\|tags\|tasm\|tf\|winbatch\|'.
                \ 'wvdial\|z8a\)$'
        let b:ECcommentOpen = ';'
        let b:ECcommentClose = ''
    elseif fileType =~ '^\(python\|perl\|[^w]*sh$\|tcl\|jproperties\|make\|'.
                \ 'robots\|apache\|apachestyle\|awk\|bc\|cfg\|cl\|conf\|'.
                \ 'crontab\|diff\|ecd\|elmfilt\|eterm\|expect\|exports\|'.
                \ 'fgl\|fvwm\|gdb\|gnuplot\|gtkrc\|hb\|hog\|ia64\|icon\|'.
                \ 'inittab\|lftp\|lilo\|lout\|lss\|lynx\|maple\|mush\|'.
                \ 'muttrc\|nsis\|ora\|pcap\|pine\|po\|procmail\|'.
                \ 'psf\|ptcap\|r\|radiance\|ratpoison\|readline\remind\|'.
                \ 'ruby\|screen\|sed\|sm\|snnsnet\|snnspat\|snnsres\|spec\|'.
                \ 'squid\|terminfo\|tidy\|tli\|tsscl\|vgrindefs\|vrml\|'.
                \ 'wget\|wml\|xf86conf\|xmath\)$'
        let b:ECcommentOpen = '#'
        let b:ECcommentClose = ''
    elseif fileType == 'webmacro'
        let b:ECcommentOpen = '##'
        let b:ECcommentClose = ''
    elseif fileType == 'ppwiz'
        let b:ECcommentOpen = ';;'
        let b:ECcommentClose = ''
    elseif fileType == 'latte'
        let b:ECcommentOpen = '\\;'
        let b:ECcommentClose = ''
    elseif fileType =~ '^\(tex\|abc\|erlang\|ist\|lprolog\|matlab\|mf\|'.
                \ 'postscr\|ppd\|prolog\|simula\|slang\|slrnrc\|slrnsc\|'.
                \ 'texmf\|viki\|virata\)$'
        let b:ECcommentOpen = '%'
        let b:ECcommentClose = ''
    elseif fileType =~ '^\(caos\|cterm\|form\|foxpro\|sicad\|snobol4\)$'
        let b:ECcommentOpen = '*'
        let b:ECcommentClose = ''
    elseif fileType =~ '^\(m4\|config\|automake\)$'
        let b:ECcommentOpen = 'dnl '
        let b:ECcommentClose = ''
    elseif fileType =~ '^\(vb\|aspvbs\|ave\|basic\|elf\|lscript\)$'
        let b:ECcommentOpen = "'"
        let b:ECcommentClose = ''
    elseif fileType =~ '^\(plsql\|vhdl\|ahdl\|ada\|asn\|csp\|eiffel\|gdmo\|'.
                \ 'haskell\|lace\|lua\|mib\|sather\|sql\|sqlforms\|sqlj\|'.
                \ 'stp\)$'
        let b:ECcommentOpen = '--'
        let b:ECcommentClose = ''
    elseif fileType == 'abaqus'
        let b:ECcommentOpen = '**'
        let b:ECcommentClose = ''
    elseif fileType =~ '^\(aml\|natural\|vsejcl\)$'
        let b:ECcommentOpen = '/*'
        let b:ECcommentClose = ''
    elseif fileType == 'ampl'
        let b:ECcommentOpen = '\\#'
        let b:ECcommentClose = ''
    elseif fileType == 'bdf'
        let b:ECcommentOpen = 'COMMENT '
        let b:ECcommentClose = ''
    elseif fileType == 'btm'
        let b:ECcommentOpen = '::'
        let b:ECcommentClose = ''
    elseif fileType == 'dcl'
        let b:ECcommentOpen = '$!'
        let b:ECcommentClose = ''
    elseif fileType == 'dosbatch'
        let b:ECcommentOpen = 'rem '
        let b:ECcommentClose = ''
    elseif fileType == 'focexec'
        let b:ECcommentOpen = '-*'
        let b:ECcommentClose = ''
    elseif fileType == 'forth'
        let b:ECcommentOpen = '\\ '
        let b:ECcommentClose = ''
    elseif fileType =~ '^\(fortran\|inform\|sqr\|uil\|xdefaults\|'.
                \ 'xmodmap\|xpm2\)$'
        let b:ECcommentOpen = '!'
        let b:ECcommentClose = ''
    elseif fileType == 'gp'
        let b:ECcommentOpen = '\\\\'
        let b:ECcommentClose = ''
    elseif fileType =~ '^\(master\|nastran\|sinda\|spice\|tak\|trasys\)$'
        let b:ECcommentOpen = '$'
        let b:ECcommentClose = ''
    elseif fileType == 'nroff' || fileType == 'groff'
        let b:ECcommentOpen = ".\\\\\""
        let b:ECcommentClose = ''
    elseif fileType == 'opl'
        let b:ECcommentOpen = 'REM '
        let b:ECcommentClose = ''
    elseif fileType == 'texinfo'
        let b:ECcommentOpen = '@c '
        let b:ECcommentClose = ''
    elseif fileType == 'mail'
        let b:ECcommentOpen = '>'
        let b:ECcommentClose = ''
    endif

    if b:ECuseCommentsOp
        let b:ECcommentMiddle =
                    \ s:ParseCommentsOp(b:ECcommentOpen, b:ECcommentClose)
        if b:ECcommentMiddle == ''
            let b:ECuseCommentsOp = 0
        endif
    else
        let b:ECcommentMiddle = ''
    endif

    if !s:overrideEmptyLines
        call s:CommentEmptyLines(fileType)
    endif
endfunction

"
" ParseCommentsOp(commentOpen, commentClose)
"       commentOpen -- comment-open string
"       commentClose-- comment-close string
"
" Try to extract the middle comment string from &comments. First hit wins.
" If nothing is found '' is returned.
"
function s:ParseCommentsOp(commentOpen, commentClose)
    let commStr = &comments
    let offset = 0
    let commentMiddle = ''

    while commStr != ''
        "
        " First decompose &omments into consecutive s-, m- and e-parts.
        "
        let s = stridx(commStr, 's')
        if s == -1
            return ''
        endif

        let commStr = strpart(commStr, s)
        let comma = stridx(commStr, ',')
        if comma == -1
            return ''
        endif
        let sPart = strpart(commStr, 0, comma)

        let commStr = strpart(commStr, comma)
        let m = stridx(commStr, 'm')
        if m == -1
            return ''
        endif

        let commStr = strpart(commStr, m)
        let comma = stridx(commStr, ',')
        if comma == -1
            return ''
        endif
        let mPart = strpart(commStr, 0, comma)

        let commStr = strpart(commStr, comma)
        let e = stridx(commStr, 'e')
        if e == -1
            return ''
        endif

        let commStr = strpart(commStr, e)
        let comma = stridx(commStr, ',')
        if comma == -1
            let comma = strlen(commStr)
        endif
        let ePart = strpart(commStr, 0, comma)

        let commStr = strpart(commStr, comma)

        "
        " Now check wether this is what we want:
        " Are the comment string the same?
        "
        let sColon = stridx(sPart, ':')
        let eColon = stridx(ePart, ':')
        if sColon == -1 || eColon == -1
            return ''
        endif
        if strpart(sPart, sColon + 1) != a:commentOpen
                    \ || strpart(ePart, eColon + 1) != a:commentClose
            continue
        endif

        let mColon = stridx(mPart, ':')
        if mColon == -1
            return ''
        endif
        let commentMiddle = strpart(mPart, mColon + 1)

        "
        " Check for any alignement.
        "
        let i = 1
        while sPart[i] != ':'
            if sPart[i] == 'r'
                let offset = strlen(a:commentOpen) - strlen(commentMiddle)
                break
            elseif sPart[i] == 'l'
                let offset = 0
                break
            elseif s:isDigit(sPart[i])
                let j = 1
                while s:isDigit(sPart[i + j])
                    let j = j + 1
                endwhile
                let offset = 1 * strpart(sPart, i, j)
                break
            endif
            let i = i + 1
        endwhile

        if offset == 0
            let i = 1
            while ePart[i] != ':'
                if ePart[i] == 'r'
                    let offset = strlen(a:commentClose) - strlen(commentMiddle)
                    break
                elseif ePart[i] == 'l'
                    let offset = 0
                    break
                elseif s:isDigit(ePart[i])
                    let j = 1
                    while s:isDigit(ePart[i + j])
                        let j = j + 1
                    endwhile
                    let offset = 1 * strpart(ePart, i, j)
                    break
                endif

                let i = i + 1
            endwhile
        endif

        while offset > 0
            let commentMiddle = " " . commentMiddle
            let offset = offset - 1
        endwhile

        break
    endwhile

    return commentMiddle
endfunction

"
" isDigit(char)
"
" Nomen est Omen.
"
function s:isDigit(char)
    let r = 0

    let charVal = char2nr(a:char)

    if charVal >= 48 && charVal <= 57
        let r = 1
    endif

    return r
endfunction

"
" CommentEmptyLines(ft)
"       ft          -- filetype of current buffer
"
" Decides, if empty lines should be commentified or not. Add the filetype,
" you want to change, to the apropriate if-clause.
"
function s:CommentEmptyLines(ft)
    " FIXME: Quick hack (tm)!
    if 0
        " Add special filetypes here.
    elseif b:ECcommentClose == ''
        let b:ECemptyLines = 'yes'
    else
        let b:ECemptyLines = 'no'
    endif
endfunction

"
" CheckPossibleEmbedding(ft)
"       ft      -- the filetype of current buffer
"
" Check wether it makes sense to allow checking for the synIDs.
" Eg. C will never have embedded code...
"
function s:CheckPossibleEmbedding(ft)
    if a:ft =~ '^\(php\|vim\|latte\|html\)$'
        let b:ECpossibleEmbedding = 1
    else
        " Since getting the synID is slow, we set the default to 'no'!
        " There are also some 'broken' languages like the filetype for
        " autoconf's configure.in's ('config'). 
        let b:ECpossibleEmbedding = 0
    endif
endfunction

"
" CommentifyMultiPart(lineString, commentStart, commentEnd, action)
"       lineString      -- line to commentify
"       commentStart    -- comment-start string, eg '/*'
"       commentEnd      -- comment-end string, eg. '*/'
"       commentMiddle   -- comment-middle string, eg. ' *'      
"
" This function commentifies code of languages, which have multipart
" comment strings, eg. '/*' - '*/' of C.
"
function s:CommentifyMultiPart(lineString, commentStart,
            \ commentEnd, commentMiddle)
    if s:Action == 'guess' || s:Action == 'first' || b:ECuseMPBlock
        let todo = s:DecideWhatToDo(a:lineString, a:commentStart, a:commentEnd)
    else
        let todo = s:Action
    endif

    if todo == 'decomment'
        return s:UnCommentify(a:lineString, a:commentStart,
                    \ a:commentEnd, a:commentMiddle)
    else
        return s:Commentify(a:lineString, a:commentStart,
                    \ a:commentEnd, a:commentMiddle)
    endif
endfunction

"
" CommentifySinglePart(lineString, commentSymbol)
"       lineString      -- line to commentify
"       commentSymbol   -- comment string, eg '#'
"
" This function is used for all languages, whose comment strings
" consist only of one string at the beginning of a line.
"
function s:CommentifySinglePart(lineString, commentSymbol)
    if s:Action == 'guess' || s:Action == 'first'
        let todo = s:DecideWhatToDo(a:lineString, a:commentSymbol)
    else
        let todo = s:Action
    endif

    if todo == 'decomment'
        return s:UnCommentify(a:lineString, a:commentSymbol)
    else
        return s:Commentify(a:lineString, a:commentSymbol)
    endif
endfunction

"
" Escape(lineString, commentStart, commentEnd)
"
" Escape already present symbols.
"
function s:Escape(lineString, commentStart, commentEnd)
    let line = a:lineString

    if b:ECaltOpen != ''
        let line = substitute(line, s:EscapeString(a:commentStart),
                    \ b:ECaltOpen, "g")
    endif
    if b:ECaltClose != ''
        let line = substitute(line, s:EscapeString(a:commentEnd),
                    \ b:ECaltClose, "g")
    endif

    return line
endfunction

"
" UnEscape(lineString, commentStart, commentEnd)
"
" Unescape already present escape symbols.
"
function s:UnEscape(lineString, commentStart, commentEnd)
    let line = a:lineString

    " We translate only the first and the last occurrence
    " of this resp. escape string. Commenting a line several
    " times and decommenting it again breaks things.
    if b:ECaltOpen != ''
        let line = substitute(line, s:EscapeString(b:ECaltOpen),
                    \ a:commentStart, "")
    endif
    if b:ECaltClose != ''
        let esAltClose = s:EscapeString(b:ECaltClose)
        let line = substitute(line, esAltClose
                    \ . "\\(.*" . esAltClose . "\\)\\@!",
                    \ a:commentEnd, "")
    endif

    return line
endfunction

"
" Commentify(lineString, commentSymbol, [commentEnd])
"       lineString      -- the line in work
"       commentSymbol   -- string to insert at the beginning of the line
"       commentEnd      -- string to insert at the end of the line
"                          may be omitted
"
" This function inserts the start- (and if given the end-) string of the
" comment in the current line.
"
function s:Commentify(lineString, commentSymbol, ...)
    let line = a:lineString
    let j = 0

    " If a end string is present, insert it too.
    if a:0 > 0
        " First we have to escape any comment already contained in the line,
        " since (at least for C) comments are not allowed to nest.
        let line = s:Escape(line, a:commentSymbol, a:1)

        if b:ECuseCommentsOp && b:ECuseMPBlock
                    \ && a:0 > 1
                    \ && s:i > s:startBlock
            let line = substitute(line, s:LookFor('commentmiddle'),
                        \ s:SubstituteWith('commentmiddle', a:2), "")
        endif

        if !b:ECuseMPBlock || (b:ECuseMPBlock && s:i == s:endBlock)
            " Align the closing part to the right.
            if b:ECalignRight && s:inBlock
                let len = s:GetLineLen(line, strlen(a:commentSymbol)
                            \ + strlen(b:ECprettyComments))
                while j < s:maxLen - len
                    let line = line .' '
                    let j = j + 1
                endwhile
            endif

            let line = substitute(line, s:LookFor('commentend'),
                        \ s:SubstituteWith('commentend', a:1), "")
        endif
    endif

    " insert the comment symbol
    if !b:ECuseMPBlock || a:0 == 0 || (b:ECuseMPBlock && s:i == s:startBlock) 
        let line = substitute(line, s:LookFor('commentstart'),
                    \ s:SubstituteWith('commentstart', a:commentSymbol), "")
    endif

    return line
endfunction

"
" UnCommentify(lineString, commentSymbol, [commentEnd])
"       lineString      -- the line in work
"       commentSymbol   -- string to remove at the beginning of the line
"       commentEnd      -- string to remove at the end of the line
"                          may be omitted
"
" This function removes the start- (and if given the end-) string of the
" comment in the current line.
"
function s:UnCommentify(lineString, commentSymbol, ...)
    let line = a:lineString

    " remove the first comment symbol found on a line
    if a:0 == 0 || !b:ECuseMPBlock || (b:ECuseMPBlock && s:i == s:startBlock) 
        let line = substitute(line, s:LookFor('decommentstart',
                    \   a:commentSymbol),
                    \ s:SubstituteWith('decommentstart'), "")
    endif

    " If a end string is present, we have to remove it, too.
    if a:0 > 0
        " First, we remove the trailing comment symbol.
        if !b:ECuseMPBlock || (b:ECuseMPBlock && s:i == s:endBlock) 
            let line = substitute(line, s:LookFor('decommentend', a:1),
                        \ s:SubstituteWith('decommentend'), "")

            " Remove any trailing whitespace, if we used alignRight.
            if b:ECalignRight
                let line = substitute(line, ' *$', '', "")
            endif
        endif

        " Maybe we added a middle string. Remove it here.
        if b:ECuseCommentsOp && b:ECuseMPBlock
                    \ && a:0 > 1
                    \ && s:i > s:startBlock
            let line = substitute(line, s:LookFor('decommentmiddle', a:2),
                        \ s:SubstituteWith('decommentmiddle'), "")
        endif

        " Remove escaped inner comments.
        let line = s:UnEscape(line, a:commentSymbol, a:1)
    endif

    return line
endfunction

"
" GetLineLen(line, offset)
"       line        -- line of which length should be computed
"       offset      -- maybe a shift of the line to the right
"
" Expands '\t' to it's tabstop value.
"
function s:GetLineLen(line, offset)
    let len = a:offset
    let i = 0

    while a:line[i] != ""
        if a:line[i] == "\t"
            let len = (((len / &tabstop) + 1) * &tabstop)
        else
            let len = len + 1
        endif
        let i = i + 1
    endwhile

    return len
endfunction

"
" EscapeString(string)
"       string      -- string to process
"
" Escapes characters in 'string', which have some function in
" regular expressions, with a '\'.
"
" Returns the escaped string.
"
function s:EscapeString(string)
    return escape(a:string, "*{}[]$^-")
endfunction

"
" LookFor(what, ...)
"       what        -- what type of regular expression
"                       * checkstart:
"                       * checkend:
"                         check for comment at start/end of line
"                       * commentstart:
"                       * commentend:
"                         insert comment strings
"                       * decommentstart:
"                       * decommentend:
"                         remove comment strings
"       a:1         -- comment string
"
function s:LookFor(what, ...)
    if b:ECuseBlockIndent && s:inBlock
        let handleWhitespace = s:blockIndentRegex
    else
        let handleWhitespace = b:ECsaveWhite
    endif

    if a:what == 'checkstart'
        let regex = '^'. b:ECsaveWhite . s:EscapeString(a:1)
                    \ . s:EscapeString(b:ECidentFront)
    elseif a:what == 'checkend'
        let regex = s:EscapeString(b:ECidentBack)
                    \ . s:EscapeString(a:1) . b:ECsaveWhite . '$'
    elseif a:what == 'commentstart'
        let regex = '^'. handleWhitespace
    elseif a:what == 'commentmiddle'
        let regex = '^'. handleWhitespace
    elseif a:what == 'commentend'
        let regex = '$'
    elseif a:what == 'decommentstart'
        let regex = '^'. b:ECsaveWhite . s:EscapeString(a:1)
                    \ . s:EscapeString(b:ECidentFront) . b:ECprettyUnComments
    elseif a:what == 'decommentmiddle'
        let regex = '^'. b:ECsaveWhite . s:EscapeString(a:1)
                    \ . s:EscapeString(b:ECidentFront) . b:ECprettyUnComments
    elseif a:what == 'decommentend'
        let regex = b:ECprettyUnComments . s:EscapeString(b:ECidentBack)
                    \ . s:EscapeString(a:1) . b:ECsaveWhite .'$'
    endif

    return regex
endfunction

"
" SubstituteWith(what, ...)
"       what        -- what type of regular expression
"                       * commentstart:
"                       * commentend:
"                         insert comment strings
"                       * decommentstart:
"                       * decommentend:
"                         remove comment strings
"       a:1         -- comment string
"
function s:SubstituteWith(what, ...)
    if a:what == 'commentstart'
                \ || a:what == 'commentmiddle'
                \ || a:what == 'commentend'
        let commentSymbol = a:1
    else
        let commentSymbol = ''
    endif

    if b:ECuseBlockIndent && s:inBlock
        let handleWhitespace = '\1' . commentSymbol
    else
        let handleWhitespace = b:ECrespectWhite . commentSymbol
                    \ . b:ECignoreWhite
    endif

    if a:what == 'commentstart'
        let regex = handleWhitespace . b:ECidentFront
                    \ . b:ECprettyComments
    elseif a:what == 'commentmiddle'
        let regex = handleWhitespace . b:ECidentFront
                    \ . b:ECprettyComments
    elseif a:what == 'commentend'
        let regex = b:ECprettyComments . b:ECidentBack . a:1
    elseif a:what == 'decommentstart'
                \ || a:what == 'decommentmiddle'
                \ || a:what == 'decommentend'
        let regex = handleWhitespace
    endif

    return regex
endfunction

"
"
" DecideWhatToDo(lineString, commentStart, ...)
"       lineString      -- first line of block
"       commentStart    -- comment start symbol
"       a:1             -- comment end symbol
"
function s:DecideWhatToDo(lineString, commentStart, ...)
    " If we checked already, we return our previous result.
    if !s:firstOfBlock
                \ && (s:Action == 'first'
                \       || (b:ECuseMPBlock && s:inBlock && a:0))
        return s:blockAction
    endif

    let s:blockAction = 'comment'

    if s:inBlock && a:0 && b:ECuseMPBlock
        let first = getline(s:startBlock)
        let last = getline(s:endBlock)

        if first =~ s:LookFor('checkstart', a:commentStart)
                \ && first !~ s:LookFor('checkend', a:1)
                \ && last !~ s:LookFor('checkstart', a:commentStart)
                \ && last =~ s:LookFor('checkend', a:1)
            let s:blockAction = 'decomment'
        endif

        return s:blockAction
    endif

    if a:lineString =~ s:LookFor('checkstart', a:commentStart)
        let s:blockAction = 'decomment'
    endif

    if a:0
        if a:lineString !~ s:LookFor('checkend', a:1)
            let s:blockAction = 'comment'
        endif
    endif

    let s:firstOfBlock = 0
    return s:blockAction
endfunction

"
" TabsToSpaces(str)
"       str         -- string to convert
"
" Convert leading tabs of given string to spaces.
"
function s:TabsToSpaces(str)
    let string = a:str

    " FIXME: Can we use something like retab? I don't think so,
    " because retab changes every whitespace in the line, but we
    " wan't to modify only the leading spaces. Is this a problem?
    while string =~ '^\( *\)\t'
        let string = substitute(string, '^\( *\)\t', '\1'. s:tabConvert, "")
    endwhile

    return string
endfunction

"
" SpacesToTabs(str)
"       str         -- string to convert
"
" Convert leading spaces of given string to tabs.
"
function s:SpacesToTabs(str)
    let string = a:str

    if !&expandtab
        while string =~ '^\(\t*\)'. s:tabConvert
            let string = substitute(string, '^\(\t*\)'. s:tabConvert,
                        \ '\1\t', "")
        endwhile
    endif

    return string
endfunction

"
" EnhCommentifyFallback4Embedded(test, fallback)
"       test        -- test for the special case
"       fallback    -- filetype instead of normal fallback
"
" This function is global. It should be called from filetype
" plugins like php, where the normal fallback behaviour may
" not work. One may use 'synFiletype' to reference the guessed
" filetype via synID.
"
function EnhCommentifyFallback4Embedded(test, fallback)
    let b:EnhCommentifyFallbackTest = a:test
    let b:EnhCommentifyFallbackValue = a:fallback
endfunction

"
" Keyboard mappings.
"
noremap <Plug>Comment
            \ :call EnhancedCommentify('', 'comment')<CR>
noremap <Plug>DeComment
            \ :call EnhancedCommentify('', 'decomment')<CR>
noremap <Plug>Traditional
            \ :call EnhancedCommentify('', 'guess')<CR>
noremap <Plug>FirstLine
            \ :call EnhancedCommentify('', 'first')<CR>

noremap <Plug>VisualComment
            \ <Esc>:call EnhancedCommentify('', 'comment',
            \   line("'<"), line("'>"))<CR>
noremap <Plug>VisualDeComment
            \ <Esc>:call EnhancedCommentify('', 'decomment',
            \   line("'<"), line("'>"))<CR>
noremap <Plug>VisualTraditional
            \ <Esc>:call EnhancedCommentify('', 'guess',
            \   line("'<"), line("'>"))<CR>
noremap <Plug>VisualFirstLine
            \ <Esc>:call EnhancedCommentify('', 'first',
            \   line("'<"), line("'>"))<CR>
"
" Finally set keybindings.
"
" SetKeybindings(where)
"       where       -- "l" for local to the buffer, "g" for global
"
function s:SetKeybindings(where)
    if a:where == "l"
        let where = "<buffer>"
        let ns = "b"
    else
        let where = ""
        let ns = "s"
    endif

    execute "let userBindings = ". ns .":ECuserBindings"
    execute "let useAltKeys = ". ns .":ECuseAltKeys"
    execute "let traditionalMode = ". ns .":ECtraditionalMode"
    execute "let firstLineMode = ". ns .":ECfirstLineMode"
    execute "let bindInNormal = ". ns .":ECbindInNormal"
    execute "let bindInInsert = ". ns .":ECbindInInsert"
    execute "let bindInVisual = ". ns .":ECbindInVisual"

    if userBindings
        "
        " *** Put your personal bindings here! ***
        "
    else
        if useAltKeys
            let s:c = '<M-c>'
            let s:x = '<M-x>'
            let s:C = '<M-v>'
            let s:X = '<M-y>'
        else
            let s:c = '<Leader>c'
            let s:x = '<Leader>x'
            let s:C = '<Leader>C'
            let s:X = '<Leader>X'
        endif

        if traditionalMode
            let s:Method = 'Traditional'
        elseif firstLineMode
            let s:Method = 'FirstLine'
        else
            let s:Method = 'Comment'

            " Decomment must be defined here. Everything else is mapped below.
            if bindInNormal 
                execute 'nmap '. where .' <silent> <unique> '. s:C
                            \ .' <Plug>DeCommentj'
                execute 'nmap '. where .' <silent> <unique> '. s:X
                            \ .' <Plug>DeComment'
            endif

            if bindInInsert
                execute 'imap '. where .' <silent> <unique> '. s:C
                            \ .' <Esc><Plug>DeCommentji'
                execute 'imap '. where .' <silent> <unique> '. s:X
                            \ .' <Esc><Plug>DeCommenti'
            endif

            if bindInVisual
                execute 'vmap '. where .' <silent> <unique> '. s:C
                            \ .' <Plug>VisualDeCommentj'
                execute 'vmap '. where .' <silent> <unique> '. s:X
                            \ .' <Plug>VisualDeComment'
            endif
        endif

        if bindInNormal
            execute 'nmap '. where .' <silent> <unique> '. s:c
                        \ .' <Plug>'. s:Method .'j'
            execute 'nmap '. where .' <silent> <unique> '. s:x
                        \ .' <Plug>'. s:Method
        endif

        if bindInInsert
            execute 'imap '. where .' <silent> <unique> '. s:c
                        \ .' <Esc><Plug>'. s:Method .'ji'
            execute 'imap '. where .' <silent> <unique> '. s:x
                        \ .' <Esc><Plug>'. s:Method
        endif

        if bindInVisual
            execute 'vmap <silent> <unique> '. s:c
                        \ .' <Plug>Visual'. s:Method .'j'
            execute 'vmap '. where .' <silent> <unique> '. s:x
                        \ .' <Plug>Visual'. s:Method
        endif
    endif
endfunction

if !s:ECbindPerBuffer
    call s:SetKeybindings("g")
endif

let &cpo = s:savedCpo

" vim: set sts=4 sw=4 ts=8 :