/
tcomment.txt
669 lines (539 loc) · 31 KB
/
tcomment.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
*tcomment.txt* An easily extensible & universal comment plugin
Author: Thomas Link, micathom AT gmail com?subject=vim
tcomment provides easy to use, file-type sensible comments for Vim. It
can handle embedded syntax.
TComment works like a toggle, i.e., it will comment out text that
contains uncommented lines, and it will remove comment markup for
already commented text (i.e. text that contains no uncommented lines).
If the file-type is properly defined, TComment will figure out which
comment string to use. Otherwise you use |tcomment#type#Define()| to
override the default choice.
TComment can properly handle an embedded syntax, e.g., ruby/python/perl
regions in vim scripts, HTML or JavaScript in php code etc.
tcomment favours the use of line-wise comment styles. This implies that usually
whole line will be commented out. tcomment also knows block-style and inline
comments that can be used via special maps (see below) or the |:TCommentAs|
command.
Demo:
http://vimsomnia.blogspot.com/2010/11/tcomment-vim-plugin.html
*tcomment-maps*
Key bindings~
Most of the time the default toggle keys will do what you want (or to be
more precise: what I think you want it to do ;-).
*tcomment-operator*
As operator (the prefix can be customized via |g:tcomment_opleader1|):
gc{motion} :: Toggle comments (for small comments within one line
the &filetype_inline style will be used, if
defined)
gc<Count>c{motion} :: Toggle comment with count argument
(see |tcomment#Comment()|)
gcc :: Toggle comment for the current line
Force line-wise operation:
gC{motion} :: Toggle comments by line
gC<Count>c{motion} :: Toggle comment by line with count argument
(see |tcomment#Comment()|)
Explicit commenting/uncommenting:
g<{motion} :: Uncomment region
g<c :: Uncomment the current line
g<b :: Uncomment the current region as block
g>{motion} :: Comment region
g>c :: Comment the current line
g>b :: Comment the current region as block
In visual mode:
gc :: Toggle comments
g> :: Comment selected text
CAVEAT: If you visually select text within a line, the visual mode map will
comment out the selected text. If you selected text across several lines, the
visual mode map will assume though that you wanted to comment out lines --
since this is how many vim maps work. In order to make tcomment use e.g. inline
comments anyway, use the <c-_>i map -- see below.
By default the cursor stays put. If you want the cursor to the end of
the commented text, set |g:tcomment#operator#mode_extra| to '>' (but this may not
work properly with exclusive motions).
Primary key maps for normal and insert mode (see also |g:tcomment_mapleader1|):
<c-_><c-_> :: :TComment
<c-_><space> :: :TComment <QUERY COMMENT-BEGIN ?COMMENT-END>
<c-_>b :: :TCommentBlock
In insert mode, the cursor will be positioned inside
the comment. In normal mode, the cursor will stay
put.
<c-_>a :: :TCommentAs <QUERY COMMENT TYPE>
<c-_>n :: :TCommentAs &filetype <QUERY COUNT>
<c-_>s :: :TCommentAs &filetype_<QUERY COMMENT SUBTYPE>
<c-_>i :: :TCommentInline (in normal and insert mode, this map will
create an empty inline comment, which isn't suitable for
all filetypes though)
In insert mode, the cursor will be positioned inside
the comment. In normal mode, the cursor will stay
put.
<c-_>r :: :TCommentRight
<c-_>p :: Comment the current inner paragraph
<c-_><Count> :: Set the count argument (a number from 1 to 9) for use with
the subsequent tcomment map/command (see
|tcomment#Comment()|)
E.g. in JavaScript, in order to get an empty /** */
comment for documentation purposes, in insert mode type
<c-_>2<c-_>i
In order to get an empty block comment like >
/**
*
*/
< type <c-_>2<c-_>b
Most of the above maps are also available in visual mode.
A secondary set of key maps is defined for normal and insert mode (see also
|g:tcomment_mapleader2|):
<Leader>__ :: :TComment
<Leader>_p :: Comment the current inner paragraph
<Leader>_<space> :: :TComment <QUERY COMMENT-BEGIN ?COMMENT-END>
<Leader>_i :: :TCommentInline
<Leader>_r :: :TCommentRight
<Leader>_b :: :TCommentBlock
<Leader>_a :: :TCommentAs <QUERY COMMENT TYPE>
<Leader>_n :: :TCommentAs &filetype <QUERY COUNT>
<Leader>_s :: :TCommentAs &filetype_<QUERY COMMENT SUBTYPE>
... and for select mode:
<Leader>__ :: :TComment
<Leader>_i :: :TCommentInline
-----------------------------------------------------------------------
*tcomment-new-filetype* *tcomment-debug*
Adding a new filetype~
If tcomment doesn't know a filetype, it makes use of 'commentstring' or
'comments'. If the result still does not satisfy your needs, you might have to
add a custom filetype definition. This could be done in a file like
`autoload/tcomment/types/mytypes.vim` somewhere in your 'runtimepath', which
will be loaded on startup.
New comment types can be defined via the |tcomment#type#Define()| function. If
the file may contain embedded code of another filetype, you might also want to
set `g:tcomment#filetype#guess_{FILETYPE}` to 1 or the name of a default
fallback filetype.
If nothing helps:
1. Make sure 'filetype' is set correctly.
2. Place the cursor at an appropriate position -- e.g. the first non-blank
character of a line of code.
3. Call |tcomment#debug#CollectInfo()|.
4. File an issue on github and post the output of `:call
tcomment#debug#CollectInfo()`. The output will also be copied to the
clipboard.
If this still doesn't help, please install tlib
(https://github.com/tomtom/tlib_vim), please try:
Tlibtraceset --file=tcomment.log +tcomment
Then comment out the text in question and send me the log file.
-----------------------------------------------------------------------
Install~
Either use the zip archive:
- Download the zip archive
- Extract it to `~/.vim/pack/tml/start/tcomment`
or install from github:
- Start a terminal
- Change the working directory to `~/.vim/pack/tml/start/`
- Type: `git clone https://github.com/tomtom/tcomment_vim`
NOTE: If you don't want to run this plugin on startup, use
`~/.vim/pack/tml/opt/`.
NOTE: On Windows, ~/.vim might be ~/vimfiles. Please see 'runtimepath' for
details.
========================================================================
Contents~
g:tcomment_maps ............................... |g:tcomment_maps|
g:tcomment_mapleader1 ......................... |g:tcomment_mapleader1|
g:tcomment_mapleader2 ......................... |g:tcomment_mapleader2|
g:tcomment_opleader1 .......................... |g:tcomment_opleader1|
g:tcomment_mapleader_uncomment_anyway ......... |g:tcomment_mapleader_uncomment_anyway|
g:tcomment_mapleader_comment_anyway ........... |g:tcomment_mapleader_comment_anyway|
g:tcomment_map_modifier ....................... |g:tcomment_map_modifier|
g:tcomment_opmap_modifier ..................... |g:tcomment_opmap_modifier|
:TComment ..................................... |:TComment|
:TCommentAs ................................... |:TCommentAs|
:TCommentRight ................................ |:TCommentRight|
:TCommentBlock ................................ |:TCommentBlock|
:TCommentInline ............................... |:TCommentInline|
:TCommentMaybeInline .......................... |:TCommentMaybeInline|
g:tcomment#blank_lines ........................ |g:tcomment#blank_lines|
g:tcomment#rstrip_on_uncomment ................ |g:tcomment#rstrip_on_uncomment|
g:tcomment#mode_extra ......................... |g:tcomment#mode_extra|
g:tcomment#options ............................ |g:tcomment#options|
g:tcomment#options_comments ................... |g:tcomment#options_comments|
g:tcomment#options_commentstring .............. |g:tcomment#options_commentstring|
g:tcomment#ignore_char_type ................... |g:tcomment#ignore_char_type|
g:tcomment#replacements_c ..................... |g:tcomment#replacements_c|
g:tcomment#inline_fmt_c ....................... |g:tcomment#inline_fmt_c|
g:tcomment#block2_fmt_c ....................... |g:tcomment#block2_fmt_c|
g:tcomment#replacements_xml ................... |g:tcomment#replacements_xml|
g:tcomment#block_fmt_xml ...................... |g:tcomment#block_fmt_xml|
g:tcomment#inline_fmt_xml ..................... |g:tcomment#inline_fmt_xml|
g:tcomment#ignore_comment_def ................. |g:tcomment#ignore_comment_def|
g:tcomment#must_escape_expression_backslash ... |g:tcomment#must_escape_expression_backslash|
tcomment#GuessCommentType ..................... |tcomment#GuessCommentType()|
tcomment#Comment .............................. |tcomment#Comment()|
tcomment#CommentAs ............................ |tcomment#CommentAs()|
tcomment#commentdef#Get ....................... |tcomment#commentdef#Get()|
tcomment#commentdef#GetCustom ................. |tcomment#commentdef#GetCustom()|
g:tcomment#filetype#guess ..................... |g:tcomment#filetype#guess|
g:tcomment#filetype#guess_cpp ................. |g:tcomment#filetype#guess_cpp|
g:tcomment#filetype#guess_blade ............... |g:tcomment#filetype#guess_blade|
g:tcomment#filetype#guess_dsl ................. |g:tcomment#filetype#guess_dsl|
g:tcomment#filetype#guess_php ................. |g:tcomment#filetype#guess_php|
g:tcomment#filetype#ignore_php ................ |g:tcomment#filetype#ignore_php|
g:tcomment#filetype#syntax_map ................ |g:tcomment#filetype#syntax_map|
tcomment#filetype#Guess ....................... |tcomment#filetype#Guess()|
tcomment#filetype#GetAlt ...................... |tcomment#filetype#GetAlt()|
g:tcomment#operator#mode_extra ................ |g:tcomment#operator#mode_extra|
g:tcomment#syntax#substitute .................. |g:tcomment#syntax#substitute|
g:tcomment_types .............................. |g:tcomment_types|
tcomment#type#Define .......................... |tcomment#type#Define()|
tcomment#type#GetDefinition ................... |tcomment#type#GetDefinition()|
------------------------------------------------------------------------
*plugin/tcomment.vim*
*g:tcomment_maps*
g:tcomment_maps (default: 1)
If true, set maps.
*g:tcomment_mapleader1*
g:tcomment_mapleader1 (default: '<c-_>')
g:tcomment_mapleader1 should be a shortcut that can be used with
map, imap, vmap.
*g:tcomment_mapleader2*
g:tcomment_mapleader2 (default: '<Leader>_')
g:tcomment_mapleader2 should be a shortcut that can be used with
map, xmap.
*g:tcomment_opleader1*
g:tcomment_opleader1 (default: 'gc')
See |tcomment-operator|.
*g:tcomment_mapleader_uncomment_anyway*
g:tcomment_mapleader_uncomment_anyway (default: 'g<')
See |tcomment-operator|.
*g:tcomment_mapleader_comment_anyway*
g:tcomment_mapleader_comment_anyway (default: 'g>')
See |tcomment-operator|.
*g:tcomment_map_modifier*
g:tcomment_map_modifier (default: '<silent>')
Use map modifiers like |:map-<silent>|.
*g:tcomment_opmap_modifier*
g:tcomment_opmap_modifier (default: '<silent>')
Use map modifiers like |:map-<silent>| for operators.
*:TComment*
:[range]TComment[!] ?ARGS...
If there is a visual selection that begins and ends in the same line,
then |:TCommentInline| is used instead.
The optional range defaults to the current line. With a bang '!',
always comment the line.
ARGS... are either (see also |tcomment#Comment()|):
1. a list of key=value pairs
2. 1-2 values for: ?commentBegin, ?commentEnd
*:TCommentAs*
:[range]TCommentAs[!] commenttype ?ARGS...
TCommentAs requires g:tcomment_{filetype} to be defined.
With a bang '!', always comment the line.
ARGS... are either (see also |tcomment#Comment()|):
1. a list of key=value pairs
2. 1-2 values for: ?commentBegin, ?commentEnd
*:TCommentRight*
:[range]TCommentRight[!] ?ARGS...
Comment the text to the right of the cursor. If a visual selection was
made (be it block-wise or not), all lines are commented out at from
the current cursor position downwards.
With a bang '!', always comment the line.
ARGS... are either (see also |tcomment#Comment()|):
1. a list of key=value pairs
2. 1-2 values for: ?commentBegin, ?commentEnd
*:TCommentBlock*
:[range]TCommentBlock[!] ?ARGS...
Comment as "block", e.g. use the {&ft}_block comment style. The
commented text isn't indented or reformated.
With a bang '!', always comment the line.
ARGS... are either (see also |tcomment#Comment()|):
1. a list of key=value pairs
2. 1-2 values for: ?commentBegin, ?commentEnd
*:TCommentInline*
:[range]TCommentInline[!] ?ARGS...
Use the {&ft}_inline comment style.
With a bang '!', always comment the line.
ARGS... are either (see also |tcomment#Comment()|):
1. a list of key=value pairs
2. 1-2 values for: ?commentBegin, ?commentEnd
*:TCommentMaybeInline*
:[range]TCommentMaybeInline[!] ?ARGS...
With a bang '!', always comment the line.
ARGS... are either (see also |tcomment#Comment()|):
1. a list of key=value pairs
2. 1-2 values for: ?commentBegin, ?commentEnd
------------------------------------------------------------------------
*autoload/tcomment.vim*
*g:tcomment#blank_lines*
g:tcomment#blank_lines (default: 2)
If 1, comment blank lines too.
If 2, also comment blank lines within indented code blocks
(requires mixedindent -- see |tcomment#Comment()|).
*g:tcomment#rstrip_on_uncomment*
g:tcomment#rstrip_on_uncomment (default: 1)
If 1, remove right-hand whitespace on uncomment from empty lines.
If 2, remove right-hand whitespace on uncomment from all lines.
*g:tcomment#mode_extra*
g:tcomment#mode_extra (default: '')
Modifies how commenting works.
> ... Move the cursor to the end of the comment
>> ... Like above but move the cursor to the beginning of the next line
>| ... Like above but move the cursor to the next line
# ... Move the cursor to the position of the commented text
(NOTE: this only works when creating empty comments using
|:TCommentInline| from normal or insert mode and should
not be set here as a global option.)
*g:tcomment#options*
g:tcomment#options (default: {})
Other key-value options used by |tcomment#Comment()|.
If the buffer-local variable b:tcomment_options exists, it will be
used in addition.
Examples:
Put the opening comment marker always in the first column
regardless of the block's indentation, put this into your |vimrc|
file: >
let g:tcomment#options = {'col': 1}
< Indent uncommented lines: >
let g:tcomment#options = {'postprocess_uncomment': 'norm! %sgg=%sgg'}
<
*g:tcomment#options_comments*
g:tcomment#options_comments (default: {'whitespace': get(g:tcomment#options, 'whitespace', 'both')})
Additional args for |tcomment#Comment()| when using the 'comments'
option.
*g:tcomment#options_commentstring*
g:tcomment#options_commentstring (default: {'whitespace': get(g:tcomment#options, 'whitespace', 'both')})
Additional args for |tcomment#Comment()| when using the
'commentstring' option.
*g:tcomment#ignore_char_type*
g:tcomment#ignore_char_type (default: 1)
|text-objects| for use with |tcomment#operator#Op| can have different
types: line, block, char etc. Text objects like aB, it, at etc.
have type char but this may not work reliably. By default,
tcomment handles those text objects most often as if they were of
type line. Set this variable to 0 in order to change this
behaviour. Be prepared that the result may not always match your
intentions.
*g:tcomment#replacements_c*
g:tcomment#replacements_c (default: {...})
Replacements for c filetype.
*g:tcomment#inline_fmt_c*
g:tcomment#inline_fmt_c (default: {...})
Generic c-like comments.
*g:tcomment#block2_fmt_c*
g:tcomment#block2_fmt_c (default: {...})
Generic c-like block comments (alternative markup).
*g:tcomment#replacements_xml*
g:tcomment#replacements_xml (default: {...})
Replacements for xml filetype.
*g:tcomment#block_fmt_xml*
g:tcomment#block_fmt_xml (default: {...})
Generic xml-like block comments.
*g:tcomment#inline_fmt_xml*
g:tcomment#inline_fmt_xml (default: {...})
Generic xml-like comments.
*g:tcomment#ignore_comment_def*
g:tcomment#ignore_comment_def (default: [])
A list of names or filetypes, which should be ignored by
|tcomment#DefineType()| -- no custom comment definition will be
stored for these names.
This variable should be set before loading autoload/tcomment.vim.
*g:tcomment#must_escape_expression_backslash*
g:tcomment#must_escape_expression_backslash (default: 0)
Users of vim earlier than 7.3 might have to set this variable to
true. Set this variable to 0, if you see unexpected "\r" char
sequences in comments.
The recommended value was `!(v:version > 702 || (v:version == 702 && has('patch407')))`.
It is now assumed though, that no unpatched versions of vim are in
use.
References:
Patch 7.2.407 when using :s with an expression backslashes are dropped
https://github.com/tomtom/tcomment_vim/issues/102
*tcomment#GuessCommentType()*
tcomment#GuessFileType(?options={})
A function that makes the tcomment#filetype#Guess() function usable for other
library developers.
The argument is a dictionary with the following keys:
beg ................ (default = line("."))
end ................ (default = line("."))
comment_mode ........ (default = "G")
filetype ........... (default = &filetype)
fallbackFiletype ... (default = "")
This function return a dictionary that contains information about how
to make comments. The information about the filetype of the text
between lines "beg" and "end" is in the "filetype" key of the return
value. It returns the first discernible filetype it encounters.
*tcomment#Comment()*
tcomment#Comment(beg, end, ...)
tcomment#Comment(line1, line2, ?comment_mode, ?comment_anyway, ?args...)
args... are either:
1. a list of key=value pairs where known keys are (see also
|g:tcomment#options|):
as=STRING ... Use a specific comment definition
count=N ... Repeat the comment string N times
col=N ... Start the comment at column N (in block
mode; must be smaller than |indent()|)
mode=STRING ... See the notes below on the "comment_mode" argument
mode_extra=STRING ... Add to comment_mode
begin=STRING ... Comment prefix
end=STRING ... Comment postfix
middle=STRING ... Middle line comments in block mode
rxbeg=N ... Regexp to find the substring of "begin"
that should be multiplied by "count"
rxend=N ... The above for "end"
rxmid=N ... The above for "middle"
mixedindent=BOOL ... If true, allow use of mixed
characters for indentation
commentstring_rx ... A regexp format string that matches
commented lines (no new groups may be
introduced, the |regexp| is |\V|; % have
to be doubled); "commentstring", "begin"
and optionally "end" must be defined or
deducible.
whitespace ... Define whether commented text is
surrounded with whitespace; if
both ... surround with whitespace (default)
left ... keep whitespace on the left
right... keep whitespace on the right
no ... don't use whitespace
strip_whitespace ... Strip trailing whitespace: if 1
(default), strip from empty lines only,
if 2, always strip whitespace; if 0,
don't strip any whitespace
postprocess_uncomment .. Run a |printf()| expression with 2
placeholders on uncommented lines, e.g.
'norm! %sgg=%sgg'.
choose ... A list of comment definitions (a
dictionary as defined above) that may
contain an `if` key referring to an
expression; if this condition evaluates
to true, the item will be selected; the
last item in the list will be selected
anyway (see the bib definition for an
example)
if ... an |eval()|able expression (only valid
within a choose list, see above)
2. 1-2 values for: ?commentPrefix, ?commentPostfix
3. a dictionary (internal use only)
comment_mode (see also ¦g:tcomment#mode_extra¦):
G ... guess the value of comment_mode
B ... block (use extra lines for the comment markers)
L ... lines
i ... maybe inline, guess
I ... inline
R ... right (comment the line right of the cursor)
v ... visual
o ... operator
C ... force comment
K ... comment only uncommented lines
U ... force uncomment (if U and C are present, U wins)
By default, each line in range will be commented by adding the comment
prefix and postfix.
*tcomment#CommentAs()*
tcomment#CommentAs(beg, end, comment_anyway, filetype, ?args...)
Where args is either:
1. A count NUMBER
2. An args list (see the notes on the "args" argument of
|tcomment#Comment()|)
comment text as if it were of a specific filetype
------------------------------------------------------------------------
*autoload/tcomment/commentdef.vim*
*tcomment#commentdef#Get()*
tcomment#commentdef#Get(beg, end, comment_mode, ...)
tcomment#commentdef#Get(beg, end, comment_mode, ?filetype="")
*tcomment#commentdef#GetCustom()*
tcomment#commentdef#GetCustom(filetype, comment_mode, ...)
tcomment#commentdef#GetCustom(filetype, comment_mode, ?default="", ?default_cdef={})
------------------------------------------------------------------------
*autoload/tcomment/filetype.vim*
*g:tcomment#filetype#guess*
g:tcomment#filetype#guess (default: 0)
Guess the file type based on syntax names always or for some fileformat only
If non-zero, try to guess filetypes.
tcomment also checks g:tcomment#filetype#guess_{&filetype} for
filetype specific values.
Values:
0 ... don't guess
1 ... guess
FILETYPE ... assume this filetype
NOTE: Issue 222, 224: Default=1 doesn't work well
*g:tcomment#filetype#guess_cpp*
g:tcomment#filetype#guess_cpp (default: 0)
See |g:tcomment#filetype#guess_php|.
*g:tcomment#filetype#guess_blade*
g:tcomment#filetype#guess_blade (default: 'html')
See |g:tcomment#filetype#guess_php|.
*g:tcomment#filetype#guess_dsl*
g:tcomment#filetype#guess_dsl (default: 'xml')
For dsl documents, assume filetype = xml.
*g:tcomment#filetype#guess_php*
g:tcomment#filetype#guess_php (default: 'html')
In php documents, the php part is usually marked as phpRegion. We
thus assume that the buffers default comment style isn't php but
html.
*g:tcomment#filetype#ignore_php*
g:tcomment#filetype#ignore_php (default: 'sql')
In php files, some syntax regions are wrongly highlighted as sql
markup. We thus ignore sql syntax when guessing the filetype in
php files.
*g:tcomment#filetype#syntax_map*
g:tcomment#filetype#syntax_map (default: {...})
tcomment guesses filetypes based on the name of the current syntax
region. This works well if the syntax names match
/filetypeSomeName/. Other syntax names have to be explicitly
mapped onto the corresponding filetype.
NOTE: |g:tcomment#syntax#substitute| and
|g:tcomment#syntax#substitute_by_filetype| provide alternative,
and maybe preferable means to detect the proper filetype from a
syntax group name.
*tcomment#filetype#Guess()*
tcomment#filetype#Guess(beg, end, comment_mode, filetype, ...)
inspired by Meikel Brandmeyer's EnhancedCommentify.vim
this requires that a syntax names are prefixed by the filetype name
tcomment#filetype#Guess(beg, end, comment_mode, filetype, ?fallbackFiletype)
*tcomment#filetype#GetAlt()*
tcomment#filetype#GetAlt(filetype, cdef)
Handle sub-filetypes etc.
------------------------------------------------------------------------
*autoload/tcomment/operator.vim*
*g:tcomment#operator#mode_extra*
g:tcomment#operator#mode_extra (default: '')
Modifies how the operator works.
See |g:tcomment#mode_extra| for a list of possible values.
------------------------------------------------------------------------
*autoload/tcomment/syntax.vim*
*g:tcomment#syntax#substitute*
g:tcomment#syntax#substitute (default: {RX: {'sub': SUBST} ...})
Perform replacements on the syntax name. This can be used to
streamline inconsistent syntax names or to map a syntax name onto
a differen filetype.
------------------------------------------------------------------------
*autoload/tcomment/type.vim*
*g:tcomment_types*
g:tcomment_types (default: {})
A dictionary of NAME => COMMENT DEFINITION (see |tcomment#type#Define()|)
that can be set in vimrc to override tcomment's default comment
styles.
*tcomment#type#Define()*
tcomment#type#Define(name, commentdef, ?cdef={}, ?anyway=0)
If you don't explicitly define a comment style, |:TComment| will use
'commentstring' instead. We override the default values here in order
to have a blank after the comment marker. Block comments work only if
we explicitly define the markup.
NAME usually is a 'filetype'. You can use special suffixes to define
special comment types. E.g. the name "FILETYPE_block" is used for
block comments for 'filetype'. The name "FILETYPE_inline" is used for
inline comments. If no specialized comment definition exists, the
normal one with name "FILETYPE" is used.
The comment definition can be either a string or a dictionary.
If it is a string:
The format for block comments is similar to 'commentstrings' with the
exception that the format strings for blocks can contain a second line
that defines how "middle lines" (see :h format-comments) should be
displayed.
Example: If the string is "--%s--\n-- ", lines will be commented as
"--%s--" but the middle lines in block comments will be commented as
"--%s".
If it is a dictionary:
See the help on the args argument of |tcomment#Comment| (see item 1,
args is a list of key=value pairs) to find out which fields can be
used.
*tcomment#type#GetDefinition()*
tcomment#type#GetDefinition(name, ...)
Return the comment definition for NAME.
*b:tcomment_def_{NAME}*
Return b:tcomment_def_{NAME} if the variable exists. Otherwise return
the comment definition as set with |tcomment#type#Define|.
vim:tw=78:fo=w2croql:isk=!-~,^*,^|,^":ts=8:ft=help:norl: