001/////////////////////////////////////////////////////////////////////////////////////////////// 002// checkstyle: Checks Java source code and other text files for adherence to a set of rules. 003// Copyright (C) 2001-2026 the original author or authors. 004// 005// This library is free software; you can redistribute it and/or 006// modify it under the terms of the GNU Lesser General Public 007// License as published by the Free Software Foundation; either 008// version 2.1 of the License, or (at your option) any later version. 009// 010// This library is distributed in the hope that it will be useful, 011// but WITHOUT ANY WARRANTY; without even the implied warranty of 012// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 013// Lesser General Public License for more details. 014// 015// You should have received a copy of the GNU Lesser General Public 016// License along with this library; if not, write to the Free Software 017// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 018/////////////////////////////////////////////////////////////////////////////////////////////// 019 020package com.puppycrawl.tools.checkstyle.api; 021 022import com.puppycrawl.tools.checkstyle.grammar.javadoc.JavadocCommentsLexer; 023 024/** 025 * Contains the constants for all the tokens contained in the Abstract 026 * Syntax Tree for the javadoc grammar. 027 * 028 * @see <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html"> 029 * javadoc - The Java API Documentation Generator</a> 030 */ 031public final class JavadocCommentsTokenTypes { 032 033 /** 034 * Root node of any Javadoc comment. 035 * 036 * <p><b>Tree for example:</b></p> 037 * <pre>{@code 038 * JAVADOC_CONTENT -> JAVADOC_CONTENT 039 * |--LEADING_ASTERISK -> * 040 * |--NEWLINE -> \n 041 * |--LEADING_ASTERISK -> * 042 * |--NEWLINE -> \n 043 * |--LEADING_ASTERISK -> * 044 * `--NEWLINE -> \n 045 * }</pre> 046 */ 047 public static final int JAVADOC_CONTENT = JavadocCommentsLexer.JAVADOC; 048 049 /** 050 * Leading asterisk used to format Javadoc lines. 051 * 052 * <p><b>Example:</b></p> 053 * <pre>{@code 054 * /** 055 * * This is a Javadoc line. 056 * * / 057 * }</pre> 058 * 059 * <p><b>Tree:</b></p> 060 * <pre>{@code 061 * --BLOCK_COMMENT_BEGIN -> /** 062 * |--COMMENT_CONTENT -> *\r\n * This is a Javadoc line.\r\n 063 * | `--JAVADOC_CONTENT -> JAVADOC_CONTENT 064 * | |--NEWLINE -> \r\n 065 * | |--LEADING_ASTERISK -> * 066 * | |--TEXT -> This is a Javadoc line. 067 * | |--NEWLINE -> \r\n 068 * | `--TEXT -> 069 * ` --BLOCK_COMMENT_END -> * 070 * }</pre> 071 */ 072 public static final int LEADING_ASTERISK = JavadocCommentsLexer.LEADING_ASTERISK; 073 074 /** 075 * Newline character in a Javadoc comment. 076 */ 077 public static final int NEWLINE = JavadocCommentsLexer.NEWLINE; 078 079 /** 080 * Plain text content within a Javadoc comment. 081 */ 082 public static final int TEXT = JavadocCommentsLexer.TEXT; 083 084 // Block tags 085 086 /** 087 * General block tag (e.g. {@code @param}, {@code @return}). 088 */ 089 public static final int JAVADOC_BLOCK_TAG = JavadocCommentsLexer.JAVADOC_BLOCK_TAG; 090 091 /** 092 * At-sign {@code @} that starts a block tag. 093 * 094 * <p><b>Example:</b></p> 095 * <pre>{@code * @author name}</pre> 096 * 097 * <b>Tree:</b> 098 * <pre>{@code 099 * |--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}