1 ///////////////////////////////////////////////////////////////////////////////////////////////
2 // checkstyle: Checks Java source code and other text files for adherence to a set of rules.
3 // Copyright (C) 2001-2026 the original author or authors.
4 //
5 // This library is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU Lesser General Public
7 // License as published by the Free Software Foundation; either
8 // version 2.1 of the License, or (at your option) any later version.
9 //
10 // This library is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 // Lesser General Public License for more details.
14 //
15 // You should have received a copy of the GNU Lesser General Public
16 // License along with this library; if not, write to the Free Software
17 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 ///////////////////////////////////////////////////////////////////////////////////////////////
19
20 package com.puppycrawl.tools.checkstyle.api;
21
22 import com.puppycrawl.tools.checkstyle.grammar.javadoc.JavadocCommentsLexer;
23
24 /**
25 * Contains the constants for all the tokens contained in the Abstract
26 * Syntax Tree for the javadoc grammar.
27 *
28 * @see <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html">
29 * javadoc - The Java API Documentation Generator</a>
30 */
31 public final class JavadocCommentsTokenTypes {
32
33 /**
34 * Root node of any Javadoc comment.
35 *
36 * <p><b>Tree for example:</b></p>
37 * <pre>{@code
38 * JAVADOC_CONTENT -> JAVADOC_CONTENT
39 * |--LEADING_ASTERISK -> *
40 * |--NEWLINE -> \n
41 * |--LEADING_ASTERISK -> *
42 * |--NEWLINE -> \n
43 * |--LEADING_ASTERISK -> *
44 * `--NEWLINE -> \n
45 * }</pre>
46 */
47 public static final int JAVADOC_CONTENT = JavadocCommentsLexer.JAVADOC;
48
49 /**
50 * Leading asterisk used to format Javadoc lines.
51 *
52 * <p><b>Example:</b></p>
53 * <pre>{@code
54 * /**
55 * * This is a Javadoc line.
56 * * /
57 * }</pre>
58 *
59 * <p><b>Tree:</b></p>
60 * <pre>{@code
61 * --BLOCK_COMMENT_BEGIN -> /**
62 * |--COMMENT_CONTENT -> *\r\n * This is a Javadoc line.\r\n
63 * | `--JAVADOC_CONTENT -> JAVADOC_CONTENT
64 * | |--NEWLINE -> \r\n
65 * | |--LEADING_ASTERISK -> *
66 * | |--TEXT -> This is a Javadoc line.
67 * | |--NEWLINE -> \r\n
68 * | `--TEXT ->
69 * ` --BLOCK_COMMENT_END -> *
70 * }</pre>
71 */
72 public static final int LEADING_ASTERISK = JavadocCommentsLexer.LEADING_ASTERISK;
73
74 /**
75 * Newline character in a Javadoc comment.
76 */
77 public static final int NEWLINE = JavadocCommentsLexer.NEWLINE;
78
79 /**
80 * Plain text content within a Javadoc comment.
81 */
82 public static final int TEXT = JavadocCommentsLexer.TEXT;
83
84 // Block tags
85
86 /**
87 * General block tag (e.g. {@code @param}, {@code @return}).
88 */
89 public static final int JAVADOC_BLOCK_TAG = JavadocCommentsLexer.JAVADOC_BLOCK_TAG;
90
91 /**
92 * At-sign {@code @} that starts a block tag.
93 *
94 * <p><b>Example:</b></p>
95 * <pre>{@code * @author name}</pre>
96 *
97 * <b>Tree:</b>
98 * <pre>{@code
99 * |--LEADING_ASTERISK -> *
100 * |--TEXT ->
101 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
102 * `--AUTHOR_BLOCK_TAG -> AUTHOR_BLOCK_TAG
103 * |--AT_SIGN -> @
104 * |--TAG_NAME -> author
105 * `--DESCRIPTION -> DESCRIPTION
106 * `--TEXT -> name
107 * }</pre>
108 *
109 * @see #JAVADOC_BLOCK_TAG
110 */
111 public static final int AT_SIGN = JavadocCommentsLexer.AT_SIGN;
112
113 /**
114 * {@code @author} Javadoc block tag.
115 *
116 * <p>Such Javadoc tag can have one child:</p>
117 * <ol>
118 * <li>{@link #DESCRIPTION}</li>
119 * </ol>
120 *
121 * <p><b>Example:</b></p>
122 * <pre>{@code * @author name.}</pre>
123 *
124 * <b>Tree:</b>
125 * <pre>{@code
126 * JAVADOC_CONTENT -> JAVADOC_CONTENT
127 * |--LEADING_ASTERISK -> *
128 * |--TEXT ->
129 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
130 * `--AUTHOR_BLOCK_TAG -> AUTHOR_BLOCK_TAG
131 * |--AT_SIGN -> @
132 * |--TAG_NAME -> author
133 * `--DESCRIPTION -> DESCRIPTION
134 * `--TEXT -> name.
135 * }</pre>
136 *
137 * @see #JAVADOC_BLOCK_TAG
138 */
139 public static final int AUTHOR_BLOCK_TAG = JavadocCommentsLexer.AUTHOR_BLOCK_TAG;
140
141 /**
142 * {@code @deprecated} block tag.
143 *
144 * <p>Such Javadoc tag can have one child:</p>
145 * <ol>
146 * <li>{@link #DESCRIPTION}</li>
147 * </ol>
148 *
149 * <p><b>Example:</b></p>
150 * <pre>{@code * @deprecated deprecated text.}</pre>
151 *
152 * <b>Tree:</b>
153 * <pre>{@code
154 * JAVADOC_CONTENT -> JAVADOC_CONTENT
155 * |--LEADING_ASTERISK -> *
156 * |--TEXT ->
157 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
158 * `--DEPRECATED_BLOCK_TAG -> DEPRECATED_BLOCK_TAG
159 * |--AT_SIGN -> @
160 * |--TAG_NAME -> deprecated
161 * `--DESCRIPTION -> DESCRIPTION
162 * `--TEXT -> deprecated text.
163 * }</pre>
164 *
165 * @see #JAVADOC_BLOCK_TAG
166 */
167 public static final int DEPRECATED_BLOCK_TAG = JavadocCommentsLexer.DEPRECATED_BLOCK_TAG;
168
169 /**
170 * {@code @param} Javadoc block tag.
171 *
172 * <p>Such Javadoc tag can have two children:</p>
173 * <ol>
174 * <li>{@link #PARAMETER_NAME}</li>
175 * <li>{@link #DESCRIPTION}</li>
176 * </ol>
177 *
178 * <p><b>Example:</b></p>
179 * <pre>{@code * @param value The parameter of method.}</pre>
180 *
181 * <b>Tree:</b>
182 * <pre>{@code
183 * JAVADOC_CONTENT -> JAVADOC_CONTENT
184 * |--LEADING_ASTERISK -> *
185 * |--TEXT ->
186 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
187 * `--PARAM_BLOCK_TAG -> PARAM_BLOCK_TAG
188 * |--AT_SIGN -> @
189 * |--TAG_NAME -> param
190 * |--TEXT ->
191 * |--PARAMETER_NAME -> value
192 * `--DESCRIPTION -> DESCRIPTION
193 * `--TEXT -> The parameter of method.
194 * }</pre>
195 *
196 * @see #JAVADOC_BLOCK_TAG
197 */
198 public static final int PARAM_BLOCK_TAG = JavadocCommentsLexer.PARAM_BLOCK_TAG;
199
200 /**
201 * {@code @return} Javadoc block tag.
202 *
203 * <p>Such Javadoc tag can have one child:</p>
204 * <ol>
205 * <li>{@link #DESCRIPTION}</li>
206 * </ol>
207 *
208 * <p><b>Example:</b></p>
209 * <pre>{@code * @return The return of method.}</pre>
210 *
211 * <b>Tree:</b>
212 * <pre>{@code
213 * JAVADOC_CONTENT -> JAVADOC_CONTENT
214 * |--LEADING_ASTERISK -> *
215 * |--TEXT ->
216 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
217 * `--RETURN_BLOCK_TAG -> RETURN_BLOCK_TAG
218 * |--AT_SIGN -> @
219 * |--TAG_NAME -> return
220 * `--DESCRIPTION -> DESCRIPTION
221 * `--TEXT -> The return of method.
222 * }</pre>
223 *
224 * @see #JAVADOC_BLOCK_TAG
225 */
226 public static final int RETURN_BLOCK_TAG = JavadocCommentsLexer.RETURN_BLOCK_TAG;
227
228 /**
229 * {@code @throws} Javadoc block tag.
230 *
231 * <p>Such Javadoc tag can have two children:</p>
232 * <ol>
233 * <li>{@link #IDENTIFIER} - the exception class</li>
234 * <li>{@link #DESCRIPTION} - description</li>
235 * </ol>
236 *
237 * <p><b>Example:</b></p>
238 * <pre>{@code * @throws IOException if an I/O error occurs}</pre>
239 *
240 * <b>Tree:</b>
241 * <pre>{@code
242 * JAVADOC_CONTENT -> JAVADOC_CONTENT
243 * |--LEADING_ASTERISK -> *
244 * |--TEXT ->
245 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
246 * `--THROWS_BLOCK_TAG -> THROWS_BLOCK_TAG
247 * |--AT_SIGN -> @
248 * |--TAG_NAME -> throws
249 * |--TEXT ->
250 * |--IDENTIFIER -> IOException
251 * `--DESCRIPTION -> DESCRIPTION
252 * `--TEXT -> if an I/O error occurs
253 * }</pre>
254 *
255 * @see #JAVADOC_BLOCK_TAG
256 */
257 public static final int THROWS_BLOCK_TAG = JavadocCommentsLexer.THROWS_BLOCK_TAG;
258
259 /**
260 * {@code @exception} Javadoc block tag.
261 *
262 * <p>Such Javadoc tag can have two children:</p>
263 * <ol>
264 * <li>{@link #IDENTIFIER}</li>
265 * <li>{@link #DESCRIPTION}</li>
266 * </ol>
267 *
268 * <p><b>Example:</b></p>
269 * <pre>{@code * @exception FileNotFoundException when file is not found.}</pre>
270 *
271 * <b>Tree:</b>
272 * <pre>{@code
273 * JAVADOC_CONTENT -> JAVADOC_CONTENT
274 * |--LEADING_ASTERISK -> *
275 * |--TEXT ->
276 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
277 * `--EXCEPTION_BLOCK_TAG -> EXCEPTION_BLOCK_TAG
278 * |--AT_SIGN -> @
279 * |--TAG_NAME -> exception
280 * |--TEXT ->
281 * |--IDENTIFIER -> FileNotFoundException
282 * `--DESCRIPTION -> DESCRIPTION
283 * `--TEXT -> when file is not found.
284 * }</pre>
285 *
286 * @see #JAVADOC_BLOCK_TAG
287 */
288 public static final int EXCEPTION_BLOCK_TAG = JavadocCommentsLexer.EXCEPTION_BLOCK_TAG;
289
290 /**
291 * {@code @since} Javadoc block tag.
292 *
293 * <p>Such Javadoc tag can have one child:</p>
294 * <ol>
295 * <li>{@link #DESCRIPTION}</li>
296 * </ol>
297 *
298 * <p><b>Example:</b></p>
299 * <pre>{@code * @since 1.0}</pre>
300 *
301 * <b>Tree:</b>
302 * <pre>{@code
303 * JAVADOC_CONTENT -> JAVADOC_CONTENT
304 * |--LEADING_ASTERISK -> *
305 * |--TEXT ->
306 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
307 * `--SINCE_BLOCK_TAG -> SINCE_BLOCK_TAG
308 * |--AT_SIGN -> @
309 * |--TAG_NAME -> since
310 * `--DESCRIPTION -> DESCRIPTION
311 * `--TEXT -> 1.0
312 * }</pre>
313 *
314 * @see #JAVADOC_BLOCK_TAG
315 */
316 public static final int SINCE_BLOCK_TAG = JavadocCommentsLexer.SINCE_BLOCK_TAG;
317
318 /**
319 * {@code @version} Javadoc block tag.
320 *
321 * <p>This tag has only one argument — {@link #TEXT}:</p>
322 *
323 * <p><b>Example:</b></p>
324 * <pre>{@code * @version value}</pre>
325 *
326 * <b>Tree:</b>
327 * <pre>{@code
328 * JAVADOC_CONTENT -> JAVADOC_CONTENT
329 * |--LEADING_ASTERISK -> *
330 * |--TEXT ->
331 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
332 * `--VERSION_BLOCK_TAG -> VERSION_BLOCK_TAG
333 * |--AT_SIGN -> @
334 * |--TAG_NAME -> version
335 * `--DESCRIPTION -> DESCRIPTION
336 * `--TEXT -> value
337 * }</pre>
338 *
339 * @see #JAVADOC_BLOCK_TAG
340 */
341 public static final int VERSION_BLOCK_TAG = JavadocCommentsLexer.VERSION_BLOCK_TAG;
342
343 /**
344 * {@code @see} Javadoc block tag.
345 *
346 * <p>Such Javadoc tag can have three children:</p>
347 * <ol>
348 * <li>{@link #REFERENCE}</li>
349 * <li>{@link #DESCRIPTION}</li>
350 * <li>{@link #HTML_ELEMENT}</li>
351 * </ol>
352 *
353 * <p><b>Example:</b></p>
354 * <pre>{@code * @see SomeClass#Field}</pre>
355 *
356 * <b>Tree:</b>
357 * <pre>{@code
358 * JAVADOC_CONTENT -> JAVADOC_CONTENT
359 * |--LEADING_ASTERISK -> *
360 * |--TEXT ->
361 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
362 * `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG
363 * |--AT_SIGN -> @
364 * |--TAG_NAME -> see
365 * |--TEXT ->
366 * `--REFERENCE -> REFERENCE
367 * |--IDENTIFIER -> SomeClass
368 * |--HASH -> #
369 * `--MEMBER_REFERENCE -> MEMBER_REFERENCE
370 * `--IDENTIFIER -> Field
371 * }</pre>
372 *
373 * @see #JAVADOC_BLOCK_TAG
374 */
375 public static final int SEE_BLOCK_TAG = JavadocCommentsLexer.SEE_BLOCK_TAG;
376
377 /**
378 * {@code @hidden} Javadoc block tag.
379 *
380 * <p>Such Javadoc tag can have one child:</p>
381 * <ol>
382 * <li>{@link #DESCRIPTION} – optional description text</li>
383 * </ol>
384 *
385 * <p><b>Example:</b></p>
386 * <pre>{@code * @hidden value}</pre>
387 *
388 * <b>Tree:</b>
389 * <pre>{@code
390 * JAVADOC_CONTENT -> JAVADOC_CONTENT
391 * |--LEADING_ASTERISK -> *
392 * |--TEXT ->
393 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
394 * `--HIDDEN_BLOCK_TAG -> HIDDEN_BLOCK_TAG
395 * |--AT_SIGN -> @
396 * |--TAG_NAME -> hidden
397 * `--DESCRIPTION -> DESCRIPTION
398 * `--TEXT -> value
399 * }</pre>
400 *
401 * @see #JAVADOC_BLOCK_TAG
402 */
403 public static final int HIDDEN_BLOCK_TAG = JavadocCommentsLexer.HIDDEN_BLOCK_TAG;
404
405 /**
406 * {@code @uses} Javadoc block tag.
407 *
408 * <p>Such Javadoc tag can have one child:</p>
409 * <ol>
410 * <li>{@link #IDENTIFIER} – the referenced service type</li>
411 * </ol>
412 *
413 * <p><b>Example:</b></p>
414 * <pre>{@code * @uses com.example.app.MyService}</pre>
415 *
416 * <b>Tree:</b>
417 * <pre>{@code
418 * JAVADOC_CONTENT -> JAVADOC_CONTENT
419 * |--LEADING_ASTERISK -> *
420 * |--TEXT ->
421 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
422 * `--USES_BLOCK_TAG -> USES_BLOCK_TAG
423 * |--AT_SIGN -> @
424 * |--TAG_NAME -> uses
425 * |--TEXT ->
426 * `--IDENTIFIER -> com.example.app.MyService
427 * }</pre>
428 *
429 * @see #JAVADOC_BLOCK_TAG
430 */
431 public static final int USES_BLOCK_TAG = JavadocCommentsLexer.USES_BLOCK_TAG;
432
433 /**
434 * {@code @provides} block tag.
435 *
436 * <p>Such Javadoc tag can have two children:</p>
437 * <ol>
438 * <li>{@link #IDENTIFIER}</li>
439 * <li>{@link #DESCRIPTION}</li>
440 * </ol>
441 *
442 * <p><b>Example:</b></p>
443 * <pre>{@code * @provides com.example.MyService with com.example.MyServiceImpl}</pre>
444 *
445 * <b>Tree:</b>
446 * <pre>{@code
447 * JAVADOC_CONTENT -> JAVADOC_CONTENT
448 * |--LEADING_ASTERISK -> *
449 * |--TEXT ->
450 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
451 * `--PROVIDES_BLOCK_TAG -> PROVIDES_BLOCK_TAG
452 * |--AT_SIGN -> @
453 * |--TAG_NAME -> provides
454 * |--TEXT ->
455 * |--IDENTIFIER -> com.example.MyService
456 * `--DESCRIPTION -> DESCRIPTION
457 * `--TEXT -> with com.example.MyServiceImpl
458 * }</pre>
459 *
460 * @see #JAVADOC_BLOCK_TAG
461 */
462 public static final int PROVIDES_BLOCK_TAG = JavadocCommentsLexer.PROVIDES_BLOCK_TAG;
463
464 /**
465 * {@code @serial} block tag.
466 *
467 * <p>Such Javadoc tag can have one child:</p>
468 * <ol>
469 * <li>{@link #DESCRIPTION} – optional description text</li>
470 * </ol>
471 *
472 * <p><b>Example:</b></p>
473 * <pre>{@code * @serial include}</pre>
474 *
475 * <b>Tree:</b>
476 * <pre>{@code
477 * JAVADOC_CONTENT -> JAVADOC_CONTENT
478 * |--LEADING_ASTERISK -> *
479 * |--TEXT ->
480 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
481 * `--SERIAL_BLOCK_TAG -> SERIAL_BLOCK_TAG
482 * |--AT_SIGN -> @
483 * |--TAG_NAME -> serial
484 * `--DESCRIPTION -> DESCRIPTION
485 * `--TEXT -> include
486 * }</pre>
487 *
488 * @see #JAVADOC_BLOCK_TAG
489 */
490 public static final int SERIAL_BLOCK_TAG = JavadocCommentsLexer.SERIAL_BLOCK_TAG;
491
492 /**
493 * {@code @serialData} block tag.
494 *
495 * <p>Such Javadoc tag can have one child:</p>
496 * <ol>
497 * <li>{@link #DESCRIPTION} – optional description text</li>
498 * </ol>
499 *
500 * <p><b>Example:</b></p>
501 * <pre>{@code * @serialData data description value}</pre>
502 *
503 * <b>Tree:</b>
504 * <pre>{@code
505 * JAVADOC_CONTENT -> JAVADOC_CONTENT
506 * |--LEADING_ASTERISK -> *
507 * |--TEXT ->
508 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
509 * `--SERIAL_DATA_BLOCK_TAG -> SERIAL_DATA_BLOCK_TAG
510 * |--AT_SIGN -> @
511 * |--TAG_NAME -> serialData
512 * `--DESCRIPTION -> DESCRIPTION
513 * `--TEXT -> data description value
514 * }</pre>
515 *
516 * @see #JAVADOC_BLOCK_TAG
517 */
518 public static final int SERIAL_DATA_BLOCK_TAG = JavadocCommentsLexer.SERIAL_DATA_BLOCK_TAG;
519
520 /**
521 * {@code @serialField} Javadoc block tag.
522 *
523 * <p>Such Javadoc tag can have three children:</p>
524 * <ol>
525 * <li>{@link #IDENTIFIER} – field name</li>
526 * <li>{@link #FIELD_TYPE} – field type</li>
527 * <li>{@link #DESCRIPTION} – field description</li>
528 * </ol>
529 *
530 * <p><b>Example:</b></p>
531 * <pre>{@code * @serialField name String The person's full name.}</pre>
532 *
533 * <b>Tree:</b>
534 * <pre>{@code
535 * JAVADOC_CONTENT -> JAVADOC_CONTENT
536 * |--LEADING_ASTERISK -> *
537 * |--TEXT ->
538 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
539 * `--SERIAL_FIELD_BLOCK_TAG -> SERIAL_FIELD_BLOCK_TAG
540 * |--AT_SIGN -> @
541 * |--TAG_NAME -> serialField
542 * |--TEXT ->
543 * |--IDENTIFIER -> name
544 * |--TEXT ->
545 * |--FIELD_TYPE -> String
546 * `--DESCRIPTION -> DESCRIPTION
547 * `--TEXT -> The person's full name.
548 * }</pre>
549 *
550 * @see #JAVADOC_BLOCK_TAG
551 */
552 public static final int SERIAL_FIELD_BLOCK_TAG = JavadocCommentsLexer.SERIAL_FIELD_BLOCK_TAG;
553
554 /**
555 * {@code @customBlock} Javadoc block tag.
556 *
557 * <p>This type represents any block tag that is not explicitly recognized by Checkstyle,
558 * such as a project-specific or malformed tag.</p>
559 *
560 * <p><b>Example:</b></p>
561 * <pre>{@code * @mycustomtag This is a custom block tag.}</pre>
562 *
563 * <b>Tree:</b>
564 * <pre>{@code
565 * JAVADOC_CONTENT -> JAVADOC_CONTENT
566 * |--LEADING_ASTERISK -> *
567 * |--TEXT ->
568 * `--JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG
569 * `--CUSTOM_BLOCK_TAG -> CUSTOM_BLOCK_TAG
570 * |--AT_SIGN -> @
571 * |--TAG_NAME -> mycustomtag
572 * `--DESCRIPTION -> DESCRIPTION
573 * `--TEXT -> This is a custom block tag.
574 * }</pre>
575 *
576 * @see #JAVADOC_BLOCK_TAG
577 */
578 public static final int CUSTOM_BLOCK_TAG = JavadocCommentsLexer.CUSTOM_BLOCK_TAG;
579
580 // Inline tags
581
582 /**
583 * General inline tag (e.g. {@code @link}).
584 */
585 public static final int JAVADOC_INLINE_TAG = JavadocCommentsLexer.JAVADOC_INLINE_TAG;
586
587 /**
588 * Start of an inline tag <code>{</code>.
589 */
590 public static final int JAVADOC_INLINE_TAG_START =
591 JavadocCommentsLexer.JAVADOC_INLINE_TAG_START;
592
593 /**
594 * End of an inline tag <code>}</code>.
595 */
596 public static final int JAVADOC_INLINE_TAG_END = JavadocCommentsLexer.JAVADOC_INLINE_TAG_END;
597
598 /**
599 * {@code {@code}} Javadoc inline tag.
600 *
601 * <p>Such Javadoc tag can have no children:</p>
602 *
603 * <p><b>Example:</b></p>
604 * <pre>{@code * {@code println("Hello");}}</pre>
605 *
606 * <b>Tree:</b>
607 * <pre>{@code
608 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
609 * |--CODE_INLINE_TAG -> CODE_INLINE_TAG
610 * |--JAVADOC_INLINE_TAG_START -> { @
611 * |--TAG_NAME -> code
612 * |--TEXT -> println("Hello");
613 * `--JAVADOC_INLINE_TAG_END -> }
614 * }</pre>
615 *
616 * @see #JAVADOC_INLINE_TAG
617 */
618 public static final int CODE_INLINE_TAG = JavadocCommentsLexer.CODE_INLINE_TAG;
619
620 /**
621 * {@code {@link}} Javadoc inline tag.
622 *
623 * <p>Such Javadoc tag can have two children:</p>
624 * <ol>
625 * <li>{@link #REFERENCE}</li>
626 * <li>{@link #DESCRIPTION}</li>
627 * </ol>
628 *
629 * <p><b>Example:</b></p>
630 * <pre>{@code * {@link Math#max(int, int) label}}</pre>
631 *
632 * <b>Tree:</b>
633 * <pre>{@code
634 * --JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
635 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG
636 * |--JAVADOC_INLINE_TAG_START -> { @
637 * |--TAG_NAME -> link
638 * |--TEXT ->
639 * |--REFERENCE -> REFERENCE
640 * | |--IDENTIFIER -> Math
641 * | |--HASH -> #
642 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE
643 * | |--IDENTIFIER -> max
644 * | |--LPAREN -> (
645 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST
646 * | | |--PARAMETER_TYPE -> int
647 * | | |--COMMA -> ,
648 * | | |--TEXT ->
649 * | | `--PARAMETER_TYPE -> int
650 * | `--RPAREN -> )
651 * |--DESCRIPTION -> DESCRIPTION
652 * | `--TEXT -> label
653 * `--JAVADOC_INLINE_TAG_END -> }
654 * }</pre>
655 *
656 * @see #JAVADOC_INLINE_TAG
657 */
658 public static final int LINK_INLINE_TAG = JavadocCommentsLexer.LINK_INLINE_TAG;
659
660 /**
661 * {@code {@linkplain}} Javadoc inline tag.
662 *
663 * <p>Such Javadoc tag can have two children:</p>
664 * <ol>
665 * <li>{@link #REFERENCE}</li>
666 * <li>{@link #DESCRIPTION}</li>
667 * </ol>
668 *
669 * <p><b>Example:</b></p>
670 * <pre>{@code * {@linkplain String#indexOf(int, int) label}}</pre>
671 *
672 * <b>Tree:</b>
673 * <pre>{@code
674 * --JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
675 * `--LINKPLAIN_INLINE_TAG -> LINKPLAIN_INLINE_TAG
676 * |--JAVADOC_INLINE_TAG_START -> { @
677 * |--TAG_NAME -> linkplain
678 * |--TEXT ->
679 * |--REFERENCE -> REFERENCE
680 * | |--IDENTIFIER -> String
681 * | |--HASH -> #
682 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE
683 * | |--IDENTIFIER -> indexOf
684 * | |--LPAREN -> (
685 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST
686 * | | |--PARAMETER_TYPE -> int
687 * | | |--COMMA -> ,
688 * | | |--TEXT ->
689 * | | `--PARAMETER_TYPE -> int
690 * | `--RPAREN -> )
691 * |--DESCRIPTION -> DESCRIPTION
692 * | `--TEXT -> label
693 * `--JAVADOC_INLINE_TAG_END -> }
694 * }</pre>
695 *
696 * @see #JAVADOC_INLINE_TAG
697 */
698 public static final int LINKPLAIN_INLINE_TAG = JavadocCommentsLexer.LINKPLAIN_INLINE_TAG;
699
700 /**
701 * {@code {@value}} Javadoc inline tag.
702 *
703 * <p>Such Javadoc tag can have one child:</p>
704 * <ol>
705 * <li>{@link #REFERENCE}</li>
706 * </ol>
707 *
708 * <p><b>Example:</b></p>
709 * <pre>{@code * {@value Integer#MAX_VALUE}}</pre>
710 *
711 * <b>Tree:</b>
712 * <pre>{@code
713 * --JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
714 * `--VALUE_INLINE_TAG -> VALUE_INLINE_TAG
715 * |--JAVADOC_INLINE_TAG_START -> { @
716 * |--TAG_NAME -> value
717 * |--TEXT ->
718 * |--REFERENCE -> REFERENCE
719 * | |--IDENTIFIER -> Integer
720 * | |--HASH -> #
721 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE
722 * | `--IDENTIFIER -> MAX_VALUE
723 * |--TEXT ->
724 * `--JAVADOC_INLINE_TAG_END -> }
725 * }</pre>
726 *
727 * @see #JAVADOC_INLINE_TAG
728 */
729 public static final int VALUE_INLINE_TAG = JavadocCommentsLexer.VALUE_INLINE_TAG;
730
731 /**
732 * Inline {@code {@summary ...}} tag inside Javadoc.
733 *
734 * <p>This node represents an inline {@code {@summary ...}} tag used to provide a
735 * short summary description within a Javadoc sentence.</p>
736 *
737 * <p><b>Example:</b></p>
738 * <pre>{@code * Example showing {@summary This is a short summary.}}</pre>
739 *
740 * <b>Tree:</b>
741 * <pre>{@code
742 * |--LEADING_ASTERISK -> *
743 * |--TEXT -> Example showing
744 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
745 * `--SUMMARY_INLINE_TAG -> SUMMARY_INLINE_TAG
746 * |--JAVADOC_INLINE_TAG_START -> { @
747 * |--TAG_NAME -> summary
748 * |--DESCRIPTION -> DESCRIPTION
749 * | `--TEXT -> This is a short summary.
750 * `--JAVADOC_INLINE_TAG_END -> }
751 * }</pre>
752 *
753 * @see #JAVADOC_INLINE_TAG
754 */
755
756 public static final int SUMMARY_INLINE_TAG = JavadocCommentsLexer.SUMMARY_INLINE_TAG;
757
758 /**
759 * {@code {@inheritDoc}} inline tag.
760 *
761 * <p>This node models the inline {@code {@inheritDoc}} tag that instructs Javadoc
762 * to inherit documentation from the corresponding element in a parent class or interface.</p>
763 *
764 * <p><b>Example:</b></p>
765 * <pre>{@code * {@inheritDoc}}</pre>
766 *
767 * <b>Tree:</b>
768 * <pre>{@code
769 * |--LEADING_ASTERISK -> *
770 * |--TEXT ->
771 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
772 * `--INHERIT_DOC_INLINE_TAG -> INHERIT_DOC_INLINE_TAG
773 * |--JAVADOC_INLINE_TAG_START -> { @
774 * |--TAG_NAME -> inheritDoc
775 * `--JAVADOC_INLINE_TAG_END -> }
776 * }</pre>
777 *
778 * @see #JAVADOC_INLINE_TAG
779 */
780 public static final int INHERIT_DOC_INLINE_TAG = JavadocCommentsLexer.INHERIT_DOC_INLINE_TAG;
781
782 /**
783 * {@code {@systemProperty}} inline tag.
784 *
785 * <p>Such Javadoc tag is used to reference a system property.</p>
786 *
787 * <p><b>Example:</b></p>
788 * <pre>{@code * This method uses {@systemProperty user.home} system property.}</pre>
789 *
790 * <b>Tree:</b>
791 * <pre>{@code
792 * |--LEADING_ASTERISK -> *
793 * |--TEXT -> This method uses
794 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
795 * | `--SYSTEM_PROPERTY_INLINE_TAG -> SYSTEM_PROPERTY_INLINE_TAG
796 * | |--JAVADOC_INLINE_TAG_START -> { @
797 * | |--TAG_NAME -> systemProperty
798 * | |--TEXT ->
799 * | |--IDENTIFIER -> user.home
800 * | `--JAVADOC_INLINE_TAG_END -> }
801 * |--TEXT -> system property.
802 * }</pre>
803 *
804 * @see #JAVADOC_INLINE_TAG
805 */
806 public static final int SYSTEM_PROPERTY_INLINE_TAG =
807 JavadocCommentsLexer.SYSTEM_PROPERTY_INLINE_TAG;
808
809 /**
810 * {@code {@literal}} inline tag.
811 *
812 * <p><b>Example:</b></p>
813 * <pre>{@code * {@literal @Override}}</pre>
814 *
815 * <b>Tree:</b>
816 * <pre>{@code
817 * |--LEADING_ASTERISK -> *
818 * |--TEXT ->
819 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
820 * `--LITERAL_INLINE_TAG -> LITERAL_INLINE_TAG
821 * |--JAVADOC_INLINE_TAG_START -> { @
822 * |--TAG_NAME -> literal
823 * |--TEXT -> @Override
824 * `--JAVADOC_INLINE_TAG_END -> }
825 * }</pre>
826 *
827 * @see #JAVADOC_INLINE_TAG
828 */
829 public static final int LITERAL_INLINE_TAG = JavadocCommentsLexer.LITERAL_INLINE_TAG;
830
831 /**
832 * Inline {@code return} tag inside Javadoc.
833 *
834 * <p>This node represents an inline {@code {@return ...}} tag used to
835 * describe the returned value directly within a Javadoc sentence.</p>
836 *
837 * <p><b>Example:</b></p>
838 * <pre>{@code Example showing result {@return The computed value.}}</pre>
839 *
840 * <b>Tree:</b>
841 * <pre>{@code
842 * |--LEADING_ASTERISK -> *
843 * |--TEXT -> Example showing result
844 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
845 * `--RETURN_INLINE_TAG -> RETURN_INLINE_TAG
846 * |--JAVADOC_INLINE_TAG_START -> { @
847 * |--TAG_NAME -> return
848 * |--DESCRIPTION -> DESCRIPTION
849 * | `--TEXT -> The computed value.
850 * `--JAVADOC_INLINE_TAG_END -> }
851 * }</pre>
852 *
853 * @see #JAVADOC_INLINE_TAG
854 */
855
856 public static final int RETURN_INLINE_TAG = JavadocCommentsLexer.RETURN_INLINE_TAG;
857
858 /**
859 * {@code {@index}} inline tag.
860 *
861 * <p>This node represents an inline {@code {@index ...}} tag used to mark an
862 * index term inside a Javadoc sentence.</p>
863 *
864 * <p><b>Example:</b></p>
865 * <pre>{@code * Example showing {@index keyword description of the index term}.}</pre>
866 *
867 * <b>Tree:</b>
868 * <pre>{@code
869 * |--LEADING_ASTERISK -> *
870 * |--TEXT -> Example showing
871 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
872 * `--INDEX_INLINE_TAG -> INDEX_INLINE_TAG
873 * |--JAVADOC_INLINE_TAG_START -> { @
874 * |--TAG_NAME -> index
875 * |--TEXT ->
876 * |--INDEX_TERM -> keyword
877 * |--DESCRIPTION -> DESCRIPTION
878 * | `--TEXT -> description of the index term
879 * `--JAVADOC_INLINE_TAG_END -> }
880 * |--TEXT -> .
881 * }</pre>
882 *
883 * @see #JAVADOC_INLINE_TAG
884 */
885
886 public static final int INDEX_INLINE_TAG = JavadocCommentsLexer.INDEX_INLINE_TAG;
887
888 /**
889 * {@code @snippet} inline tag.
890 *
891 * <p>This node represents an inline { @code { @snippet :}} tag used to embed
892 * code snippets directly inside a Javadoc sentence.</p>
893 *
894 * <p><b>Example:</b></p>
895 * <pre>{ @code * Example showing { @snippet :java |
896 * System.out.println("hello");
897 * }}</pre>
898 *
899 * <b>Tree:</b>
900 * <pre>{@code
901 * |--LEADING_ASTERISK -> *
902 * |--TEXT -> Example showing
903 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
904 * `--SNIPPET_INLINE_TAG -> SNIPPET_INLINE_TAG
905 * |--JAVADOC_INLINE_TAG_START -> { @
906 * |--COLON -> :
907 * |--SNIPPET_BODY -> SNIPPET_BODY
908 * | |--TEXT -> java |
909 * | |--NEWLINE -> \n
910 * | |--LEADING_ASTERISK -> *
911 * | |--TEXT -> System.out.println("hello");
912 * | |--NEWLINE -> \n
913 * | |--LEADING_ASTERISK -> *
914 * | `--TEXT ->
915 * `--JAVADOC_INLINE_TAG_END -> }
916 * }</pre>
917 *
918 * @see #JAVADOC_INLINE_TAG
919 */
920 public static final int SNIPPET_INLINE_TAG = JavadocCommentsLexer.SNIPPET_INLINE_TAG;
921
922 /**
923 * {@code @custom} inline tag.
924 *
925 * <p><b>Example:</b></p>
926 * <pre>{@code * Example showing {@custom This is a Custom Inline Tag}.}</pre>
927 *
928 * <p><b>Tree:</b></p>
929 * <pre>{@code
930 * |--LEADING_ASTERISK -> *
931 * |--TEXT -> Example showing
932 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
933 * | `--CUSTOM_INLINE_TAG -> CUSTOM_INLINE_TAG
934 * | |--JAVADOC_INLINE_TAG_START -> { @
935 * | |--TAG_NAME -> custom
936 * | |--DESCRIPTION -> DESCRIPTION
937 * | | `--TEXT -> This is a Custom Inline Tag
938 * | `--JAVADOC_INLINE_TAG_END -> }
939 * |--TEXT -> .
940 * }</pre>
941 *
942 * @see #JAVADOC_INLINE_TAG
943 */
944 public static final int CUSTOM_INLINE_TAG = JavadocCommentsLexer.CUSTOM_INLINE_TAG;
945
946 // Components
947
948 /**
949 * Identifier token.
950 */
951 public static final int IDENTIFIER = JavadocCommentsLexer.IDENTIFIER;
952
953 /**
954 * Hash symbol {@code #} used in references.
955 */
956 public static final int HASH = JavadocCommentsLexer.HASH;
957
958 /**
959 * Left parenthesis {@code ( }.
960 */
961 public static final int LPAREN = JavadocCommentsLexer.LPAREN;
962
963 /**
964 * Right parenthesis {@code ) }.
965 */
966 public static final int RPAREN = JavadocCommentsLexer.RPAREN;
967
968 /**
969 * Comma symbol {@code , }.
970 */
971 public static final int COMMA = JavadocCommentsLexer.COMMA;
972
973 /**
974 * Slash symbol {@code / }.
975 */
976 public static final int SLASH = JavadocCommentsLexer.SLASH;
977
978 /**
979 * Question mark symbol {@code ? }.
980 */
981 public static final int QUESTION = JavadocCommentsLexer.QUESTION;
982
983 /**
984 * Less-than symbol {@code < }.
985 */
986 public static final int LT = JavadocCommentsLexer.LT;
987
988 /**
989 * Greater-than symbol {@code > }.
990 */
991 public static final int GT = JavadocCommentsLexer.GT;
992
993 /**
994 * {@code extends} keyword inside type arguments of a Javadoc inline tag.
995 *
996 * <p>This node represents the {@code extends} bound used inside a
997 * parameterized type within an inline Javadoc tag.</p>
998 *
999 * <p><b>Example:</b></p>
1000 * <pre>{@code
1001 * * {@link java.util.List<? extends Number> list of any subtype of Number}
1002 * }</pre>
1003 *
1004 * <b>Tree:</b>
1005 * <pre>{@code
1006 * |--LEADING_ASTERISK -> *
1007 * |--TEXT ->
1008 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
1009 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG
1010 * |--JAVADOC_INLINE_TAG_START -> { @
1011 * |--TAG_NAME -> link
1012 * |--TEXT ->
1013 * |--REFERENCE -> REFERENCE
1014 * | |--IDENTIFIER -> java.util.List
1015 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
1016 * | |--LT -> <
1017 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
1018 * | | |--QUESTION -> ?
1019 * | | |--TEXT ->
1020 * | | |--EXTENDS -> extends
1021 * | | |--TEXT ->
1022 * | | `--IDENTIFIER -> Number
1023 * | `--GT -> >
1024 * |--DESCRIPTION -> DESCRIPTION
1025 * | `--TEXT -> list of any subtype of Number
1026 * `--JAVADOC_INLINE_TAG_END -> }
1027 * }</pre>
1028 *
1029 * @see #JAVADOC_INLINE_TAG
1030 */
1031 public static final int EXTENDS = JavadocCommentsLexer.EXTENDS;
1032
1033 /**
1034 * {@code SUPER} represents the {@code super} keyword inside a generic
1035 * wildcard bound (e.g., {@code ? super Number}).
1036 *
1037 * <p><b>Example:</b> {@code {@link java.util.List <? super Integer> list}
1038 * of any supertype of Integer}</p>
1039 *
1040 * <p><b>Tree:</b></p>
1041 * <pre>{@code
1042 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
1043 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG
1044 * |--JAVADOC_INLINE_TAG_START -> { @
1045 * |--TAG_NAME -> link
1046 * |--TEXT ->
1047 * |--REFERENCE -> REFERENCE
1048 * | |--IDENTIFIER -> java.util.List
1049 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
1050 * | |--LT -> <
1051 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
1052 * | | |--QUESTION -> ?
1053 * | | |--TEXT ->
1054 * | | |--SUPER -> super
1055 * | | |--TEXT ->
1056 * | | `--IDENTIFIER -> Integer
1057 * | `--GT -> >
1058 * |--DESCRIPTION -> DESCRIPTION
1059 * | `--TEXT -> list of any supertype of Integer
1060 * `--JAVADOC_INLINE_TAG_END -> }
1061 * }</pre>
1062 *
1063 * @see #PARAMETER_TYPE
1064 */
1065 public static final int SUPER = JavadocCommentsLexer.SUPER;
1066
1067 /**
1068 * {@code PARAMETER_TYPE} Parameter type reference.
1069 *
1070 * <p>Represents a type used in a method parameter.</p>
1071 *
1072 * <p><b>Example:</b></p>
1073 * <pre>{@code {@link java.util.List#add(Object)}} </pre>
1074 *
1075 * <b>Tree:</b>
1076 * <pre>{@code
1077 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
1078 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG
1079 * |--JAVADOC_INLINE_TAG_START -> {@
1080 * |--TAG_NAME -> link
1081 * |--REFERENCE -> REFERENCE
1082 * | |--IDENTIFIER -> List
1083 * | |--HASH -> #
1084 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE
1085 * | |--IDENTIFIER -> add
1086 * | |--LPAREN -> (
1087 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST
1088 * | | `--PARAMETER_TYPE -> Object
1089 * | `--RPAREN -> )
1090 * `--JAVADOC_INLINE_TAG_END -> }
1091 * }</pre>
1092 *
1093 * @see #REFERENCE
1094 */
1095 public static final int PARAMETER_TYPE = JavadocCommentsLexer.PARAMETER_TYPE;
1096
1097 /**
1098 * {@code REFERENCE} General reference within Javadoc.
1099 *
1100 * <p>Represents the target of an inline reference tag such as
1101 * {@code {@link String#length()}}.</p>
1102 *
1103 * <p><b>Example:</b></p>
1104 * <pre>{@code
1105 * {@link String#length()}
1106 * }</pre>
1107 *
1108 * <b>Tree:</b>
1109 * <pre>{@code
1110 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
1111 * |--LINK_INLINE_TAG -> LINK_INLINE_TAG
1112 * | |--JAVADOC_INLINE_TAG_START -> {@
1113 * | |--TAG_NAME -> link
1114 * | `--REFERENCE -> String#length()
1115 * }</pre>
1116 *
1117 * @see #JAVADOC_INLINE_TAG
1118 */
1119 public static final int REFERENCE = JavadocCommentsLexer.REFERENCE;
1120
1121 /**
1122 * {@code MEMBER_REFERENCE} Member reference (method or field).
1123 *
1124 * <p>Represents a field or method in a type reference.</p>
1125 *
1126 * <p><b>Example:</b></p>
1127 * <pre>{@code
1128 * {@link String#length()}
1129 * }</pre>
1130 *
1131 * <p><b>Tree:</b></p>
1132 * <pre>{@code
1133 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
1134 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG
1135 * |--JAVADOC_INLINE_TAG_START -> {@
1136 * |--TAG_NAME -> link
1137 * |--TEXT ->
1138 * |--REFERENCE -> REFERENCE
1139 * | |--IDENTIFIER -> String
1140 * | |--HASH -> #
1141 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE
1142 * | |--IDENTIFIER -> length
1143 * | |--LPAREN -> (
1144 * | `--RPAREN -> )
1145 * `--JAVADOC_INLINE_TAG_END -> }
1146 * }</pre>
1147 *
1148 * @see #REFERENCE
1149 */
1150 public static final int MEMBER_REFERENCE = JavadocCommentsLexer.MEMBER_REFERENCE;
1151
1152 /**
1153 * {@code PARAMETER_TYPE_LIST} represents the list of parameter types inside a
1154 * member reference within a Javadoc inline {@code @link} tag.
1155 *
1156 * <p><b>Example:</b></p>
1157 * <pre>{@code
1158 * {@link Math#max(int, int)}
1159 * }</pre>
1160 *
1161 * <p><b>Tree:</b></p>
1162 * <pre>{@code
1163 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
1164 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG
1165 * |--JAVADOC_INLINE_TAG_START -> {\@
1166 * |--TAG_NAME -> link
1167 * |--TEXT ->
1168 * |--REFERENCE -> REFERENCE
1169 * | |--IDENTIFIER -> Math
1170 * | |--HASH -> #
1171 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE
1172 * | |--IDENTIFIER -> max
1173 * | |--LPAREN -> (
1174 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST
1175 * | | |--PARAMETER_TYPE -> int
1176 * | | |--COMMA -> ,
1177 * | | |--TEXT ->
1178 * | | `--PARAMETER_TYPE -> int
1179 * | `--RPAREN -> )
1180 * `--JAVADOC_INLINE_TAG_END -> }
1181 * }</pre>
1182 *
1183 * @see #PARAMETER_TYPE
1184 */
1185 public static final int PARAMETER_TYPE_LIST = JavadocCommentsLexer.PARAMETER_TYPE_LIST;
1186
1187 /**
1188 * {@code TYPE_ARGUMENTS} Type arguments in generics.
1189 *
1190 * <p>Represents the type arguments inside a generic type reference.</p>
1191 *
1192 * <p><b>Example:</b></p>
1193 * <pre>{@code {@link java.util.List<String>}}</pre>
1194 *
1195 * <p><b>Tree:</b></p>
1196 * <pre>{@code
1197 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
1198 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG
1199 * |--JAVADOC_INLINE_TAG_START -> {@
1200 * |--TAG_NAME -> link
1201 * |--TEXT ->
1202 * |--REFERENCE -> REFERENCE
1203 * | |--IDENTIFIER -> java.util.List
1204 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS
1205 * | |--LT -> <
1206 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT
1207 * | | `--IDENTIFIER -> String
1208 * | `--GT -> >
1209 * `--JAVADOC_INLINE_TAG_END -> }
1210 * }</pre>
1211 *
1212 * @see #TYPE_ARGUMENT
1213 */
1214 public static final int TYPE_ARGUMENTS = JavadocCommentsLexer.TYPE_ARGUMENTS;
1215
1216 /**
1217 * Single type argument in generics.
1218 */
1219 public static final int TYPE_ARGUMENT = JavadocCommentsLexer.TYPE_ARGUMENT;
1220
1221 /**
1222 * Description part of a Javadoc tag.
1223 */
1224 public static final int DESCRIPTION = JavadocCommentsLexer.DESCRIPTION;
1225
1226 /**
1227 * Format specifier inside Javadoc content.
1228 */
1229 public static final int FORMAT_SPECIFIER = JavadocCommentsLexer.FORMAT_SPECIFIER;
1230
1231 /**
1232 * Attribute name in a {@code @snippet}.
1233 */
1234 public static final int SNIPPET_ATTR_NAME = JavadocCommentsLexer.SNIPPET_ATTR_NAME;
1235
1236 /**
1237 * Equals sign {@code = }.
1238 */
1239 public static final int EQUALS = JavadocCommentsLexer.EQUALS;
1240
1241 /**
1242 * {@code ATTRIBUTE_VALUE} Value assigned to an attribute.
1243 *
1244 * <p><b>Example:</b></p>
1245 * <pre>{@code <a href="example">text</a>}</pre>
1246 *
1247 * <p><b>Tree:</b></p>
1248 * <pre>{@code
1249 * HTML_ELEMENT -> HTML_ELEMENT
1250 * |--HTML_TAG_START -> HTML_TAG_START
1251 * | |--TAG_OPEN -> <
1252 * | |--TAG_NAME -> a
1253 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES
1254 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE
1255 * | | |--TEXT ->
1256 * | | |--TAG_ATTR_NAME -> href
1257 * | | |--EQUALS -> =
1258 * | | `--ATTRIBUTE_VALUE -> "example"
1259 * | `--TAG_CLOSE -> >
1260 * |--HTML_CONTENT -> HTML_CONTENT
1261 * | `--TEXT -> text
1262 * `--HTML_TAG_END -> HTML_TAG_END
1263 * |--TAG_OPEN -> <
1264 * |--TAG_SLASH -> /
1265 * |--TAG_NAME -> a
1266 * `--TAG_CLOSE -> >
1267 * }</pre>
1268 *
1269 * @see #HTML_ATTRIBUTE
1270 * @see #TAG_ATTR_NAME
1271 */
1272 public static final int ATTRIBUTE_VALUE = JavadocCommentsLexer.ATTRIBUTE_VALUE;
1273
1274 /**
1275 * Colon symbol {@code : }.
1276 */
1277 public static final int COLON = JavadocCommentsLexer.COLON;
1278
1279 /**
1280 * Term used in {@code {@index}} tag.
1281 */
1282 public static final int INDEX_TERM = JavadocCommentsLexer.INDEX_TERM;
1283
1284 /**
1285 * Single snippet attribute.
1286 */
1287 public static final int SNIPPET_ATTRIBUTE = JavadocCommentsLexer.SNIPPET_ATTRIBUTE;
1288
1289 /**
1290 * Collection of snippet attributes.
1291 */
1292 public static final int SNIPPET_ATTRIBUTES = JavadocCommentsLexer.SNIPPET_ATTRIBUTES;
1293
1294 /**
1295 * Body content of a {@code @snippet}.
1296 */
1297 public static final int SNIPPET_BODY = JavadocCommentsLexer.SNIPPET_BODY;
1298
1299 /**
1300 * Field type reference.
1301 */
1302 public static final int FIELD_TYPE = JavadocCommentsLexer.FIELD_TYPE;
1303
1304 /**
1305 * Parameter name reference.
1306 */
1307 public static final int PARAMETER_NAME = JavadocCommentsLexer.PARAMETER_NAME;
1308
1309 /**
1310 * String literal inside Javadoc.
1311 */
1312 public static final int STRING_LITERAL = JavadocCommentsLexer.STRING_LITERAL;
1313
1314 // HTML
1315
1316 /**
1317 * General HTML element.
1318 */
1319 public static final int HTML_ELEMENT = JavadocCommentsLexer.HTML_ELEMENT;
1320
1321 /**
1322 * Void HTML element (self-closing).
1323 */
1324 public static final int VOID_ELEMENT = JavadocCommentsLexer.VOID_ELEMENT;
1325
1326 /**
1327 * Content inside an HTML element.
1328 *
1329 * <p>This node represents the textual content between an HTML start tag and
1330 * the corresponding end tag inside a Javadoc comment.</p>
1331 *
1332 * <p><b>Example:</b></p>
1333 * <pre>{@code * <a href="https://example.com">link</a>}</pre>
1334 *
1335 * <b>Tree:</b>
1336 * <pre>{@code
1337 * |--LEADING_ASTERISK -> *
1338 * `--HTML_ELEMENT -> HTML_ELEMENT
1339 * |--HTML_TAG_START -> HTML_TAG_START
1340 * | |--TAG_OPEN -> <
1341 * | |--TAG_NAME -> a
1342 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES
1343 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE
1344 * | | |--TEXT -> (whitespace)
1345 * | | |--TAG_ATTR_NAME -> href
1346 * | | |--EQUALS -> =
1347 * | | `--ATTRIBUTE_VALUE -> "https://example.com"
1348 * | `--TAG_CLOSE -> >
1349 * |--HTML_CONTENT -> HTML_CONTENT
1350 * | `--TEXT -> link
1351 * `--HTML_TAG_END -> HTML_TAG_END
1352 * |--TAG_OPEN -> <
1353 * |--TAG_SLASH -> /
1354 * |--TAG_NAME -> a
1355 * `--TAG_CLOSE -> >
1356 * }</pre>
1357 *
1358 * @see #HTML_ELEMENT
1359 */
1360
1361 public static final int HTML_CONTENT = JavadocCommentsLexer.HTML_CONTENT;
1362
1363 /**
1364 * {@code HTML_ATTRIBUTE} Single HTML attribute.
1365 *
1366 * <p>Represents one attribute inside an HTML tag.</p>
1367 *
1368 * <p><b>Example:</b></p>
1369 * <pre>{@code
1370 * <input type="text">
1371 * }</pre>
1372 *
1373 * <b>Tree:</b>
1374 * <pre>{@code
1375 * HTML_ELEMENT -> HTML_ELEMENT
1376 * `--VOID_ELEMENT -> VOID_ELEMENT
1377 * `--HTML_TAG_START -> HTML_TAG_START
1378 * |--TAG_OPEN -> <
1379 * |--TAG_NAME -> input
1380 * |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES
1381 * | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE
1382 * | |--TEXT ->
1383 * | |--TAG_ATTR_NAME -> type
1384 * | |--EQUALS -> =
1385 * | `--ATTRIBUTE_VALUE -> "text"
1386 * `--TAG_CLOSE -> >
1387 * }</pre>
1388 *
1389 * @see #HTML_ATTRIBUTES
1390 */
1391 public static final int HTML_ATTRIBUTE = JavadocCommentsLexer.HTML_ATTRIBUTE;
1392
1393 /**
1394 * {@code HTML_ATTRIBUTES} represents a collection of HTML attributes
1395 * inside an HTML tag.
1396 *
1397 * <p>Appears in Javadoc comments when documenting HTML elements that contain
1398 * multiple attributes.</p>
1399 *
1400 * <p><b>Example:</b></p>
1401 * <pre>{@code
1402 * <div lang="en" custom-attr="value"></div>
1403 * }</pre>
1404 *
1405 * <p><b>Tree:</b></p>
1406 * <pre>{@code
1407 * HTML_ELEMENT -> HTML_ELEMENT
1408 * |--HTML_TAG_START -> HTML_TAG_START
1409 * | |--TAG_OPEN -> <
1410 * | |--TAG_NAME -> div
1411 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES
1412 * | | |--HTML_ATTRIBUTE -> HTML_ATTRIBUTE
1413 * | | | |--TEXT ->
1414 * | | | |--TAG_ATTR_NAME -> lang
1415 * | | | |--EQUALS -> =
1416 * | | | `--ATTRIBUTE_VALUE -> "en"
1417 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE
1418 * | | |--TEXT ->
1419 * | | |--TAG_ATTR_NAME -> custom-attr
1420 * | | |--EQUALS -> =
1421 * | | `--ATTRIBUTE_VALUE -> "value"
1422 * | `--TAG_CLOSE -> >
1423 * }</pre>
1424 *
1425 * @see #HTML_ATTRIBUTE
1426 */
1427 public static final int HTML_ATTRIBUTES = JavadocCommentsLexer.HTML_ATTRIBUTES;
1428
1429 /**
1430 * Start of an HTML tag (the opening tag node).
1431 *
1432 * <p>This node represents the opening part of an HTML element and contains
1433 * the opening delimiter, tag name, optional attributes, and the closing
1434 * delimiter of the opening tag.</p>
1435 *
1436 * <p><b>Example:</b></p>
1437 * <pre>{@code * <a href="https://example.com">link</a>}</pre>
1438 *
1439 * <b>Tree:</b>
1440 * <pre>{@code
1441 * |--LEADING_ASTERISK -> *
1442 * `--HTML_ELEMENT -> HTML_ELEMENT
1443 * `--HTML_TAG_START -> HTML_TAG_START
1444 * |--TAG_OPEN -> <
1445 * |--TAG_NAME -> a
1446 * |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES
1447 * | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE
1448 * | |--TEXT ->
1449 * | |--TAG_ATTR_NAME -> href
1450 * | |--EQUALS -> =
1451 * | `--ATTRIBUTE_VALUE -> "https://example.com"
1452 * `--TAG_CLOSE -> >
1453 * }</pre>
1454 *
1455 * @see #HTML_ELEMENT
1456 */
1457
1458 public static final int HTML_TAG_START = JavadocCommentsLexer.HTML_TAG_START;
1459
1460 /**
1461 * End of an HTML tag (the closing tag node).
1462 *
1463 * <p>This node represents the closing part of an HTML element and contains the
1464 * closing delimiter, optional slash, and the tag name.</p>
1465 *
1466 * <p><b>Example:</b></p>
1467 * <pre>{@code * <a href="https://example.com">link</a>}</pre>
1468 *
1469 * <b>Tree:</b>
1470 * <pre>{@code
1471 * |--LEADING_ASTERISK -> *
1472 * `--HTML_ELEMENT -> HTML_ELEMENT
1473 * |--HTML_TAG_START -> HTML_TAG_START
1474 * | |--TAG_OPEN -> <
1475 * | |--TAG_NAME -> a
1476 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES
1477 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE
1478 * | | |--TEXT -> (whitespace)
1479 * | | |--TAG_ATTR_NAME -> href
1480 * | | |--EQUALS -> =
1481 * | | `--ATTRIBUTE_VALUE -> "https://example.com"
1482 * | `--TAG_CLOSE -> >
1483 * |--HTML_CONTENT -> HTML_CONTENT
1484 * | `--TEXT -> link
1485 * `--HTML_TAG_END -> HTML_TAG_END
1486 * |--TAG_OPEN -> <
1487 * |--TAG_SLASH -> /
1488 * |--TAG_NAME -> a
1489 * `--TAG_CLOSE -> >
1490 * }</pre>
1491 *
1492 * @see #HTML_ELEMENT
1493 */
1494
1495 public static final int HTML_TAG_END = JavadocCommentsLexer.HTML_TAG_END;
1496
1497 /**
1498 * Represents the opening {@literal "<"} symbol of an HTML start tag.
1499 *
1500 * <p><b>Example:</b></p>
1501 * <pre>{@code
1502 * <div class="container" lang="en"></div>
1503 * }</pre>
1504 *
1505 * <b>Tree:</b>
1506 * <pre>{@code
1507 * HTML_ELEMENT -> HTML_ELEMENT
1508 * |--HTML_TAG_START -> HTML_TAG_START
1509 * | |--TAG_OPEN -> <
1510 * | |--TAG_NAME -> div
1511 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES
1512 * | | |--HTML_ATTRIBUTE -> HTML_ATTRIBUTE
1513 * | | | |--TAG_ATTR_NAME -> class
1514 * | | | |--EQUALS -> =
1515 * | | | `--ATTRIBUTE_VALUE -> "container"
1516 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE
1517 * | | |--TAG_ATTR_NAME -> lang
1518 * | | |--EQUALS -> =
1519 * | | `--ATTRIBUTE_VALUE -> "en"
1520 * | `--TAG_CLOSE -> >
1521 * `--HTML_TAG_END -> HTML_TAG_END
1522 * |--TAG_OPEN -> <
1523 * |--TAG_SLASH -> /
1524 * |--TAG_NAME -> div
1525 * `--TAG_CLOSE -> >
1526 * }</pre>
1527 *
1528 * @see #HTML_TAG_START
1529 */
1530 public static final int TAG_OPEN = JavadocCommentsLexer.TAG_OPEN;
1531
1532 /**
1533 * {@code TAG_NAME} Name of an HTML element.
1534 *
1535 * <p>Appears inside an HTML tag within Javadoc comments.</p>
1536 *
1537 * <p><b>Example:</b></p>
1538 * <pre>{@code
1539 * <div class="container">
1540 * Content
1541 * </div>
1542 * }</pre>
1543 *
1544 * <b>Tree:</b>
1545 * <pre>{@code
1546 * HTML_ELEMENT -> HTML_ELEMENT
1547 * |--HTML_TAG_START -> HTML_TAG_START
1548 * | |--TAG_OPEN -> <
1549 * | |--TAG_NAME -> div
1550 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES
1551 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE
1552 * | | |--TAG_ATTR_NAME -> class
1553 * | | |--EQUALS -> =
1554 * | | `--ATTRIBUTE_VALUE -> "container"
1555 * | `--TAG_CLOSE -> >
1556 * |--HTML_CONTENT -> HTML_CONTENT
1557 * | `--TEXT -> Content
1558 * `--HTML_TAG_END -> HTML_TAG_END
1559 * |--TAG_OPEN -> <
1560 * |--TAG_SLASH -> /
1561 * |--TAG_NAME -> div
1562 * `--TAG_CLOSE -> >
1563 * }</pre>
1564 *
1565 * <p>Here {@code TAG_NAME} corresponds to {@code "div"}.</p>
1566 */
1567 public static final int TAG_NAME = JavadocCommentsLexer.TAG_NAME;
1568
1569 /**
1570 * {@code TAG_CLOSE} represents the closing {@literal ">"} symbol
1571 * of an HTML tag.
1572 *
1573 * <p>Appears in Javadoc comments when documenting HTML elements.</p>
1574 *
1575 * <p><b>Example:</b></p>
1576 * <pre>{@code
1577 * <p>Some text</p>
1578 * }</pre>
1579 *
1580 * <b>Tree:</b>
1581 * <pre>{@code
1582 * HTML_ELEMENT -> HTML_ELEMENT
1583 * |--HTML_TAG_START -> HTML_TAG_START
1584 * | |--TAG_OPEN -> <
1585 * | |--TAG_NAME -> p
1586 * | `--TAG_CLOSE -> >
1587 * |--HTML_CONTENT -> HTML_CONTENT
1588 * | `--TEXT -> Some text
1589 * `--HTML_TAG_END -> HTML_TAG_END
1590 * |--TAG_OPEN -> <
1591 * |--TAG_SLASH -> /
1592 * |--TAG_NAME -> p
1593 * `--TAG_CLOSE -> >
1594 * }</pre>
1595 *
1596 * @see #HTML_TAG_START
1597 */
1598 public static final int TAG_CLOSE = JavadocCommentsLexer.TAG_CLOSE;
1599
1600 /**
1601 * {@code />} Self-closing tag delimiter.
1602 *
1603 * <p>Used for void HTML elements.</p>
1604 *
1605 * <p><b>Example:</b></p>
1606 * <pre>{@code * <br />}</pre>
1607 *
1608 * <b>Tree:</b>
1609 * <pre>{@code
1610 * VOID_ELEMENT -> VOID_ELEMENT
1611 * |--TAG_OPEN -> <
1612 * |--TAG_NAME -> br
1613 * `--TAG_SLASH_CLOSE -> />
1614 * }</pre>
1615 *
1616 * @see #HTML_ELEMENT
1617 */
1618 public static final int TAG_SLASH_CLOSE = JavadocCommentsLexer.TAG_SLASH_CLOSE;
1619
1620 /**
1621 * {@code TAG_SLASH} represents the slash {@literal "/"} used
1622 * inside an HTML closing tag.
1623 *
1624 * <p>Appears in Javadoc comments when closing HTML elements.</p>
1625 *
1626 * <p><b>Example:</b></p>
1627 * <pre>{@code
1628 * <p>Paragraph text</p>
1629 * }</pre>
1630 *
1631 * <b>Tree:</b>
1632 * <pre>{@code
1633 * HTML_ELEMENT -> HTML_ELEMENT
1634 * |--HTML_TAG_START -> HTML_TAG_START
1635 * | |--TAG_OPEN -> <
1636 * | |--TAG_NAME -> p
1637 * | `--TAG_CLOSE -> >
1638 * |--HTML_CONTENT -> HTML_CONTENT
1639 * | `--TEXT -> Paragraph text
1640 * `--HTML_TAG_END -> HTML_TAG_END
1641 * |--TAG_OPEN -> <
1642 * |--TAG_SLASH -> /
1643 * |--TAG_NAME -> p
1644 * `--TAG_CLOSE -> >
1645 * }</pre>
1646 *
1647 * @see #HTML_TAG_END
1648 */
1649 public static final int TAG_SLASH = JavadocCommentsLexer.TAG_SLASH;
1650
1651 /**
1652 * {@code TAG_ATTR_NAME} represents the name of an attribute inside an
1653 * HTML element within a Javadoc comment.
1654 *
1655 * <p><b>Example:</b></p>
1656 * <pre>{@code
1657 * <img src="logo.png" alt="Site logo">
1658 * }</pre>
1659 *
1660 * <p><b>Tree:</b></p>
1661 * <pre>{@code
1662 * HTML_ELEMENT -> HTML_ELEMENT
1663 * `--VOID_ELEMENT -> VOID_ELEMENT
1664 * `--HTML_TAG_START -> HTML_TAG_START
1665 * |--TAG_OPEN -> <
1666 * |--TAG_NAME -> img
1667 * |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES
1668 * | |--HTML_ATTRIBUTE -> HTML_ATTRIBUTE
1669 * | | |--TEXT ->
1670 * | | |--TAG_ATTR_NAME -> src
1671 * | | |--EQUALS -> =
1672 * | | `--ATTRIBUTE_VALUE -> "logo.png"
1673 * | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE
1674 * | |--TEXT ->
1675 * | |--TAG_ATTR_NAME -> alt
1676 * | |--EQUALS -> =
1677 * | `--ATTRIBUTE_VALUE -> "Site logo"
1678 * `--TAG_CLOSE -> >
1679 * }</pre>
1680 *
1681 * @see #HTML_ATTRIBUTES
1682 */
1683 public static final int TAG_ATTR_NAME = JavadocCommentsLexer.TAG_ATTR_NAME;
1684
1685 /**
1686 * Start of an HTML comment node.
1687 *
1688 * <p>This node represents a full HTML comment inside Javadoc.</p>
1689 *
1690 * <p>This node has three children:</p>
1691 * <ol>
1692 * <li>{@link #HTML_COMMENT_START}</li>
1693 * <li>{@link #HTML_COMMENT_CONTENT}</li>
1694 * <li>{@link #HTML_COMMENT_END}</li>
1695 * </ol>
1696 *
1697 * <p><b>Example:</b></p>
1698 * <pre>{@code * <!-- Hello World! -->}</pre>
1699 *
1700 * <b>Tree:</b>
1701 * <pre>{@code
1702 * JAVADOC_CONTENT -> JAVADOC_CONTENT
1703 * |--TEXT -> /**
1704 * |--NEWLINE -> \r\n
1705 * |--LEADING_ASTERISK -> *
1706 * |--TEXT ->
1707 * |--HTML_COMMENT -> HTML_COMMENT
1708 * |--HTML_COMMENT_START -> <!--
1709 * |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT
1710 * | `--TEXT -> Hello World!
1711 * `--HTML_COMMENT_END -> -->
1712 * |--NEWLINE -> \r\n
1713 * |--LEADING_ASTERISK -> *
1714 * |--TEXT -> /
1715 * }</pre>
1716 *
1717 * @see #HTML_COMMENT
1718 */
1719 public static final int HTML_COMMENT = JavadocCommentsLexer.HTML_COMMENT;
1720
1721 /**
1722 * {@code HTML_COMMENT_START} represents the beginning of an HTML comment,
1723 * i.e., the {@literal "<!--"} sequence inside a Javadoc comment.
1724 *
1725 * <p>HTML comments occasionally appear in Javadoc to add internal notes or
1726 * explanations without affecting the rendered output.</p>
1727 * Example: {@code <!-- Note: This method is for demonstration purposes only. -->}
1728 *
1729 * <p><b>Tree:</b></p>
1730 * <pre>{@code
1731 * HTML_COMMENT -> HTML_COMMENT
1732 * |--HTML_COMMENT_START -> <!--
1733 * |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT
1734 * | `--TEXT -> Note: This method is for demonstration purposes only.
1735 * `--HTML_COMMENT_END -> -->
1736 * }</pre>
1737 *
1738 * @see #HTML_COMMENT_END
1739 */
1740 public static final int HTML_COMMENT_START = JavadocCommentsLexer.HTML_COMMENT_START;
1741
1742 /**
1743 * Closing part of an HTML comment.
1744 *
1745 * <p>This node represents the closing delimiter of an HTML comment in
1746 * Javadoc (for example {@code -->}).</p>
1747 *
1748 * <p><b>Example:</b></p>
1749 * <pre>{@code * <!-- hidden comment -->}</pre>
1750 *
1751 * <b>Tree:</b>
1752 * <pre>{@code
1753 * |--LEADING_ASTERISK -> *
1754 * |--TEXT ->
1755 * |--HTML_COMMENT -> HTML_COMMENT
1756 * | |--HTML_COMMENT_START -> <!--
1757 * | |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT
1758 * | | `--TEXT -> hidden comment
1759 * | `--HTML_COMMENT_END -> -->
1760 * }</pre>
1761 *
1762 * @see #HTML_COMMENT
1763 */
1764
1765 public static final int HTML_COMMENT_END = JavadocCommentsLexer.HTML_COMMENT_END;
1766
1767 /**
1768 * {@code HTML_COMMENT_CONTENT} Content inside an HTML comment.
1769 *
1770 * <p>Text within an HTML comment.</p>
1771 *
1772 * <p><b>Example:</b> {@code <!-- This is a comment -->}</p>
1773 *
1774 * <p><b>Tree:</b></p>
1775 * <pre>{@code
1776 * HTML_COMMENT -> HTML_COMMENT
1777 * |--HTML_COMMENT_START -> <!--
1778 * |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT
1779 * | `--TEXT -> This is a comment
1780 * `--HTML_COMMENT_END -> -->
1781 * }</pre>
1782 *
1783 * @see #HTML_COMMENT
1784 */
1785 public static final int HTML_COMMENT_CONTENT = JavadocCommentsLexer.HTML_COMMENT_CONTENT;
1786
1787 /** Empty private constructor of the current class. */
1788 private JavadocCommentsTokenTypes() {
1789 }
1790 }