Created
July 2, 2017 22:18
-
-
Save rpietro/c70a722f43686ad5e280e3130e190c9b to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Searching for "autoload/tcomment.vim" in "/home/rpietro/.vim,/home/rpietro/.vim/bundle/vim-commentary,/home/rpietro/.vim/bundle/vim-markdown,/home/rpietro/.vim/bundle/vimwiki,/usr/share/vim/vimfiles,/usr/share/vim/vim80,/usr/share/vim/vimfiles/after,/home/rpietro/.vim/bundle/vim-markdown/after,/home/rpietro/.vim/after" | |
| Searching for "/home/rpietro/.vim/autoload/tcomment.vim" | |
| chdir(/home/rpietro/.vim/autoload) | |
| fchdir() to previous dir | |
| sourcing "/home/rpietro/.vim/autoload/tcomment.vim" | |
| line 1: " @Author: Tom Link (mailto:micathom AT gmail com?subject=[vim]) | |
| line 2: " @Website: http://www.vim.org/account/profile.php?user_id=4037 | |
| line 3: " @License: GPL (see http://www.gnu.org/licenses/gpl.txt) | |
| line 4: " @Created: 2007-09-17. | |
| line 5: " @Last Change: 2015-09-30. | |
| line 6: " @Revision: 1781 | |
| line 7: | |
| line 8: " call tlog#Log('Load: '. expand('<sfile>')) " vimtlib-sfile | |
| line 9: | |
| line 10: if !exists("g:tcomment#blank_lines") | |
| line 11: " If 1, comment blank lines too. | |
| line 12: " If 2, also comment blank lines within indented code blocks | |
| line 13: " (requires mixedindent -- see |tcomment#Comment()|). | |
| line 14: let g:tcomment#blank_lines = 2 "{{{2 | |
| line 15: endif | |
| line 16: | |
| line 17: if !exists('g:tcomment#rstrip_on_uncomment') | |
| line 18: " If 1, remove right-hand whitespace on uncomment from empty lines. | |
| line 19: " If 2, remove right-hand whitespace on uncomment from all lines. | |
| line 20: let g:tcomment#rstrip_on_uncomment = 1 "{{{2 | |
| line 21: endif | |
| line 22: | |
| line 23: if !exists("g:tcommentModeExtra") | |
| line 24: " Modifies how commenting works. | |
| line 25: " > ... Move the cursor to the end of the comment | |
| line 26: " >> ... Like above but move the cursor to the next line | |
| line 27: " # ... Move the cursor to the position of the commented text | |
| line 28: " (NOTE: this only works when creating empty comments using | |
| line 29: " |:TCommentInline| from normal or insert mode and should | |
| line 30: " not be set here as a global option.) | |
| line 31: let g:tcommentModeExtra = '' "{{{2 | |
| line 32: endif | |
| line 33: | |
| line 34: if !exists("g:tcommentOpModeExtra") | |
| line 35: " Modifies how the operator works. | |
| line 36: " See |g:tcommentModeExtra| for a list of possible values. | |
| line 37: let g:tcommentOpModeExtra = '' "{{{2 | |
| line 38: endif | |
| line 39: | |
| line 40: if !exists('g:tcommentOptions') | |
| line 41: " Other key-value options used by |tcomment#Comment()|. | |
| line 42: " | |
| line 43: " Examples: | |
| line 44: " Put the opening comment marker always in the first column | |
| line 45: " regardless of the block's indentation, put this into your |vimrc| | |
| line 46: " file: > | |
| line 47: " let g:tcommentOptions = {'col': 1} | |
| line 48: " | |
| line 49: " Indent uncommented lines: > | |
| line 50: " let g:tcommentOptions = {'postprocess_uncomment': 'norm! %sgg=%sgg'} | |
| line 51: let g:tcommentOptions = {} "{{{2 | |
| line 52: endif | |
| line 53: | |
| line 54: if !exists('g:tcomment#options_comments') | |
| line 55: " Additional args for |tcomment#Comment()| when using the 'comments' | |
| line 56: " option. | |
| line 57: let g:tcomment#options_comments = {'whitespace': get(g:tcommentOptions, 'whitespace', 'both')} "{{{2 | |
| line 58: endif | |
| line 59: | |
| line 60: if !exists('g:tcomment#options_commentstring') | |
| line 61: " Additional args for |tcomment#Comment()| when using the | |
| line 62: " 'commentstring' option. | |
| line 63: let g:tcomment#options_commentstring = {'whitespace': get(g:tcommentOptions, 'whitespace', 'both')} "{{{2 | |
| line 64: endif | |
| line 65: | |
| line 66: if !exists('g:tcomment#ignore_char_type') | |
| line 67: " |text-objects| for use with |tcomment#Operator| can have different | |
| line 68: " types: line, block, char etc. Text objects like aB, it, at etc. | |
| line 69: " have type char but this may not work reliably. By default, | |
| line 70: " tcomment handles those text objects most often as if they were of | |
| line 71: " type line. Set this variable to 0 in order to change this | |
| line 72: " behaviour. Be prepared that the result may not always match your | |
| line 73: " intentions. | |
| line 74: let g:tcomment#ignore_char_type = 1 "{{{2 | |
| line 75: endif | |
| line 76: | |
| line 77: if !exists("g:tcommentGuessFileType") | |
| line 78: " Guess the file type based on syntax names always or for some fileformat only | |
| line 79: " If non-zero, try to guess filetypes. | |
| line 80: " tcomment also checks g:tcommentGuessFileType_{&filetype} for | |
| line 81: " filetype specific values. | |
| line 82: " | |
| line 83: " Values: | |
| line 84: " 0 ... don't guess | |
| line 85: " 1 ... guess | |
| line 86: " FILETYPE ... assume this filetype | |
| line 87: let g:tcommentGuessFileType = 0 "{{{2 | |
| line 88: endif | |
| line 89: if !exists("g:tcommentGuessFileType_dsl") | |
| line 90: " For dsl documents, assume filetype = xml. | |
| line 91: let g:tcommentGuessFileType_dsl = 'xml' "{{{2 | |
| line 92: endif | |
| line 93: if !exists("g:tcommentGuessFileType_php") | |
| line 94: " In php documents, the php part is usually marked as phpRegion. We | |
| line 95: " thus assume that the buffers default comment style isn't php but | |
| line 96: " html. | |
| line 97: let g:tcommentGuessFileType_php = 'html' "{{{2 | |
| line 98: endif | |
| line 99: if !exists("g:tcommentGuessFileType_blade") | |
| line 100: " See |g:tcommentGuessFileType_php|. | |
| line 101: let g:tcommentGuessFileType_blade = 'html' "{{{2 | |
| line 102: endif | |
| line 103: if !exists("g:tcommentGuessFileType_html") | |
| line 104: let g:tcommentGuessFileType_html = 1 "{{{2 | |
| line 105: endif | |
| line 106: if !exists("g:tcommentGuessFileType_tskeleton") | |
| line 107: let g:tcommentGuessFileType_tskeleton = 1 "{{{2 | |
| line 108: endif | |
| line 109: if !exists("g:tcommentGuessFileType_vim") | |
| line 110: let g:tcommentGuessFileType_vim = 1 "{{{2 | |
| line 111: endif | |
| line 112: if !exists("g:tcommentGuessFileType_django") | |
| line 113: let g:tcommentGuessFileType_django = 1 "{{{2 | |
| line 114: endif | |
| line 115: if !exists("g:tcommentGuessFileType_eruby") | |
| line 116: let g:tcommentGuessFileType_eruby = 1 "{{{2 | |
| line 117: endif | |
| line 118: if !exists("g:tcommentGuessFileType_jinja") | |
| line 119: let g:tcommentGuessFileType_jinja = 'html' "{{{2 | |
| line 120: endif | |
| line 121: if !exists("g:tcommentGuessFileType_smarty") | |
| line 122: let g:tcommentGuessFileType_smarty = 1 "{{{2 | |
| line 123: endif | |
| line 124: if !exists("g:tcommentGuessFileType_rnoweb") | |
| line 125: let g:tcommentGuessFileType_rnoweb = 'r' "{{{2 | |
| line 126: endif | |
| line 127: | |
| line 128: if !exists("g:tcommentIgnoreTypes_php") | |
| line 129: " In php files, some syntax regions are wrongly highlighted as sql | |
| line 130: " markup. We thus ignore sql syntax when guessing the filetype in | |
| line 131: " php files. | |
| line 132: let g:tcommentIgnoreTypes_php = 'sql' "{{{2 | |
| line 133: endif | |
| line 134: | |
| line 135: if !exists('g:tcomment#syntax_substitute') | |
| line 136: " :read: let g:tcomment#syntax_substitute = {...} "{{{2 | |
| line 137: " Perform replacements on the syntax name. | |
| line 141: let g:tcomment#syntax_substitute = { '\C^javaScript\ze\(\u\|$\)': {'sub': 'javascript'}, '\C^js\ze\(\u\|$\)': {'sub': 'javascript'} } | |
| line 142: endif | |
| line 143: | |
| line 144: if !exists('g:tcomment#filetype_map') | |
| line 145: " Keys must match the full |filetype|. Regexps must be |magic|. No | |
| line 146: " regexp modifiers (like |\V|) are allowed. | |
| line 147: " let g:tcomment#filetype_map = {...} "{{{2 | |
| line 151: let g:tcomment#filetype_map = { 'rails-views': 'html', 'mkd': 'html', } | |
| line 152: endif | |
| line 153: | |
| line 154: if !exists('g:tcommentSyntaxMap') | |
| line 155: " tcomment guesses filetypes based on the name of the current syntax | |
| line 156: " region. This works well if the syntax names match | |
| line 157: " /filetypeSomeName/. Other syntax names have to be explicitly | |
| line 158: " mapped onto the corresponding filetype. | |
| line 159: " :read: let g:tcommentSyntaxMap = {...} "{{{2 | |
| line 182: let g:tcommentSyntaxMap = { 'erubyExpression': 'ruby', 'vimMzSchemeRegion': 'scheme', 'vimPerlRegion': 'perl', 'vimPythonRegion': 'python', 'vimRubyRegion': 'ruby', 'vimTclRegion': 'tcl', 'Delimiter': { 'filetype': { 'php': 'php', }, }, 'phpRegionDelimiter': { 'prevnonblank': [ {'match': '<?php', 'filetype': 'php'}, {'match': '?>', 'filetype': 'html'}, ], 'nextnonblank': [ {'match': '?>', 'filetype': 'php'}, {'match': '<?php', 'filetype': 'html'}, ], }, } | |
| line 183: endif | |
| line 184: | |
| line 185: if !exists('g:tcomment#replacements_c') | |
| line 186: " Replacements for c filetype. | |
| line 187: " :read: let g:tcomment#replacements_c = {...} "{{{2 | |
| line 191: let g:tcomment#replacements_c = { '/*': '#<{(|', '*/': '|)}>#', } | |
| line 192: endif | |
| line 193: | |
| line 194: if !exists("g:tcommentLineC_fmt") | |
| line 195: " Generic c-like block comments. | |
| line 203: let g:tcommentLineC_fmt = { 'commentstring_rx': '\%%(// %s\|/* %s */\)', 'commentstring': '/* %s */', 'rxbeg': '\*\+', 'rxend': '', 'rxmid': '', 'replacements': g:tcomment#replacements_c } | |
| line 204: endif | |
| line 205: | |
| line 206: | |
| line 207: function! tcomment#GetLineC(...) | |
| line 214: | |
| line 215: | |
| line 216: if !exists("g:tcommentInlineC") | |
| line 217: " Generic c-like comments. | |
| line 218: " :read: let g:tcommentInlineC = {...} "{{{2 | |
| line 219: let g:tcommentInlineC = tcomment#GetLineC() | |
| calling function tcomment#GetLineC() | |
| line 1: let cmt = deepcopy(g:tcommentLineC_fmt) | |
| line 2: if a:0 >= 1 | |
| line 3: let cmt.commentstring = a:1 | |
| line 4: endif | |
| line 5: return cmt | |
| function tcomment#GetLineC returning {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'} | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 220: endif | |
| line 221: | |
| line 222: | |
| line 223: if !exists("g:tcommentBlockC") | |
| line 231: let g:tcommentBlockC = { 'commentstring': '/*%s */', 'middle': ' * ', 'rxbeg': '\*\+', 'rxend': '', 'rxmid': '', 'replacements': g:tcomment#replacements_c } | |
| line 232: endif | |
| line 233: if !exists("g:tcommentBlockC2") | |
| line 234: " Generic c-like block comments (alternative markup). | |
| line 235: " :read: let g:tcommentBlockC2 = {...} "{{{2 | |
| line 243: let g:tcommentBlockC2 = { 'commentstring': '/**%s */', 'middle': ' * ', 'rxbeg': '\*\+', 'rxend': '\*\+', 'rxmid': '\*\+', 'replacements': g:tcomment#replacements_c } | |
| line 244: endif | |
| line 245: | |
| line 246: if !exists('g:tcomment#replacements_xml') | |
| line 247: " Replacements for xml filetype. | |
| line 248: " :read: let g:tcomment#replacements_xml = {...} "{{{2 | |
| line 252: let g:tcomment#replacements_xml = { '-': '-', '&': '&', } | |
| line 253: endif | |
| line 254: | |
| line 255: if !exists("g:tcommentBlockXML") | |
| line 256: " Generic xml-like block comments. | |
| line 257: " :read: let g:tcommentBlockXML = {...} "{{{2 | |
| line 261: let g:tcommentBlockXML = { 'commentstring': "<!--%s-->\n ", 'replacements': g:tcomment#replacements_xml } | |
| line 262: endif | |
| line 263: if !exists("g:tcommentInlineXML") | |
| line 264: " Generic xml-like comments. | |
| line 265: " :read: let g:tcommentInlineXML = {...} "{{{2 | |
| line 269: let g:tcommentInlineXML = { 'commentstring': "<!-- %s -->", 'replacements': g:tcomment#replacements_xml } | |
| line 270: endif | |
| line 271: | |
| line 272: if !exists('g:tcomment#ignore_comment_def') | |
| line 273: " A list of names or filetypes, which should be ignored by | |
| line 274: " |tcomment#DefineType()| -- no custom comment definition will be | |
| line 275: " stored for these names. | |
| line 276: " | |
| line 277: " This variable should be set before loading autoload/tcomment.vim. | |
| line 278: let g:tcomment#ignore_comment_def = [] "{{{2 | |
| line 279: endif | |
| line 280: | |
| line 281: if !exists('g:tcomment#must_escape_expression_backslash') | |
| line 282: " Users of vim earlier than 7.3 might have to set this variable to | |
| line 283: " true. Set this variable to 0, if you see unexpected "\r" char | |
| line 284: " sequences in comments. | |
| line 285: " | |
| line 286: " The reommended value was `!(v:version > 702 || (v:version == 702 && has('patch407')))`. | |
| line 287: " It is now assumed though, that no unpatched versions of vim are in | |
| line 288: " use. | |
| line 289: " | |
| line 290: " References: | |
| line 291: " Patch 7.2.407 when using :s with an expression backslashes are dropped | |
| line 292: " https://github.com/tomtom/tcomment_vim/issues/102 | |
| line 293: let g:tcomment#must_escape_expression_backslash = 0 "{{{2 | |
| line 294: endif | |
| line 295: | |
| line 296: | |
| line 297: let s:types_dirty = 1 | |
| line 298: | |
| line 299: let s:definitions = {} | |
| line 300: | |
| line 301: " If you don't explicitly define a comment style, |:TComment| will use | |
| line 302: " 'commentstring' instead. We override the default values here in order | |
| line 303: " to have a blank after the comment marker. Block comments work only if | |
| line 304: " we explicitly define the markup. | |
| line 305: " | |
| line 306: " NAME usually is a 'filetype'. You can use special suffixes to define | |
| line 307: " special comment types. E.g. the name "FILETYPE_block" is used for | |
| line 308: " block comments for 'filetype'. The name "FILETYPE_inline" is used for | |
| line 309: " inline comments. If no specialized comment definition exists, the | |
| line 310: " normal one with name "FILETYPE" is used. | |
| line 311: " | |
| line 312: " The comment definition can be either a string or a dictionary. | |
| line 313: " | |
| line 314: " If it is a string: | |
| line 315: " The format for block comments is similar to 'commentstrings' with the | |
| line 316: " exception that the format strings for blocks can contain a second line | |
| line 317: " that defines how "middle lines" (see :h format-comments) should be | |
| line 318: " displayed. | |
| line 319: " | |
| line 320: " Example: If the string is "--%s--\n-- ", lines will be commented as | |
| line 321: " "--%s--" but the middle lines in block comments will be commented as | |
| line 322: " "--%s". | |
| line 323: " | |
| line 324: " If it is a dictionary: | |
| line 325: " See the help on the args argument of |tcomment#Comment| (see item 1, | |
| line 326: " args is a list of key=value pairs) to find out which fields can be | |
| line 327: " used. | |
| line 328: " :display: tcomment#DefineType(name, commentdef, ?cdef={}, ?anyway=0) | |
| line 329: function! tcomment#DefineType(name, commentdef, ...) | |
| line 344: | |
| line 345: " Return the comment definition for NAME. | |
| line 346: " *b:tcomment_def_{NAME}* | |
| line 347: " Return b:tcomment_def_{NAME} if the variable exists. Otherwise return | |
| line 348: " the comment definition as set with |tcomment#DefineType|. | |
| line 349: function! tcomment#GetCommentDef(name, ...) | |
| line 356: | |
| line 357: " :nodoc: | |
| line 358: " Return 1 if a comment type is defined. | |
| line 359: function! tcomment#TypeExists(name, ...) | |
| line 369: | |
| line 370: call tcomment#DefineType('aap', '# %s' ) | |
| calling function tcomment#DefineType('aap', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 371: call tcomment#DefineType('ada', '-- %s' ) | |
| calling function tcomment#DefineType('ada', '-- %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 372: call tcomment#DefineType('autohotkey', '; %s' ) | |
| calling function tcomment#DefineType('autohotkey', '; %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 373: call tcomment#DefineType('apache', '# %s' ) | |
| calling function tcomment#DefineType('apache', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 374: call tcomment#DefineType('applescript', '(* %s *)' ) | |
| calling function tcomment#DefineType('applescript', '(* %s *)') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 375: call tcomment#DefineType('applescript_block',"(*%s*)\n" ) | |
| calling function tcomment#DefineType('applescript_block', '(*%s*) | |
| ') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 376: call tcomment#DefineType('applescript_inline','(* %s *)' ) | |
| calling function tcomment#DefineType('applescript_inline', '(* %s *)') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 377: call tcomment#DefineType('asciidoc', '// %s' ) | |
| calling function tcomment#DefineType('asciidoc', '// %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 378: call tcomment#DefineType('asm', '; %s' ) | |
| calling function tcomment#DefineType('asm', '; %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 379: call tcomment#DefineType('asterisk', '; %s' ) | |
| calling function tcomment#DefineType('asterisk', '; %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 380: call tcomment#DefineType('blade', '{{-- %s --}}' ) | |
| calling function tcomment#DefineType('blade', '{{-- %s --}}') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 381: call tcomment#DefineType('blade_block', '{{-- %s --}}' ) | |
| calling function tcomment#DefineType('blade_block', '{{-- %s --}}') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 382: call tcomment#DefineType('blade_inline', '{{-- %s --}}' ) | |
| calling function tcomment#DefineType('blade_inline', '{{-- %s --}}') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 383: call tcomment#DefineType('c', tcomment#GetLineC()) | |
| calling function tcomment#GetLineC() | |
| line 1: let cmt = deepcopy(g:tcommentLineC_fmt) | |
| line 2: if a:0 >= 1 | |
| line 3: let cmt.commentstring = a:1 | |
| line 4: endif | |
| line 5: return cmt | |
| function tcomment#GetLineC returning {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'} | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| calling function tcomment#DefineType('c', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 384: call tcomment#DefineType('c_block', g:tcommentBlockC ) | |
| calling function tcomment#DefineType('c_block', {'rxmid': '', 'rxend': '', 'middle': '...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 385: call tcomment#DefineType('c_inline', g:tcommentInlineC ) | |
| calling function tcomment#DefineType('c_inline', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 386: call tcomment#DefineType('catalog', '-- %s --' ) | |
| calling function tcomment#DefineType('catalog', '-- %s --') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 387: call tcomment#DefineType('catalog_block', "--%s--\n " ) | |
| calling function tcomment#DefineType('catalog_block', '--%s-- | |
| ') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 388: call tcomment#DefineType('cfg', '# %s' ) | |
| calling function tcomment#DefineType('cfg', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 389: call tcomment#DefineType('chromemanifest', '# %s' ) | |
| calling function tcomment#DefineType('chromemanifest', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 390: call tcomment#DefineType('clojure', {'commentstring': '; %s', 'count': 2}) | |
| calling function tcomment#DefineType('clojure', {'commentstring': '; %s', 'count': 2}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 391: call tcomment#DefineType('clojure_inline', '; %s' ) | |
| calling function tcomment#DefineType('clojure_inline', '; %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 392: call tcomment#DefineType('clojurescript', ';; %s' ) | |
| calling function tcomment#DefineType('clojurescript', ';; %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 393: call tcomment#DefineType('clojurescript_inline', '; %s' ) | |
| calling function tcomment#DefineType('clojurescript_inline', '; %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 394: call tcomment#DefineType('cmake', '# %s' ) | |
| calling function tcomment#DefineType('cmake', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 395: call tcomment#DefineType('coffee', '# %s' ) | |
| calling function tcomment#DefineType('coffee', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 396: call tcomment#DefineType('conf', '# %s' ) | |
| calling function tcomment#DefineType('conf', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 397: call tcomment#DefineType('context', '%% %s' ) | |
| calling function tcomment#DefineType('context', '%% %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 398: call tcomment#DefineType('conkyrc', '# %s' ) | |
| calling function tcomment#DefineType('conkyrc', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 399: call tcomment#DefineType('cpp', tcomment#GetLineC('// %s')) | |
| calling function tcomment#GetLineC('// %s') | |
| line 1: let cmt = deepcopy(g:tcommentLineC_fmt) | |
| line 2: if a:0 >= 1 | |
| line 3: let cmt.commentstring = a:1 | |
| line 4: endif | |
| line 5: return cmt | |
| function tcomment#GetLineC returning {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'} | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| calling function tcomment#DefineType('cpp', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 400: call tcomment#DefineType('cpp_block', g:tcommentBlockC ) | |
| calling function tcomment#DefineType('cpp_block', {'rxmid': '', 'rxend': '', 'middle': '...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 401: call tcomment#DefineType('cpp_inline', g:tcommentInlineC ) | |
| calling function tcomment#DefineType('cpp_inline', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 402: call tcomment#DefineType('cram', {'col': 1, 'commentstring': '# %s' }) | |
| calling function tcomment#DefineType('cram', {'col': 1, 'commentstring': '# %s'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 403: call tcomment#DefineType('crontab', '# %s' ) | |
| calling function tcomment#DefineType('crontab', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 404: call tcomment#DefineType('cs', '// %s' ) | |
| calling function tcomment#DefineType('cs', '// %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 405: call tcomment#DefineType('cs_block', g:tcommentBlockC ) | |
| calling function tcomment#DefineType('cs_block', {'rxmid': '', 'rxend': '', 'middle': '...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 406: call tcomment#DefineType('cs_inline', g:tcommentInlineC ) | |
| calling function tcomment#DefineType('cs_inline', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 407: call tcomment#DefineType('css', '/* %s */' ) | |
| calling function tcomment#DefineType('css', '/* %s */') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 408: call tcomment#DefineType('css_block', g:tcommentBlockC ) | |
| calling function tcomment#DefineType('css_block', {'rxmid': '', 'rxend': '', 'middle': '...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 409: call tcomment#DefineType('css_inline', g:tcommentInlineC ) | |
| calling function tcomment#DefineType('css_inline', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 410: call tcomment#DefineType('debcontrol', '# %s' ) | |
| calling function tcomment#DefineType('debcontrol', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 411: call tcomment#DefineType('debsources', '# %s' ) | |
| calling function tcomment#DefineType('debsources', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 412: call tcomment#DefineType('desktop', '# %s' ) | |
| calling function tcomment#DefineType('desktop', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 413: call tcomment#DefineType('dnsmasq', '# %s' ) | |
| calling function tcomment#DefineType('dnsmasq', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 414: call tcomment#DefineType('docbk', g:tcommentInlineXML) | |
| calling function tcomment#DefineType('docbk', {'commentstring': '<!-- %s -->', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 415: call tcomment#DefineType('docbk_block', g:tcommentBlockXML ) | |
| calling function tcomment#DefineType('docbk_block', {'commentstring': '<!--%s--> | |
| ', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 416: call tcomment#DefineType('docbk_inline', g:tcommentInlineXML) | |
| calling function tcomment#DefineType('docbk_inline', {'commentstring': '<!-- %s -->', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 417: call tcomment#DefineType('dosbatch', 'rem %s' ) | |
| calling function tcomment#DefineType('dosbatch', 'rem %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 418: call tcomment#DefineType('dosini', '; %s' ) | |
| calling function tcomment#DefineType('dosini', '; %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 419: call tcomment#DefineType('dsl', '; %s' ) | |
| calling function tcomment#DefineType('dsl', '; %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 420: call tcomment#DefineType('dustjs', '{! %s !}' ) | |
| calling function tcomment#DefineType('dustjs', '{! %s !}') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 421: call tcomment#DefineType('dylan', '// %s' ) | |
| calling function tcomment#DefineType('dylan', '// %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 422: call tcomment#DefineType('eiffel', '-- %s' ) | |
| calling function tcomment#DefineType('eiffel', '-- %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 423: call tcomment#DefineType('elixir', '# %s' ) | |
| calling function tcomment#DefineType('elixir', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 424: call tcomment#DefineType('erlang', '%%%% %s' ) | |
| calling function tcomment#DefineType('erlang', '%%%% %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 425: call tcomment#DefineType('eruby', '<%%# %s' ) | |
| calling function tcomment#DefineType('eruby', '<%%# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 426: call tcomment#DefineType('esmtprc', '# %s' ) | |
| calling function tcomment#DefineType('esmtprc', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 427: call tcomment#DefineType('expect', '# %s' ) | |
| calling function tcomment#DefineType('expect', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 428: call tcomment#DefineType('fish', '# %s' ) | |
| calling function tcomment#DefineType('fish', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 429: call tcomment#DefineType('form', {'commentstring': '* %s', 'col': 1}) | |
| calling function tcomment#DefineType('form', {'col': 1, 'commentstring': '* %s'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 430: call tcomment#DefineType('fstab', '# %s' ) | |
| calling function tcomment#DefineType('fstab', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 431: call tcomment#DefineType('gitconfig', '# %s' ) | |
| calling function tcomment#DefineType('gitconfig', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 432: call tcomment#DefineType('gitcommit', '# %s' ) | |
| calling function tcomment#DefineType('gitcommit', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 433: call tcomment#DefineType('gitignore', '# %s' ) | |
| calling function tcomment#DefineType('gitignore', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 434: call tcomment#DefineType('gnuplot', '# %s' ) | |
| calling function tcomment#DefineType('gnuplot', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 435: call tcomment#DefineType('go', '// %s' ) | |
| calling function tcomment#DefineType('go', '// %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 436: call tcomment#DefineType('go_block', g:tcommentBlockC ) | |
| calling function tcomment#DefineType('go_block', {'rxmid': '', 'rxend': '', 'middle': '...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 437: call tcomment#DefineType('go_inline', g:tcommentInlineC ) | |
| calling function tcomment#DefineType('go_inline', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 438: call tcomment#DefineType('groovy', tcomment#GetLineC('// %s')) | |
| calling function tcomment#GetLineC('// %s') | |
| line 1: let cmt = deepcopy(g:tcommentLineC_fmt) | |
| line 2: if a:0 >= 1 | |
| line 3: let cmt.commentstring = a:1 | |
| line 4: endif | |
| line 5: return cmt | |
| function tcomment#GetLineC returning {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'} | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| calling function tcomment#DefineType('groovy', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 439: call tcomment#DefineType('groovy_block', g:tcommentBlockC ) | |
| calling function tcomment#DefineType('groovy_block', {'rxmid': '', 'rxend': '', 'middle': '...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 440: call tcomment#DefineType('groovy_doc_block', g:tcommentBlockC2 ) | |
| calling function tcomment#DefineType('groovy_doc_block', {'rxmid': '\*\+', 'rxend': '\*\+', 'mi...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 441: call tcomment#DefineType('groovy_inline', g:tcommentInlineC ) | |
| calling function tcomment#DefineType('groovy_inline', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 442: call tcomment#DefineType('gtkrc', '# %s' ) | |
| calling function tcomment#DefineType('gtkrc', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 443: call tcomment#DefineType('haml', '-# %s' ) | |
| calling function tcomment#DefineType('haml', '-# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 444: call tcomment#DefineType('haskell', '-- %s' ) | |
| calling function tcomment#DefineType('haskell', '-- %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 445: call tcomment#DefineType('haskell_block', "{-%s-}\n " ) | |
| calling function tcomment#DefineType('haskell_block', '{-%s-} | |
| ') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 446: call tcomment#DefineType('haskell_inline', '{- %s -}' ) | |
| calling function tcomment#DefineType('haskell_inline', '{- %s -}') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 447: call tcomment#DefineType('html', g:tcommentInlineXML) | |
| calling function tcomment#DefineType('html', {'commentstring': '<!-- %s -->', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 448: call tcomment#DefineType('html_block', g:tcommentBlockXML ) | |
| calling function tcomment#DefineType('html_block', {'commentstring': '<!--%s--> | |
| ', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 449: call tcomment#DefineType('html_inline', g:tcommentInlineXML) | |
| calling function tcomment#DefineType('html_inline', {'commentstring': '<!-- %s -->', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 450: call tcomment#DefineType('htmldjango', '{# %s #}' ) | |
| calling function tcomment#DefineType('htmldjango', '{# %s #}') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 451: call tcomment#DefineType('htmldjango_block', "{%% comment %%}%s{%% endcomment %%}\n ") | |
| calling function tcomment#DefineType('htmldjango_block', '{%% comment %%}%s{%% endcomment %%} | |
| ') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 452: call tcomment#DefineType('htmljinja', '{# %s #}' ) | |
| calling function tcomment#DefineType('htmljinja', '{# %s #}') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 453: call tcomment#DefineType('htmljinja_block', "{%% comment %%}%s{%% endcomment %%}\n ") | |
| calling function tcomment#DefineType('htmljinja_block', '{%% comment %%}%s{%% endcomment %%} | |
| ') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 454: call tcomment#DefineType('hy', '; %s' ) | |
| calling function tcomment#DefineType('hy', '; %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 455: call tcomment#DefineType('ini', '; %s' ) " php ini (/etc/php5/...) | |
| calling function tcomment#DefineType('ini', '; %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 456: call tcomment#DefineType('io', '// %s' ) | |
| calling function tcomment#DefineType('io', '// %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 457: call tcomment#DefineType('jade', '// %s' ) | |
| calling function tcomment#DefineType('jade', '// %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 458: call tcomment#DefineType('jasmine', '# %s' ) | |
| calling function tcomment#DefineType('jasmine', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 459: call tcomment#DefineType('java', tcomment#GetLineC('// %s')) | |
| calling function tcomment#GetLineC('// %s') | |
| line 1: let cmt = deepcopy(g:tcommentLineC_fmt) | |
| line 2: if a:0 >= 1 | |
| line 3: let cmt.commentstring = a:1 | |
| line 4: endif | |
| line 5: return cmt | |
| function tcomment#GetLineC returning {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'} | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| calling function tcomment#DefineType('java', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 460: call tcomment#DefineType('java_block', g:tcommentBlockC ) | |
| calling function tcomment#DefineType('java_block', {'rxmid': '', 'rxend': '', 'middle': '...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 461: call tcomment#DefineType('java_doc_block', g:tcommentBlockC2 ) | |
| calling function tcomment#DefineType('java_doc_block', {'rxmid': '\*\+', 'rxend': '\*\+', 'mi...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 462: call tcomment#DefineType('java_inline', g:tcommentInlineC ) | |
| calling function tcomment#DefineType('java_inline', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 463: call tcomment#DefineType('javascript', tcomment#GetLineC('// %s')) | |
| calling function tcomment#GetLineC('// %s') | |
| line 1: let cmt = deepcopy(g:tcommentLineC_fmt) | |
| line 2: if a:0 >= 1 | |
| line 3: let cmt.commentstring = a:1 | |
| line 4: endif | |
| line 5: return cmt | |
| function tcomment#GetLineC returning {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'} | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| calling function tcomment#DefineType('javascript', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 464: call tcomment#DefineType('javascript_block', g:tcommentBlockC ) | |
| calling function tcomment#DefineType('javascript_block', {'rxmid': '', 'rxend': '', 'middle': '...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 465: call tcomment#DefineType('javascript_inline', g:tcommentInlineC ) | |
| calling function tcomment#DefineType('javascript_inline', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 466: call tcomment#DefineType('jsx', '{/* %s */}') | |
| calling function tcomment#DefineType('jsx', '{/* %s */}') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 467: call tcomment#DefineType('jsx_block', '{/* %s */}') | |
| calling function tcomment#DefineType('jsx_block', '{/* %s */}') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 468: call tcomment#DefineType('jsx_inline', '{/* %s */}') | |
| calling function tcomment#DefineType('jsx_inline', '{/* %s */}') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 469: call tcomment#DefineType('jinja', '{# %s #}' ) | |
| calling function tcomment#DefineType('jinja', '{# %s #}') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 470: call tcomment#DefineType('jinja_block', "{%% comment %%}%s{%% endcomment %%}\n ") | |
| calling function tcomment#DefineType('jinja_block', '{%% comment %%}%s{%% endcomment %%} | |
| ') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 471: call tcomment#DefineType('jproperties', '# %s' ) | |
| calling function tcomment#DefineType('jproperties', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 472: call tcomment#DefineType('lilypond', '%% %s' ) | |
| calling function tcomment#DefineType('lilypond', '%% %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 473: call tcomment#DefineType('lisp', '; %s' ) | |
| calling function tcomment#DefineType('lisp', '; %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 474: call tcomment#DefineType('liquid', g:tcommentInlineXML) | |
| calling function tcomment#DefineType('liquid', {'commentstring': '<!-- %s -->', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 475: call tcomment#DefineType('liquid_block', g:tcommentBlockXML ) | |
| calling function tcomment#DefineType('liquid_block', {'commentstring': '<!--%s--> | |
| ', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 476: call tcomment#DefineType('liquid_inline', g:tcommentInlineXML) | |
| calling function tcomment#DefineType('liquid_inline', {'commentstring': '<!-- %s -->', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 477: call tcomment#DefineType('lua', '-- %s' ) | |
| calling function tcomment#DefineType('lua', '-- %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 478: call tcomment#DefineType('lua_block', "--[[%s--]]\n" ) | |
| calling function tcomment#DefineType('lua_block', '--[[%s--]] | |
| ') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 479: call tcomment#DefineType('lua_inline', '--[[%s --]]' ) | |
| calling function tcomment#DefineType('lua_inline', '--[[%s --]]') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 480: call tcomment#DefineType('lynx', '# %s' ) | |
| calling function tcomment#DefineType('lynx', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 481: call tcomment#DefineType('m4', 'dnl %s' ) | |
| calling function tcomment#DefineType('m4', 'dnl %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 482: call tcomment#DefineType('mail', '> %s' ) | |
| calling function tcomment#DefineType('mail', '> %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 483: call tcomment#DefineType('make', '# %s' ) | |
| calling function tcomment#DefineType('make', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 484: call tcomment#DefineType('markdown_block', "<!---%s--->\n " ) | |
| calling function tcomment#DefineType('markdown_block', '<!---%s---> | |
| ') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 485: call tcomment#DefineType('markdown.pandoc', '<!--- %s --->' ) | |
| calling function tcomment#DefineType('markdown.pandoc', '<!--- %s --->') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 486: call tcomment#DefineType('markdown.pandoc_block', "<!---%s--->\n ") | |
| calling function tcomment#DefineType('markdown.pandoc_block', '<!---%s---> | |
| ') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 487: call tcomment#DefineType('matlab', '%% %s' ) | |
| calling function tcomment#DefineType('matlab', '%% %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 488: call tcomment#DefineType('monkey', ''' %s' ) | |
| calling function tcomment#DefineType('monkey', ''' %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 489: call tcomment#DefineType('msidl', '// %s' ) | |
| calling function tcomment#DefineType('msidl', '// %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 490: call tcomment#DefineType('msidl_block', g:tcommentBlockC ) | |
| calling function tcomment#DefineType('msidl_block', {'rxmid': '', 'rxend': '', 'middle': '...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 491: call tcomment#DefineType('nginx', '# %s' ) | |
| calling function tcomment#DefineType('nginx', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 492: call tcomment#DefineType('nroff', '.\\" %s' ) | |
| calling function tcomment#DefineType('nroff', '.\\" %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 493: call tcomment#DefineType('noweb', '%% %s' ) | |
| calling function tcomment#DefineType('noweb', '%% %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 494: call tcomment#DefineType('nsis', '# %s' ) | |
| calling function tcomment#DefineType('nsis', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 495: call tcomment#DefineType('objc', '/* %s */' ) | |
| calling function tcomment#DefineType('objc', '/* %s */') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 496: call tcomment#DefineType('objc_block', g:tcommentBlockC ) | |
| calling function tcomment#DefineType('objc_block', {'rxmid': '', 'rxend': '', 'middle': '...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 497: call tcomment#DefineType('objc_inline', g:tcommentInlineC ) | |
| calling function tcomment#DefineType('objc_inline', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 498: call tcomment#DefineType('objcpp', '// %s' ) | |
| calling function tcomment#DefineType('objcpp', '// %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 499: call tcomment#DefineType('ocaml', '(* %s *)' ) | |
| calling function tcomment#DefineType('ocaml', '(* %s *)') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 500: call tcomment#DefineType('ocaml_block', "(*%s*)\n " ) | |
| calling function tcomment#DefineType('ocaml_block', '(*%s*) | |
| ') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 501: call tcomment#DefineType('ocaml_inline', '(* %s *)' ) | |
| calling function tcomment#DefineType('ocaml_inline', '(* %s *)') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 502: call tcomment#DefineType('pac', '// %s' ) | |
| calling function tcomment#DefineType('pac', '// %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 503: call tcomment#DefineType('pascal', '(* %s *)' ) | |
| calling function tcomment#DefineType('pascal', '(* %s *)') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 504: call tcomment#DefineType('pascal_block', "(*%s*)\n " ) | |
| calling function tcomment#DefineType('pascal_block', '(*%s*) | |
| ') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 505: call tcomment#DefineType('pascal_inline', '(* %s *)' ) | |
| calling function tcomment#DefineType('pascal_inline', '(* %s *)') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 506: call tcomment#DefineType('perl', '# %s' ) | |
| calling function tcomment#DefineType('perl', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 507: call tcomment#DefineType('perl_block', "=cut%s=cut" ) | |
| calling function tcomment#DefineType('perl_block', '=cut%s=cut') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 508: call tcomment#DefineType('pfmain', '# %s' ) | |
| calling function tcomment#DefineType('pfmain', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 509: call tcomment#DefineType('php', {'commentstring_rx': '\%%(//\|#\) %s', 'commentstring': '// %s'}) | |
| calling function tcomment#DefineType('php', {'commentstring': '// %s', 'commentstring_rx': '\%%(//\|#\) %s'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 510: call tcomment#DefineType('php_2_block', g:tcommentBlockC2 ) | |
| calling function tcomment#DefineType('php_2_block', {'rxmid': '\*\+', 'rxend': '\*\+', 'mi...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 511: call tcomment#DefineType('php_block', g:tcommentBlockC ) | |
| calling function tcomment#DefineType('php_block', {'rxmid': '', 'rxend': '', 'middle': '...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 512: call tcomment#DefineType('php_inline', g:tcommentInlineC ) | |
| calling function tcomment#DefineType('php_inline', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 513: call tcomment#DefineType('po', '# %s' ) | |
| calling function tcomment#DefineType('po', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 514: call tcomment#DefineType('prolog', '%% %s' ) | |
| calling function tcomment#DefineType('prolog', '%% %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 515: call tcomment#DefineType('puppet', '# %s' ) | |
| calling function tcomment#DefineType('puppet', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 516: call tcomment#DefineType('purescript', '-- %s' ) | |
| calling function tcomment#DefineType('purescript', '-- %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 517: call tcomment#DefineType('purescript_block', "{-%s-}\n " ) | |
| calling function tcomment#DefineType('purescript_block', '{-%s-} | |
| ') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 518: call tcomment#DefineType('purescript_inline','{- %s -}' ) | |
| calling function tcomment#DefineType('purescript_inline', '{- %s -}') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 519: call tcomment#DefineType('python', '# %s' ) | |
| calling function tcomment#DefineType('python', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 520: call tcomment#DefineType('qml', '// %s' ) | |
| calling function tcomment#DefineType('qml', '// %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 521: call tcomment#DefineType('r', '# %s' ) | |
| calling function tcomment#DefineType('r', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 522: call tcomment#DefineType('racket', '; %s' ) | |
| calling function tcomment#DefineType('racket', '; %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 523: call tcomment#DefineType('racket_block', '#|%s|#' ) | |
| calling function tcomment#DefineType('racket_block', '#|%s|#') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 524: call tcomment#DefineType('rc', '// %s' ) | |
| calling function tcomment#DefineType('rc', '// %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 525: call tcomment#DefineType('readline', '# %s' ) | |
| calling function tcomment#DefineType('readline', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 526: call tcomment#DefineType('remind', {'commentstring_rx': '\[;#] %s', 'commentstring': '# %s'}) | |
| calling function tcomment#DefineType('remind', {'commentstring': '# %s', 'commentstring_rx': '\[;#] %s'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 527: call tcomment#DefineType('resolv', '# %s' ) | |
| calling function tcomment#DefineType('resolv', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 528: call tcomment#DefineType('robot', {'col': 1, 'commentstring': '# %s'}) | |
| calling function tcomment#DefineType('robot', {'col': 1, 'commentstring': '# %s'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 529: call tcomment#DefineType('robots', '# %s' ) | |
| calling function tcomment#DefineType('robots', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 530: call tcomment#DefineType('rust', tcomment#GetLineC('// %s')) | |
| calling function tcomment#GetLineC('// %s') | |
| line 1: let cmt = deepcopy(g:tcommentLineC_fmt) | |
| line 2: if a:0 >= 1 | |
| line 3: let cmt.commentstring = a:1 | |
| line 4: endif | |
| line 5: return cmt | |
| function tcomment#GetLineC returning {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'} | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| calling function tcomment#DefineType('rust', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 531: call tcomment#DefineType('rust_block', g:tcommentBlockC ) | |
| calling function tcomment#DefineType('rust_block', {'rxmid': '', 'rxend': '', 'middle': '...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 532: call tcomment#DefineType('ruby', '# %s' ) | |
| calling function tcomment#DefineType('ruby', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 533: call tcomment#DefineType('ruby_3', '### %s' ) | |
| calling function tcomment#DefineType('ruby_3', '### %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 534: call tcomment#DefineType('ruby_block', "=begin rdoc%s=end") | |
| calling function tcomment#DefineType('ruby_block', '=begin rdoc%s=end') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 535: call tcomment#DefineType('ruby_nodoc_block', "=begin%s=end" ) | |
| calling function tcomment#DefineType('ruby_nodoc_block', '=begin%s=end') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 536: call tcomment#DefineType('samba', '# %s' ) | |
| calling function tcomment#DefineType('samba', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 537: call tcomment#DefineType('sbs', "' %s" ) | |
| calling function tcomment#DefineType('sbs', ''' %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 538: call tcomment#DefineType('scala', '// %s' ) | |
| calling function tcomment#DefineType('scala', '// %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 539: call tcomment#DefineType('scala_block', g:tcommentBlockC ) | |
| calling function tcomment#DefineType('scala_block', {'rxmid': '', 'rxend': '', 'middle': '...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 540: call tcomment#DefineType('scala_inline', g:tcommentInlineC ) | |
| calling function tcomment#DefineType('scala_inline', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 541: call tcomment#DefineType('scheme', '; %s' ) | |
| calling function tcomment#DefineType('scheme', '; %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 542: call tcomment#DefineType('scheme_block', '#|%s|#' ) | |
| calling function tcomment#DefineType('scheme_block', '#|%s|#') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 543: call tcomment#DefineType('scss', '// %s' ) | |
| calling function tcomment#DefineType('scss', '// %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 544: call tcomment#DefineType('scss_block', g:tcommentBlockC ) | |
| calling function tcomment#DefineType('scss_block', {'rxmid': '', 'rxend': '', 'middle': '...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 545: call tcomment#DefineType('scss_inline', g:tcommentInlineC ) | |
| calling function tcomment#DefineType('scss_inline', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 546: call tcomment#DefineType('sed', '# %s' ) | |
| calling function tcomment#DefineType('sed', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 547: call tcomment#DefineType('sgml', g:tcommentInlineXML) | |
| calling function tcomment#DefineType('sgml', {'commentstring': '<!-- %s -->', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 548: call tcomment#DefineType('sgml_block', g:tcommentBlockXML ) | |
| calling function tcomment#DefineType('sgml_block', {'commentstring': '<!--%s--> | |
| ', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 549: call tcomment#DefineType('sgml_inline', g:tcommentInlineXML) | |
| calling function tcomment#DefineType('sgml_inline', {'commentstring': '<!-- %s -->', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 550: call tcomment#DefineType('sh', '# %s' ) | |
| calling function tcomment#DefineType('sh', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 551: call tcomment#DefineType('slim', '/%s' ) | |
| calling function tcomment#DefineType('slim', '/%s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 552: call tcomment#DefineType('sls', '# %s' ) | |
| calling function tcomment#DefineType('sls', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 553: call tcomment#DefineType('smarty', '{* %s *}' ) | |
| calling function tcomment#DefineType('smarty', '{* %s *}') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 554: call tcomment#DefineType('spec', '# %s' ) | |
| calling function tcomment#DefineType('spec', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 555: call tcomment#DefineType('sps', '* %s.' ) | |
| calling function tcomment#DefineType('sps', '* %s.') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 556: call tcomment#DefineType('sps_block', "* %s." ) | |
| calling function tcomment#DefineType('sps_block', '* %s.') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 557: call tcomment#DefineType('spss', '* %s.' ) | |
| calling function tcomment#DefineType('spss', '* %s.') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 558: call tcomment#DefineType('spss_block', "* %s." ) | |
| calling function tcomment#DefineType('spss_block', '* %s.') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 559: call tcomment#DefineType('sql', '-- %s' ) | |
| calling function tcomment#DefineType('sql', '-- %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 560: call tcomment#DefineType('squid', '# %s' ) | |
| calling function tcomment#DefineType('squid', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 561: call tcomment#DefineType('sshconfig', '# %s' ) | |
| calling function tcomment#DefineType('sshconfig', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 562: call tcomment#DefineType('sshdconfig', '# %s' ) | |
| calling function tcomment#DefineType('sshdconfig', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 563: call tcomment#DefineType('st', '" %s "' ) | |
| calling function tcomment#DefineType('st', '" %s "') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 564: call tcomment#DefineType('tcl', '# %s' ) | |
| calling function tcomment#DefineType('tcl', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 565: call tcomment#DefineType('tex', '%% %s' ) | |
| calling function tcomment#DefineType('tex', '%% %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 566: call tcomment#DefineType('toml', '# %s' ) | |
| calling function tcomment#DefineType('toml', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 567: call tcomment#DefineType('tpl', '<!-- %s -->' ) | |
| calling function tcomment#DefineType('tpl', '<!-- %s -->') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 568: call tcomment#DefineType('tup', '# %s' ) | |
| calling function tcomment#DefineType('tup', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 569: call tcomment#DefineType('typoscript', '# %s' ) | |
| calling function tcomment#DefineType('typoscript', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 570: call tcomment#DefineType('upstart', '# %s' ) | |
| calling function tcomment#DefineType('upstart', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 571: call tcomment#DefineType('vader', {'col': 1, 'commentstring': '" %s' }) | |
| calling function tcomment#DefineType('vader', {'col': 1, 'commentstring': '" %s'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 572: call tcomment#DefineType('vhdl', '-- %s' ) | |
| calling function tcomment#DefineType('vhdl', '-- %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 573: call tcomment#DefineType('verilog', '// %s' ) | |
| calling function tcomment#DefineType('verilog', '// %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 574: call tcomment#DefineType('verilog_inline', g:tcommentInlineC ) | |
| calling function tcomment#DefineType('verilog_inline', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 575: call tcomment#DefineType('verilog_block', g:tcommentBlockC ) | |
| calling function tcomment#DefineType('verilog_block', {'rxmid': '', 'rxend': '', 'middle': '...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 576: call tcomment#DefineType('verilog_systemverilog', '// %s' ) | |
| calling function tcomment#DefineType('verilog_systemverilog', '// %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 577: call tcomment#DefineType('verilog_systemverilog_block', g:tcommentBlockC) | |
| calling function tcomment#DefineType('verilog_systemverilog_block', {'rxmid': '', 'rxend': '', 'middle': '...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 578: call tcomment#DefineType('verilog_systemverilog_inline', g:tcommentInlineC) | |
| calling function tcomment#DefineType('verilog_systemverilog_inline', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 579: call tcomment#DefineType('viki', '%% %s' ) | |
| calling function tcomment#DefineType('viki', '%% %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 580: call tcomment#DefineType('viki_3', '%%%%%% %s' ) | |
| calling function tcomment#DefineType('viki_3', '%%%%%% %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 581: call tcomment#DefineType('viki_inline', '{cmt: %s}' ) | |
| calling function tcomment#DefineType('viki_inline', '{cmt: %s}') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 582: call tcomment#DefineType('vim', '" %s' ) | |
| calling function tcomment#DefineType('vim', '" %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 583: call tcomment#DefineType('vim_3', '""" %s' ) | |
| calling function tcomment#DefineType('vim_3', '""" %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 584: call tcomment#DefineType('vimwiki', '%%%% %s' ) | |
| calling function tcomment#DefineType('vimwiki', '%%%% %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 585: call tcomment#DefineType('websec', '# %s' ) | |
| calling function tcomment#DefineType('websec', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 586: call tcomment#DefineType('x86conf', '# %s' ) | |
| calling function tcomment#DefineType('x86conf', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 587: call tcomment#DefineType('xml', g:tcommentInlineXML) | |
| calling function tcomment#DefineType('xml', {'commentstring': '<!-- %s -->', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 588: call tcomment#DefineType('xml_block', g:tcommentBlockXML ) | |
| calling function tcomment#DefineType('xml_block', {'commentstring': '<!--%s--> | |
| ', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 589: call tcomment#DefineType('xml_inline', g:tcommentInlineXML) | |
| calling function tcomment#DefineType('xml_inline', {'commentstring': '<!-- %s -->', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 590: call tcomment#DefineType('xs', g:tcommentInlineC ) | |
| calling function tcomment#DefineType('xs', {'rxmid': '', 'rxend': '', 'commentstr...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 591: call tcomment#DefineType('xs_block', g:tcommentBlockC ) | |
| calling function tcomment#DefineType('xs_block', {'rxmid': '', 'rxend': '', 'middle': '...)}>#', '/*': '#<{(|'}, 'rxbeg': '\*\+'}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 592: call tcomment#DefineType('xslt', g:tcommentInlineXML) | |
| calling function tcomment#DefineType('xslt', {'commentstring': '<!-- %s -->', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 593: call tcomment#DefineType('xslt_block', g:tcommentBlockXML ) | |
| calling function tcomment#DefineType('xslt_block', {'commentstring': '<!--%s--> | |
| ', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 594: call tcomment#DefineType('xslt_inline', g:tcommentInlineXML) | |
| calling function tcomment#DefineType('xslt_inline', {'commentstring': '<!-- %s -->', 'replacements': {'&': '&', '-': '-'}}) | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 595: call tcomment#DefineType('yaml', '# %s' ) | |
| calling function tcomment#DefineType('yaml', '# %s') | |
| line 1: let basename = matchstr(a:name, '^[^_]\+') | |
| line 2: let use = a:0 >= 2 ? a:2 : len(filter(copy(g:tcomment#ignore_comment_def), 'v:val == basename')) == 0 | |
| line 3: " TLogVAR a:name, use | |
| line 4: if use | |
| line 5: if type(a:commentdef) == 4 | |
| line 6: let cdef = copy(a:commentdef) | |
| line 7: else | |
| line 8: let cdef = a:0 >= 1 ? a:1 : {} | |
| line 9: let cdef.commentstring = a:commentdef | |
| line 10: endif | |
| line 11: let s:definitions[a:name] = cdef | |
| line 12: endif | |
| line 13: let s:types_dirty = 1 | |
| function tcomment#DefineType returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 596: | |
| line 597: " :doc: | |
| line 598: " A dictionary of NAME => COMMENT DEFINITION (see |tcomment#DefineType|) | |
| line 599: " that can be set in vimrc to override tcomment's default comment | |
| line 600: " styles. | |
| line 601: " :read: let g:tcomment_types = {} "{{{2 | |
| line 602: if exists('g:tcomment_types') | |
| line 603: for [s:name, s:def] in items(g:tcomment_types) | |
| line 604: call tcomment#DefineType(s:name, s:def) | |
| line 605: endfor | |
| line 606: unlet! s:name s:def | |
| line 607: endif | |
| line 608: | |
| line 609: | |
| line 610: function! s:DefaultValue(option) | |
| line 617: | |
| line 618: | |
| line 619: function! s:Count(string, rx) | |
| line 622: | |
| line 623: | |
| line 624: function! s:Printf1(fmt, expr) | |
| line 632: | |
| line 633: | |
| line 634: let s:default_comments = s:DefaultValue('comments') | |
| calling function <SNR>42_DefaultValue('comments') | |
| line 1: exec 'let '. a:option .' = &'. a:option | |
| line 1: let comments = &comments | |
| line 2: exec 'set '. a:option .'&' | |
| line 2: set comments& | |
| line 3: exec 'let default = &'. a:option | |
| line 3: let default = &comments | |
| line 4: exec 'let &'. a:option .' = '. a:option | |
| line 4: let &comments = comments | |
| line 5: return default | |
| function <SNR>42_DefaultValue returning 's1:/*,mb:*,ex:*/,://,b:#,:%,:XCOMM,n:>,fb:-' | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 635: let s:default_comment_string = s:DefaultValue('commentstring') | |
| calling function <SNR>42_DefaultValue('commentstring') | |
| line 1: exec 'let '. a:option .' = &'. a:option | |
| line 1: let commentstring = &commentstring | |
| line 2: exec 'set '. a:option .'&' | |
| line 2: set commentstring& | |
| line 3: exec 'let default = &'. a:option | |
| line 3: let default = &commentstring | |
| line 4: exec 'let &'. a:option .' = '. a:option | |
| line 4: let &commentstring = commentstring | |
| line 5: return default | |
| function <SNR>42_DefaultValue returning '/*%s*/' | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 636: let s:null_comment_string = '%s' | |
| line 637: | |
| line 638: " tcomment#Comment(line1, line2, ?comment_mode, ?comment_anyway, ?args...) | |
| line 639: " args... are either: | |
| line 640: " 1. a list of key=value pairs where known keys are (see also | |
| line 641: " |g:tcommentOptions|): | |
| line 642: " as=STRING ... Use a specific comment definition | |
| line 643: " count=N ... Repeat the comment string N times | |
| line 644: " col=N ... Start the comment at column N (in block | |
| line 645: " mode; must be smaller than |indent()|) | |
| line 646: " mode=STRING ... See the notes below on the "comment_mode" argument | |
| line 647: " mode_extra=STRING ... Add to comment_mode | |
| line 648: " begin=STRING ... Comment prefix | |
| line 649: " end=STRING ... Comment postfix | |
| line 650: " middle=STRING ... Middle line comments in block mode | |
| line 651: " rxbeg=N ... Regexp to find the substring of "begin" | |
| line 652: " that should be multiplied by "count" | |
| line 653: " rxend=N ... The above for "end" | |
| line 654: " rxmid=N ... The above for "middle" | |
| line 655: " mixedindent=BOOL ... If true, allow use of mixed | |
| line 656: " characters for indentation | |
| line 657: " commentstring_rx ... A regexp format string that matches | |
| line 658: " commented lines (no new groups may be | |
| line 659: " introduced, the |regexp| is |\V|; % have | |
| line 660: " to be doubled); "commentstring", "begin" | |
| line 661: " and optionally "end" must be defined or | |
| line 662: " deducible. | |
| line 663: " whitespace ... Define whether commented text is | |
| line 664: " surrounded with whitespace; if | |
| line 665: " both ... surround with whitespace (default) | |
| line 666: " left ... keep whitespace on the left | |
| line 667: " right... keep whitespace on the right | |
| line 668: " no ... don't use whitespace | |
| line 669: " strip_whitespace ... Strip trailing whitespace: if 1 | |
| line 670: " (default), strip from empty lines only, | |
| line 671: " if 2, always strip whitespace; if 0, | |
| line 672: " don't strip any whitespace | |
| line 673: " postprocess_uncomment .. Run a |printf()| expression with 2 | |
| line 674: " placeholders on uncommented lines, e.g. | |
| line 675: " 'norm! %sgg=%sgg'. | |
| line 676: " 2. 1-2 values for: ?commentPrefix, ?commentPostfix | |
| line 677: " 3. a dictionary (internal use only) | |
| line 678: " | |
| line 679: " comment_mode (see also ¦g:tcommentModeExtra¦): | |
| line 680: " G ... guess the value of comment_mode | |
| line 681: " B ... block (use extra lines for the comment markers) | |
| line 682: " L ... lines | |
| line 683: " i ... maybe inline, guess | |
| line 684: " I ... inline | |
| line 685: " R ... right (comment the line right of the cursor) | |
| line 686: " v ... visual | |
| line 687: " o ... operator | |
| line 688: " C ... force comment | |
| line 689: " K ... comment only uncommented lines | |
| line 690: " U ... force uncomment (if U and C are present, U wins) | |
| line 691: " By default, each line in range will be commented by adding the comment | |
| line 692: " prefix and postfix. | |
| line 693: function! tcomment#Comment(beg, end, ...) | |
| line 914: | |
| line 915: | |
| line 916: if v:version >= 703 | |
| line 917: function! s:Strdisplaywidth(...) "{{{3 | |
| line 920: else | |
| line 921: function! s:Strdisplaywidth(string, ...) "{{{3 | |
| line 925: endif | |
| line 926: | |
| line 927: | |
| line 928: function! tcomment#MaybeReuseOptions(name) "{{{3 | |
| line 940: | |
| line 941: | |
| line 942: function! s:GetTempOption(name, default) "{{{3 | |
| line 949: | |
| line 950: | |
| line 951: function! tcomment#ResetOption() "{{{3 | |
| line 954: | |
| line 955: | |
| line 956: function! tcomment#SetOption(name, arg) "{{{3 | |
| line 971: | |
| line 972: | |
| line 973: function! s:GetStartEnd(beg, end, comment_mode) "{{{3 | |
| line 1023: | |
| line 1024: | |
| line 1025: function! s:SetWhitespaceMode(cdef) "{{{3 | |
| line 1069: | |
| line 1070: | |
| line 1071: function! s:RepeatCommentstring(cdef) "{{{3 | |
| line 1103: | |
| line 1104: | |
| line 1105: function! s:ParseArgs(beg, end, comment_mode, arglist) "{{{3 | |
| line 1116: | |
| line 1117: | |
| line 1118: function! s:ExtendCDef(beg, end, comment_mode, cdef, args) | |
| line 1144: | |
| line 1145: | |
| line 1146: function! tcomment#Operator(type, ...) "{{{3 | |
| line 1222: | |
| line 1223: | |
| line 1224: function! tcomment#OperatorLine(type) "{{{3 | |
| line 1228: | |
| line 1229: | |
| line 1230: function! tcomment#OperatorAnyway(type) "{{{3 | |
| line 1234: | |
| line 1235: | |
| line 1236: function! tcomment#OperatorLineAnyway(type) "{{{3 | |
| line 1240: | |
| line 1241: | |
| line 1242: " :display: tcomment#CommentAs(beg, end, comment_anyway, filetype, ?args...) | |
| line 1243: " Where args is either: | |
| line 1244: " 1. A count NUMBER | |
| line 1245: " 2. An args list (see the notes on the "args" argument of | |
| line 1246: " |tcomment#Comment()|) | |
| line 1247: " comment text as if it were of a specific filetype | |
| line 1248: function! tcomment#CommentAs(beg, end, comment_anyway, filetype, ...) | |
| line 1272: | |
| line 1273: | |
| line 1274: " collect all known comment types | |
| line 1275: " :nodoc: | |
| line 1276: function! tcomment#CollectFileTypes() | |
| line 1283: | |
| line 1284: call tcomment#CollectFileTypes() | |
| calling function tcomment#CollectFileTypes() | |
| line 1: if s:types_dirty | |
| line 2: let s:types = keys(s:definitions) | |
| line 3: let s:types_rx = '\V\^\('. join(s:types, '\|') .'\)\(\u\.\*\)\?\$' | |
| line 4: let s:types_dirty = 0 | |
| line 5: endif | |
| function tcomment#CollectFileTypes returning #0 | |
| continuing in /home/rpietro/dotfiles/vim/.vim/autoload/tcomment.vim | |
| line 1285: | |
| line 1286: | |
| line 1287: " return a list of filetypes for which a tcomment_{&ft} is defined | |
| line 1288: " :nodoc: | |
| line 1289: function! tcomment#Complete(ArgLead, CmdLine, CursorPos) "{{{3 | |
| line 1303: | |
| line 1304: | |
| line 1305: let s:first_completion = 0 | |
| line 1306: | |
| line 1307: " :nodoc: | |
| line 1308: function! tcomment#CompleteArgs(ArgLead, CmdLine, CursorPos) "{{{3 | |
| line 1323: | |
| line 1324: | |
| line 1325: function! s:EncodeCommentPart(string) | |
| line 1328: | |
| line 1329: | |
| line 1330: function! s:GetCommentDefinitionForType(beg, end, comment_mode, filetype) "{{{3 | |
| line 1343: | |
| line 1344: | |
| line 1345: " s:GetCommentDefinition(beg, end, comment_mode, ?filetype="") | |
| line 1346: function! s:GetCommentDefinition(beg, end, comment_mode, ...) | |
| line 1384: | |
| line 1385: | |
| line 1386: function! s:StartPosRx(comment_mode, line, col) | |
| line 1396: | |
| line 1397: | |
| line 1398: function! s:EndPosRx(comment_mode, lnum, col) | |
| line 1406: | |
| line 1407: | |
| line 1408: function! s:StartLineRx(pos) | |
| line 1411: | |
| line 1412: | |
| line 1413: function! s:EndLineRx(pos) | |
| line 1416: | |
| line 1417: | |
| line 1418: function! s:StartColRx(comment_mode, col, ...) | |
| line 1437: | |
| line 1438: | |
| line 1439: function! s:EndColRx(comment_mode, lnum, pos) | |
| line 1456: | |
| line 1457: | |
| line 1458: function! s:CommentDef(beg, end, checkRx, comment_mode, cbeg, cend) | |
| line 1522: | |
| line 1523: | |
| line 1524: function! s:ProcessLine(comment_do, match, checkRx, replace) | |
| line 1597: | |
| line 1598: | |
| line 1599: function! s:ReplaceInLine(text) "{{{3 | |
| line 1607: | |
| line 1608: | |
| line 1609: function! s:UnreplaceInLine(text) "{{{3 | |
| line 1617: | |
| line 1618: | |
| line 1619: function! s:DoReplacements(text, tokens, replacements) "{{{3 | |
| line 1630: | |
| line 1631: | |
| line 1632: function! s:InlineReplacement(text, rx, tokens, replacements) "{{{3 | |
| line 1650: | |
| line 1651: | |
| line 1652: function! s:CommentBlock(beg, end, cbeg, cend, comment_mode, comment_do, checkRx, cdef) | |
| line 1749: | |
| line 1750: | |
| line 1751: function! s:Filetype(...) "{{{3 | |
| line 1776: | |
| line 1777: | |
| line 1778: function! s:AltFiletype(filetype) "{{{3 | |
| line 1803: | |
| line 1804: | |
| line 1805: " A function that makes the s:GuessFileType() function usable for other | |
| line 1806: " library developers. | |
| line 1807: " | |
| line 1808: " The argument is a dictionary with the following keys: | |
| line 1809: " | |
| line 1810: " beg ................ (default = line(".")) | |
| line 1811: " end ................ (default = line(".")) | |
| line 1812: " comment_mode ........ (default = "G") | |
| line 1813: " filetype ........... (default = &filetype) | |
| line 1814: " fallbackFiletype ... (default = "") | |
| line 1815: " | |
| line 1816: " This function return a dictionary that contains information about how | |
| line 1817: " to make comments. The information about the filetype of the text | |
| line 1818: " between lines "beg" and "end" is in the "filetype" key of the return | |
| line 1819: " value. It returns the first discernible filetype it encounters. | |
| line 1820: " :display: tcomment#GuessFileType(?options={}) | |
| line 1821: function! tcomment#GuessCommentType(...) "{{{3 | |
| line 1830: | |
| line 1831: | |
| line 1832: " inspired by Meikel Brandmeyer's EnhancedCommentify.vim | |
| line 1833: " this requires that a syntax names are prefixed by the filetype name | |
| line 1834: " s:GuessFileType(beg, end, comment_mode, filetype, ?fallbackFiletype) | |
| line 1835: function! s:GuessFileType(beg, end, comment_mode, filetype, ...) | |
| line 1931: | |
| line 1932: | |
| line 1933: function! s:GetSyntaxName(lnum, col) "{{{3 | |
| line 1945: | |
| line 1946: | |
| line 1947: function! s:AddModeExtra(comment_mode, extra, beg, end) "{{{3 | |
| line 1968: | |
| line 1969: | |
| line 1970: function! s:GuessCommentMode(comment_mode, supported_comment_modes) "{{{3 | |
| line 1987: | |
| line 1988: | |
| line 1989: function! s:GuessVimOptionsCommentString(comment_mode) | |
| line 2030: | |
| line 2031: | |
| line 2032: function! s:ConstructFromCommentsOption(comment_mode) | |
| line 2062: | |
| line 2063: | |
| line 2064: function! s:ExtractCommentsPart() | |
| line 2088: | |
| line 2089: | |
| line 2090: " s:GuessCustomCommentString(ft, comment_mode, ?default="", ?default_cdef={}) | |
| line 2091: function! s:GuessCustomCommentString(ft, comment_mode, ...) | |
| line 2130: | |
| line 2131: | |
| line 2132: function! s:GetCommentReplace(cdef, cms0) | |
| line 2141: | |
| line 2142: | |
| line 2143: function! s:BlockGetCommentRx(cdef) | |
| line 2152: | |
| line 2153: | |
| line 2154: function! s:BlockGetCommentString(cdef) | |
| line 2161: | |
| line 2162: | |
| line 2163: function! s:BlockGetMiddleString(cdef) | |
| line 2170: | |
| line 2171: | |
| line 2172: function! tcomment#TextObjectInlineComment() "{{{3 | |
| line 2191: | |
| line 2192: | |
| line 2193: " vi: ft=vim:tw=72:ts=4:fo=w2croql | |
| finished sourcing /home/rpietro/.vim/autoload/tcomment.vim | |
| calling function tcomment#Comment(1, 1, 'i', '') | |
| line 1: let comment_mode0 = s:AddModeExtra((a:0 >= 1 ? a:1 : 'G'), g:tcommentModeExtra, a:beg, a:end) | |
| calling function tcomment#Comment[1]..<SNR>42_AddModeExtra('i', '', 1, 1) | |
| line 1: " TLogVAR a:comment_mode, a:extra | |
| line 2: if a:beg == a:end | |
| line 3: let extra = substitute(a:extra, '\C[B]', '', 'g') | |
| line 4: else | |
| line 5: let extra = substitute(a:extra, '\C[IR]', '', 'g') | |
| line 6: endif | |
| line 7: let comment_mode = a:comment_mode | |
| line 8: if extra =~# 'B' | |
| line 9: let comment_mode = substitute(comment_mode, '\c[gir]', '', 'g') | |
| line 10: endif | |
| line 11: if extra =~# '[IR]' | |
| line 12: let comment_mode = substitute(comment_mode, '\c[gb]', '', 'g') | |
| line 13: endif | |
| line 14: if extra =~# '[BLIRK]' && comment_mode =~# 'G' | |
| line 15: let comment_mode = substitute(comment_mode, '\c[G]', '', 'g') | |
| line 16: endif | |
| line 17: let rv = comment_mode . extra | |
| line 18: " TLogVAR a:comment_mode, a:extra, comment_mode, extra, rv | |
| line 19: return rv | |
| function tcomment#Comment[1]..<SNR>42_AddModeExtra returning 'i' | |
| continuing in function tcomment#Comment | |
| line 2: let comment_mode = comment_mode0 | |
| line 3: let comment_anyway = a:0 >= 2 ? (a:2 == '!') : 0 | |
| line 4: " TLogVAR a:beg, a:end, comment_mode, comment_anyway, a:000 | |
| line 5: " save the cursor position | |
| line 6: if exists('w:tcomment_pos') | |
| line 7: let s:current_pos = copy(w:tcomment_pos) | |
| line 8: else | |
| line 9: let s:current_pos = getpos('.') | |
| line 10: endif | |
| line 11: " echom "DBG current_pos=" string(s:current_pos) | |
| line 12: let cursor_pos = getpos("'>") | |
| line 13: " TLogVAR cursor_pos | |
| line 14: let s:cursor_pos = [] | |
| line 15: if comment_mode =~# 'i' | |
| line 16: let blnum = line("'<") | |
| line 17: if blnum == line("'>") | |
| line 18: if virtcol('.') <= indent(blnum) | |
| line 19: let i_mode = 'G' | |
| line 20: else | |
| line 21: let i_mode = 'I' | |
| line 22: endif | |
| line 23: else | |
| line 24: let i_mode = 'G' | |
| line 25: endif | |
| line 26: let comment_mode = substitute(comment_mode, '\Ci', i_mode, 'g') | |
| line 27: " TLogVAR 1, comment_mode | |
| line 28: endif | |
| line 29: let [lbeg, cbeg, lend, cend] = s:GetStartEnd(a:beg, a:end, comment_mode) | |
| calling function tcomment#Comment[29]..<SNR>42_GetStartEnd(1, 1, 'I') | |
| line 1: " TLogVAR a:beg, a:end, a:comment_mode | |
| line 2: if type(a:beg) == 3 | |
| line 3: let [lbeg, cbeg] = a:beg | |
| line 4: let [lend, cend] = a:end | |
| line 5: else | |
| line 6: let lbeg = a:beg | |
| line 7: let lend = a:end | |
| line 8: let comment_mode = a:comment_mode | |
| line 9: " TLogVAR comment_mode | |
| line 10: if comment_mode =~# 'R' | |
| line 11: let cbeg = virtcol('.') | |
| line 12: let cend = virtcol('$') | |
| line 13: let comment_mode = substitute(comment_mode, '\CR', 'G', 'g') | |
| line 14: " TLogVAR 'R', cbeg, cend, comment_mode | |
| line 15: elseif comment_mode =~# 'I' | |
| line 16: let cbeg = virtcol("'<") | |
| line 17: if cbeg == 0 | |
| line 18: let cbeg = virtcol('.') | |
| line 19: endif | |
| line 20: let cend = virtcol("'>") | |
| line 21: if cend < virtcol('$') && (comment_mode =~# 'o' || &selection == 'inclusive') | |
| line 22: let cend += 1 | |
| line 23: " TLogVAR cend, virtcol('$') | |
| line 24: endif | |
| line 25: " TLogVAR 'I', cbeg, cend, comment_mode | |
| line 26: else | |
| line 27: let cbeg = -1 | |
| line 28: let cend = 0 | |
| line 29: for lnum in range(a:beg, a:end) | |
| line 30: if getline(lnum) =~ '\S' | |
| line 31: let indentwidth = indent(lnum) | |
| line 32: " TLogVAR cbeg, lnum, indentwidth, getline(lnum) | |
| line 33: if cbeg == -1 || indentwidth < cbeg | |
| line 34: let cbeg = indentwidth | |
| line 35: endif | |
| line 36: endif | |
| line 37: endfor | |
| line 38: if cbeg == -1 | |
| line 39: let cbeg = 0 | |
| line 40: endif | |
| line 41: endif | |
| line 42: endif | |
| line 43: " TLogVAR lbeg, cbeg, lend, cend | |
| line 44: if lend < lbeg || (lend == lbeg && cend > 0 && cend < cbeg) | |
| line 45: return [lend, cend, lbeg, cbeg] | |
| line 46: else | |
| line 47: return [lbeg, cbeg, lend, cend] | |
| function tcomment#Comment[29]..<SNR>42_GetStartEnd returning [1, 1, 1, 1] | |
| continuing in function tcomment#Comment | |
| line 30: " TLogVAR lbeg, cbeg, lend, cend, virtcol('$') | |
| line 31: if comment_mode ==? 'I' && comment_mode0 =~# 'i' && lbeg == lend && cend >= virtcol('$') - 1 | |
| line 32: let comment_mode = substitute(comment_mode, '\CI', cbeg <= 1 ? 'G' : 'R', 'g') | |
| line 33: " TLogVAR comment_mode | |
| line 34: endif | |
| line 35: let mode_extra = s:GetTempOption('mode_extra', '') | |
| calling function tcomment#Comment[35]..<SNR>42_GetTempOption('mode_extra', '') | |
| line 1: if exists('s:temp_options') && has_key(s:temp_options, a:name) | |
| line 2: return s:temp_options[a:name] | |
| line 3: else | |
| line 4: return a:default | |
| function tcomment#Comment[35]..<SNR>42_GetTempOption returning '' | |
| continuing in function tcomment#Comment | |
| line 36: " TLogVAR mode_extra | |
| line 37: if !empty(mode_extra) | |
| line 38: let comment_mode = s:AddModeExtra(comment_mode, mode_extra, lbeg, lend) | |
| line 39: " TLogVAR "mode_extra", comment_mode | |
| line 40: unlet s:temp_options.mode_extra | |
| line 41: endif | |
| line 42: " get the correct commentstring | |
| line 43: let cdef = copy(g:tcommentOptions) | |
| line 44: " TLogVAR 1, cdef | |
| line 45: if exists('b:tcommentOptions') | |
| line 46: let cdef = extend(cdef, copy(b:tcommentOptions)) | |
| line 47: " TLogVAR 2, cdef | |
| line 48: endif | |
| line 49: if a:0 >= 3 && type(a:3) == 4 | |
| line 50: call extend(cdef, a:3) | |
| line 51: " TLogVAR 3, cdef | |
| line 52: else | |
| line 53: let cdef0 = s:GetCommentDefinition(lbeg, lend, comment_mode) | |
| calling function tcomment#Comment[53]..<SNR>42_GetCommentDefinition(1, 1, 'I') | |
| line 1: let ft = a:0 >= 1 ? a:1 : '' | |
| line 2: " TLogVAR a:comment_mode, ft | |
| line 3: if ft != '' | |
| line 4: let cdef = s:GuessCustomCommentString(ft, a:comment_mode) | |
| line 5: else | |
| line 6: let cdef = {'mode': a:comment_mode} | |
| line 7: endif | |
| line 8: " TLogVAR cdef | |
| line 9: let cms = get(cdef, 'commentstring', '') | |
| line 10: if empty(cms) | |
| line 11: let filetype = s:Filetype(ft) | |
| calling function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[11]..<SNR>42_Filetype('') | |
| line 1: let ft = a:0 >= 1 && !empty(a:1) ? a:1 : &filetype | |
| line 2: let pos = a:0 >= 2 ? a:2 : 0 | |
| line 3: " TLogVAR ft, pos | |
| line 4: let fts = split(ft, '^\@!\.') | |
| line 5: " TLogVAR fts | |
| line 6: " let ft = substitute(ft, '\..*$', '', '') | |
| line 7: let rv = get(fts, pos, ft) | |
| line 8: " TLogVAR fts, rv | |
| line 9: if !exists('s:filetype_map_rx') | |
| line 10: let fts_rx = '^'. join(map(keys(g:tcomment#filetype_map), 'escape(v:val, ''\'')'), '\|') .'$' | |
| line 11: endif | |
| line 12: " TLogVAR fts_rx | |
| line 13: if rv =~ fts_rx | |
| line 14: for [ft_rx, ftrv] in items(g:tcomment#filetype_map) | |
| line 15: " TLogVAR ft_rx, ftrv | |
| line 16: if rv =~ ft_rx | |
| line 17: let rv = substitute(rv, ft_rx, ftrv, '') | |
| line 18: " TLogVAR rv | |
| line 19: break | |
| line 20: endif | |
| line 21: endfor | |
| line 22: endif | |
| line 23: return rv | |
| function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[11]..<SNR>42_Filetype returning 'markdown' | |
| continuing in function tcomment#Comment[53]..<SNR>42_GetCommentDefinition | |
| line 12: if exists('b:commentstring') | |
| line 13: let cms = b:commentstring | |
| line 14: " TLogVAR 1, cms | |
| line 15: return s:GuessCustomCommentString(filetype, a:comment_mode, cms) | |
| line 16: elseif exists('b:commentStart') && b:commentStart != '' | |
| line 17: let cms = s:EncodeCommentPart(b:commentStart) .' %s' | |
| line 18: " TLogVAR 2, cms | |
| line 19: if exists('b:commentEnd') && b:commentEnd != '' | |
| line 20: let cms = cms .' '. s:EncodeCommentPart(b:commentEnd) | |
| line 21: endif | |
| line 22: return s:GuessCustomCommentString(filetype, a:comment_mode, cms) | |
| line 23: else | |
| line 24: let [use_guess_ft, altFiletype] = s:AltFiletype(ft) | |
| calling function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[24]..<SNR>42_AltFiletype('') | |
| line 1: let filetype = empty(a:filetype) ? &filetype : a:filetype | |
| line 2: " TLogVAR a:filetype, filetype | |
| line 3: if g:tcommentGuessFileType || (exists('g:tcommentGuessFileType_'. filetype) && g:tcommentGuessFileType_{filetype} =~ '[^0]') | |
| line 5: if g:tcommentGuessFileType_{filetype} == 1 | |
| line 6: if filetype =~ '^.\{-}\..\+$' | |
| line 7: let altFiletype = s:Filetype(filetype, 1) | |
| line 8: else | |
| line 9: let altFiletype = '' | |
| line 10: endif | |
| line 11: else | |
| line 12: let altFiletype = g:tcommentGuessFileType_{filetype} | |
| line 13: endif | |
| line 14: " TLogVAR 1, altFiletype | |
| line 15: return [1, altFiletype] | |
| line 16: elseif filetype =~ '^.\{-}\..\+$' | |
| line 17: let altFiletype = s:Filetype(filetype, 1) | |
| line 18: " TLogVAR 2, altFiletype | |
| line 19: return [1, altFiletype] | |
| line 20: else | |
| line 21: " TLogVAR 3, '' | |
| line 22: return [0, ''] | |
| function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[24]..<SNR>42_AltFiletype returning [0, ''] | |
| continuing in function tcomment#Comment[53]..<SNR>42_GetCommentDefinition | |
| line 25: " TLogVAR use_guess_ft, altFiletype | |
| line 26: if use_guess_ft | |
| line 27: return s:GuessFileType(a:beg, a:end, a:comment_mode, filetype, altFiletype) | |
| line 28: else | |
| line 29: let guess_cdef = s:GuessVimOptionsCommentString(a:comment_mode) | |
| calling function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[29]..<SNR>42_GuessVimOptionsCommentString('I') | |
| line 1: " TLogVAR a:comment_mode | |
| line 2: let valid_cms = (match(&commentstring, '%\@<!\(%%\)*%s') != -1) | |
| line 3: let ccmodes = 'r' | |
| line 4: if &commentstring =~ '\S\s*%s\s*\S' | |
| line 5: let ccmodes .= 'bi' | |
| line 6: endif | |
| line 7: let guess_comment_mode = s:GuessCommentMode(a:comment_mode, ccmodes) | |
| calling function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[29]..<SNR>42_GuessVimOptionsCommentString[7]..<SNR>42_GuessCommentMode('I', 'r') | |
| line 1: " TLogVAR a:comment_mode, a:supported_comment_modes | |
| line 2: let special = substitute(a:comment_mode, '\c[^ukc]', '', 'g') | |
| line 3: let cmode = tolower(a:comment_mode) | |
| line 4: let ccmodes = split(tolower(a:supported_comment_modes), '\zs') | |
| line 5: let ccmodes = filter(ccmodes, 'stridx(cmode, v:val) != -1') | |
| line 6: let guess = substitute(a:comment_mode, '\w\+', 'G', 'g') | |
| line 7: " TLogVAR ccmodes, guess | |
| line 8: if a:comment_mode =~# '[BR]' | |
| line 9: let rv = !empty(ccmodes) ? a:comment_mode : guess | |
| line 10: elseif a:comment_mode =~# '[I]' | |
| line 11: let rv = !empty(ccmodes) ? a:comment_mode : '' | |
| line 12: else | |
| line 13: let rv = guess | |
| line 14: endif | |
| line 15: return s:AddModeExtra(rv, special, 0, 1) | |
| calling function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[29]..<SNR>42_GuessVimOptionsCommentString[7]..<SNR>42_GuessCommentMode[15]..<SNR>42_AddModeExtra('', '', 0, 1) | |
| line 1: " TLogVAR a:comment_mode, a:extra | |
| line 2: if a:beg == a:end | |
| line 3: let extra = substitute(a:extra, '\C[B]', '', 'g') | |
| line 4: else | |
| line 5: let extra = substitute(a:extra, '\C[IR]', '', 'g') | |
| line 6: endif | |
| line 7: let comment_mode = a:comment_mode | |
| line 8: if extra =~# 'B' | |
| line 9: let comment_mode = substitute(comment_mode, '\c[gir]', '', 'g') | |
| line 10: endif | |
| line 11: if extra =~# '[IR]' | |
| line 12: let comment_mode = substitute(comment_mode, '\c[gb]', '', 'g') | |
| line 13: endif | |
| line 14: if extra =~# '[BLIRK]' && comment_mode =~# 'G' | |
| line 15: let comment_mode = substitute(comment_mode, '\c[G]', '', 'g') | |
| line 16: endif | |
| line 17: let rv = comment_mode . extra | |
| line 18: " TLogVAR a:comment_mode, a:extra, comment_mode, extra, rv | |
| line 19: return rv | |
| function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[29]..<SNR>42_GuessVimOptionsCommentString[7]..<SNR>42_GuessCommentMode[15]..<SNR>42_AddModeExtra returning '' | |
| continuing in function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[29]..<SNR>42_GuessVimOptionsCommentString[7]..<SNR>42_GuessCommentMode | |
| function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[29]..<SNR>42_GuessVimOptionsCommentString[7]..<SNR>42_GuessCommentMode returning '' | |
| continuing in function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[29]..<SNR>42_GuessVimOptionsCommentString | |
| line 8: " TLogVAR guess_comment_mode | |
| line 9: if &commentstring != s:default_comment_string && valid_cms | |
| line 10: " The &commentstring appears to have been set and to be valid | |
| line 11: let cdef = copy(g:tcomment#options_commentstring) | |
| line 12: let cdef.mode = guess_comment_mode | |
| line 13: let cdef.commentstring = &commentstring | |
| line 14: return cdef | |
| function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[29]..<SNR>42_GuessVimOptionsCommentString returning {'commentstring': '> %s', 'mode': '', 'whitespace': 'both'} | |
| continuing in function tcomment#Comment[53]..<SNR>42_GetCommentDefinition | |
| line 30: " TLogVAR guess_cdef | |
| line 31: return s:GuessCustomCommentString(filetype, a:comment_mode, guess_cdef.commentstring, guess_cdef) | |
| calling function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[31]..<SNR>42_GuessCustomCommentString('markdown', 'I', '> %s', {'commentstring': '> %s', 'mode': '', 'whitespace': 'both'}) | |
| line 1: " TLogVAR a:ft, a:comment_mode, a:000 | |
| line 2: let comment_mode = a:comment_mode | |
| line 3: let custom_comment = tcomment#TypeExists(a:ft) | |
| calling function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[31]..<SNR>42_GuessCustomCommentString[3]..tcomment#TypeExists('markdown') | |
| line 1: let comment_mode = a:0 >= 1 ? a:1 : '' | |
| line 2: let name = a:name | |
| line 3: if comment_mode =~? 'b' | |
| line 4: let name .= '_block' | |
| line 5: elseif comment_mode =~? 'i' | |
| line 6: let name .= '_inline' | |
| line 7: endif | |
| line 8: return has_key(s:definitions, name) ? name : '' | |
| function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[31]..<SNR>42_GuessCustomCommentString[3]..tcomment#TypeExists returning '' | |
| continuing in function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[31]..<SNR>42_GuessCustomCommentString | |
| line 4: let custom_comment_mode = tcomment#TypeExists(a:ft, comment_mode) | |
| calling function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[31]..<SNR>42_GuessCustomCommentString[4]..tcomment#TypeExists('markdown', 'I') | |
| line 1: let comment_mode = a:0 >= 1 ? a:1 : '' | |
| line 2: let name = a:name | |
| line 3: if comment_mode =~? 'b' | |
| line 4: let name .= '_block' | |
| line 5: elseif comment_mode =~? 'i' | |
| line 6: let name .= '_inline' | |
| line 7: endif | |
| line 8: return has_key(s:definitions, name) ? name : '' | |
| function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[31]..<SNR>42_GuessCustomCommentString[4]..tcomment#TypeExists returning '' | |
| continuing in function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[31]..<SNR>42_GuessCustomCommentString | |
| line 5: let supported_comment_mode = !empty(custom_comment_mode) ? comment_mode : '' | |
| line 6: " TLogVAR custom_comment, custom_comment_mode | |
| line 7: let default = a:0 >= 1 ? a:1 : '' | |
| line 8: let default_cdef = a:0 >= 2 ? a:2 : {} | |
| line 9: let default_supports_comment_mode = get(default_cdef, 'comment_mode', custom_comment_mode) | |
| line 10: " TLogVAR default, default_supports_comment_mode | |
| line 11: if comment_mode =~# '[ILB]' && !empty(custom_comment_mode) | |
| line 12: let def = tcomment#GetCommentDef(custom_comment_mode) | |
| line 13: " TLogVAR 1, def | |
| line 14: elseif !empty(custom_comment) | |
| line 15: let def = tcomment#GetCommentDef(custom_comment) | |
| line 16: let comment_mode = s:GuessCommentMode(comment_mode, supported_comment_mode) | |
| line 17: " TLogVAR 3, def, comment_mode | |
| line 18: elseif !empty(default) | |
| line 19: if empty(default_cdef) | |
| line 20: let def = {'commentstring': default} | |
| line 21: else | |
| line 22: let def = default_cdef | |
| line 23: endif | |
| line 24: let comment_mode = s:GuessCommentMode(comment_mode, default_supports_comment_mode) | |
| calling function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[31]..<SNR>42_GuessCustomCommentString[24]..<SNR>42_GuessCommentMode('I', '') | |
| line 1: " TLogVAR a:comment_mode, a:supported_comment_modes | |
| line 2: let special = substitute(a:comment_mode, '\c[^ukc]', '', 'g') | |
| line 3: let cmode = tolower(a:comment_mode) | |
| line 4: let ccmodes = split(tolower(a:supported_comment_modes), '\zs') | |
| line 5: let ccmodes = filter(ccmodes, 'stridx(cmode, v:val) != -1') | |
| line 6: let guess = substitute(a:comment_mode, '\w\+', 'G', 'g') | |
| line 7: " TLogVAR ccmodes, guess | |
| line 8: if a:comment_mode =~# '[BR]' | |
| line 9: let rv = !empty(ccmodes) ? a:comment_mode : guess | |
| line 10: elseif a:comment_mode =~# '[I]' | |
| line 11: let rv = !empty(ccmodes) ? a:comment_mode : '' | |
| line 12: else | |
| line 13: let rv = guess | |
| line 14: endif | |
| line 15: return s:AddModeExtra(rv, special, 0, 1) | |
| calling function tcomment#Comment[53]..<SNR>42_GetCommentDefinition[31]..<SNR>42_Gu |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment