001/////////////////////////////////////////////////////////////////////////////////////////////// 002// checkstyle: Checks Java source code and other text files for adherence to a set of rules. 003// Copyright (C) 2001-2025 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 * Custom or unrecognized inline tag. 924 */ 925 public static final int CUSTOM_INLINE_TAG = JavadocCommentsLexer.CUSTOM_INLINE_TAG; 926 927 // Components 928 929 /** 930 * Identifier token. 931 */ 932 public static final int IDENTIFIER = JavadocCommentsLexer.IDENTIFIER; 933 934 /** 935 * Hash symbol {@code #} used in references. 936 */ 937 public static final int HASH = JavadocCommentsLexer.HASH; 938 939 /** 940 * Left parenthesis {@code ( }. 941 */ 942 public static final int LPAREN = JavadocCommentsLexer.LPAREN; 943 944 /** 945 * Right parenthesis {@code ) }. 946 */ 947 public static final int RPAREN = JavadocCommentsLexer.RPAREN; 948 949 /** 950 * Comma symbol {@code , }. 951 */ 952 public static final int COMMA = JavadocCommentsLexer.COMMA; 953 954 /** 955 * Slash symbol {@code / }. 956 */ 957 public static final int SLASH = JavadocCommentsLexer.SLASH; 958 959 /** 960 * Question mark symbol {@code ? }. 961 */ 962 public static final int QUESTION = JavadocCommentsLexer.QUESTION; 963 964 /** 965 * Less-than symbol {@code < }. 966 */ 967 public static final int LT = JavadocCommentsLexer.LT; 968 969 /** 970 * Greater-than symbol {@code > }. 971 */ 972 public static final int GT = JavadocCommentsLexer.GT; 973 974 /** 975 * {@code extends} keyword inside type arguments of a Javadoc inline tag. 976 * 977 * <p>This node represents the {@code extends} bound used inside a 978 * parameterized type within an inline Javadoc tag.</p> 979 * 980 * <p><b>Example:</b></p> 981 * <pre>{@code 982 * * {@link java.util.List<? extends Number> list of any subtype of Number} 983 * }</pre> 984 * 985 * <b>Tree:</b> 986 * <pre>{@code 987 * |--LEADING_ASTERISK -> * 988 * |--TEXT -> 989 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 990 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 991 * |--JAVADOC_INLINE_TAG_START -> { @ 992 * |--TAG_NAME -> link 993 * |--TEXT -> 994 * |--REFERENCE -> REFERENCE 995 * | |--IDENTIFIER -> java.util.List 996 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 997 * | |--LT -> < 998 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 999 * | | |--QUESTION -> ? 1000 * | | |--TEXT -> 1001 * | | |--EXTENDS -> extends 1002 * | | |--TEXT -> 1003 * | | `--IDENTIFIER -> Number 1004 * | `--GT -> > 1005 * |--DESCRIPTION -> DESCRIPTION 1006 * | `--TEXT -> list of any subtype of Number 1007 * `--JAVADOC_INLINE_TAG_END -> } 1008 * }</pre> 1009 * 1010 * @see #JAVADOC_INLINE_TAG 1011 */ 1012 public static final int EXTENDS = JavadocCommentsLexer.EXTENDS; 1013 1014 /** 1015 * {@code SUPER} represents the {@code super} keyword inside a generic 1016 * wildcard bound (e.g., {@code ? super Number}). 1017 * 1018 * <p><b>Example:</b> {@code {@link java.util.List <? super Integer> list} 1019 * of any supertype of Integer}</p> 1020 * 1021 * <p><b>Tree:</b></p> 1022 * <pre>{@code 1023 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1024 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1025 * |--JAVADOC_INLINE_TAG_START -> { @ 1026 * |--TAG_NAME -> link 1027 * |--TEXT -> 1028 * |--REFERENCE -> REFERENCE 1029 * | |--IDENTIFIER -> java.util.List 1030 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1031 * | |--LT -> < 1032 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1033 * | | |--QUESTION -> ? 1034 * | | |--TEXT -> 1035 * | | |--SUPER -> super 1036 * | | |--TEXT -> 1037 * | | `--IDENTIFIER -> Integer 1038 * | `--GT -> > 1039 * |--DESCRIPTION -> DESCRIPTION 1040 * | `--TEXT -> list of any supertype of Integer 1041 * `--JAVADOC_INLINE_TAG_END -> } 1042 * }</pre> 1043 * 1044 * @see #PARAMETER_TYPE 1045 */ 1046 public static final int SUPER = JavadocCommentsLexer.SUPER; 1047 1048 /** 1049 * {@code PARAMETER_TYPE} Parameter type reference. 1050 * 1051 * <p>Represents a type used in a method parameter.</p> 1052 * 1053 * <p><b>Example:</b></p> 1054 * <pre>{@code {@link java.util.List#add(Object)}} </pre> 1055 * 1056 * <b>Tree:</b> 1057 * <pre>{@code 1058 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1059 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1060 * |--JAVADOC_INLINE_TAG_START -> {@ 1061 * |--TAG_NAME -> link 1062 * |--REFERENCE -> REFERENCE 1063 * | |--IDENTIFIER -> List 1064 * | |--HASH -> # 1065 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1066 * | |--IDENTIFIER -> add 1067 * | |--LPAREN -> ( 1068 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST 1069 * | | `--PARAMETER_TYPE -> Object 1070 * | `--RPAREN -> ) 1071 * `--JAVADOC_INLINE_TAG_END -> } 1072 * }</pre> 1073 * 1074 * @see #REFERENCE 1075 */ 1076 public static final int PARAMETER_TYPE = JavadocCommentsLexer.PARAMETER_TYPE; 1077 1078 /** 1079 * {@code REFERENCE} General reference within Javadoc. 1080 * 1081 * <p>Represents the target of an inline reference tag such as 1082 * {@code {@link String#length()}}.</p> 1083 * 1084 * <p><b>Example:</b></p> 1085 * <pre>{@code 1086 * {@link String#length()} 1087 * }</pre> 1088 * 1089 * <b>Tree:</b> 1090 * <pre>{@code 1091 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1092 * |--LINK_INLINE_TAG -> LINK_INLINE_TAG 1093 * | |--JAVADOC_INLINE_TAG_START -> {@ 1094 * | |--TAG_NAME -> link 1095 * | `--REFERENCE -> String#length() 1096 * }</pre> 1097 * 1098 * @see #JAVADOC_INLINE_TAG 1099 */ 1100 public static final int REFERENCE = JavadocCommentsLexer.REFERENCE; 1101 1102 /** 1103 * {@code MEMBER_REFERENCE} Member reference (method or field). 1104 * 1105 * <p>Represents a field or method in a type reference.</p> 1106 * 1107 * <p><b>Example:</b></p> 1108 * <pre>{@code 1109 * {@link String#length()} 1110 * }</pre> 1111 * 1112 * <p><b>Tree:</b></p> 1113 * <pre>{@code 1114 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1115 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1116 * |--JAVADOC_INLINE_TAG_START -> {@ 1117 * |--TAG_NAME -> link 1118 * |--TEXT -> 1119 * |--REFERENCE -> REFERENCE 1120 * | |--IDENTIFIER -> String 1121 * | |--HASH -> # 1122 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1123 * | |--IDENTIFIER -> length 1124 * | |--LPAREN -> ( 1125 * | `--RPAREN -> ) 1126 * `--JAVADOC_INLINE_TAG_END -> } 1127 * }</pre> 1128 * 1129 * @see #REFERENCE 1130 */ 1131 public static final int MEMBER_REFERENCE = JavadocCommentsLexer.MEMBER_REFERENCE; 1132 1133 /** 1134 * {@code PARAMETER_TYPE_LIST} represents the list of parameter types inside a 1135 * member reference within a Javadoc inline {@code @link} tag. 1136 * 1137 * <p><b>Example:</b></p> 1138 * <pre>{@code 1139 * {@link Math#max(int, int)} 1140 * }</pre> 1141 * 1142 * <p><b>Tree:</b></p> 1143 * <pre>{@code 1144 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1145 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1146 * |--JAVADOC_INLINE_TAG_START -> {\@ 1147 * |--TAG_NAME -> link 1148 * |--TEXT -> 1149 * |--REFERENCE -> REFERENCE 1150 * | |--IDENTIFIER -> Math 1151 * | |--HASH -> # 1152 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 1153 * | |--IDENTIFIER -> max 1154 * | |--LPAREN -> ( 1155 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST 1156 * | | |--PARAMETER_TYPE -> int 1157 * | | |--COMMA -> , 1158 * | | |--TEXT -> 1159 * | | `--PARAMETER_TYPE -> int 1160 * | `--RPAREN -> ) 1161 * `--JAVADOC_INLINE_TAG_END -> } 1162 * }</pre> 1163 * 1164 * @see #PARAMETER_TYPE 1165 */ 1166 public static final int PARAMETER_TYPE_LIST = JavadocCommentsLexer.PARAMETER_TYPE_LIST; 1167 1168 /** 1169 * {@code TYPE_ARGUMENTS} Type arguments in generics. 1170 * 1171 * <p>Represents the type arguments inside a generic type reference.</p> 1172 * 1173 * <p><b>Example:</b></p> 1174 * <pre>{@code {@link java.util.List<String>}}</pre> 1175 * 1176 * <p><b>Tree:</b></p> 1177 * <pre>{@code 1178 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1179 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 1180 * |--JAVADOC_INLINE_TAG_START -> {@ 1181 * |--TAG_NAME -> link 1182 * |--TEXT -> 1183 * |--REFERENCE -> REFERENCE 1184 * | |--IDENTIFIER -> java.util.List 1185 * | `--TYPE_ARGUMENTS -> TYPE_ARGUMENTS 1186 * | |--LT -> < 1187 * | |--TYPE_ARGUMENT -> TYPE_ARGUMENT 1188 * | | `--IDENTIFIER -> String 1189 * | `--GT -> > 1190 * `--JAVADOC_INLINE_TAG_END -> } 1191 * }</pre> 1192 * 1193 * @see #TYPE_ARGUMENT 1194 */ 1195 public static final int TYPE_ARGUMENTS = JavadocCommentsLexer.TYPE_ARGUMENTS; 1196 1197 /** 1198 * Single type argument in generics. 1199 */ 1200 public static final int TYPE_ARGUMENT = JavadocCommentsLexer.TYPE_ARGUMENT; 1201 1202 /** 1203 * Description part of a Javadoc tag. 1204 */ 1205 public static final int DESCRIPTION = JavadocCommentsLexer.DESCRIPTION; 1206 1207 /** 1208 * Format specifier inside Javadoc content. 1209 */ 1210 public static final int FORMAT_SPECIFIER = JavadocCommentsLexer.FORMAT_SPECIFIER; 1211 1212 /** 1213 * Attribute name in a {@code @snippet}. 1214 */ 1215 public static final int SNIPPET_ATTR_NAME = JavadocCommentsLexer.SNIPPET_ATTR_NAME; 1216 1217 /** 1218 * Equals sign {@code = }. 1219 */ 1220 public static final int EQUALS = JavadocCommentsLexer.EQUALS; 1221 1222 /** 1223 * {@code ATTRIBUTE_VALUE} Value assigned to an attribute. 1224 * 1225 * <p><b>Example:</b></p> 1226 * <pre>{@code <a href="example">text</a>}</pre> 1227 * 1228 * <p><b>Tree:</b></p> 1229 * <pre>{@code 1230 * HTML_ELEMENT -> HTML_ELEMENT 1231 * |--HTML_TAG_START -> HTML_TAG_START 1232 * | |--TAG_OPEN -> < 1233 * | |--TAG_NAME -> a 1234 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 1235 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1236 * | | |--TEXT -> 1237 * | | |--TAG_ATTR_NAME -> href 1238 * | | |--EQUALS -> = 1239 * | | `--ATTRIBUTE_VALUE -> "example" 1240 * | `--TAG_CLOSE -> > 1241 * |--HTML_CONTENT -> HTML_CONTENT 1242 * | `--TEXT -> text 1243 * `--HTML_TAG_END -> HTML_TAG_END 1244 * |--TAG_OPEN -> < 1245 * |--TAG_SLASH -> / 1246 * |--TAG_NAME -> a 1247 * `--TAG_CLOSE -> > 1248 * }</pre> 1249 * 1250 * @see #HTML_ATTRIBUTE 1251 * @see #TAG_ATTR_NAME 1252 */ 1253 public static final int ATTRIBUTE_VALUE = JavadocCommentsLexer.ATTRIBUTE_VALUE; 1254 1255 /** 1256 * Colon symbol {@code : }. 1257 */ 1258 public static final int COLON = JavadocCommentsLexer.COLON; 1259 1260 /** 1261 * Term used in {@code {@index}} tag. 1262 */ 1263 public static final int INDEX_TERM = JavadocCommentsLexer.INDEX_TERM; 1264 1265 /** 1266 * Single snippet attribute. 1267 */ 1268 public static final int SNIPPET_ATTRIBUTE = JavadocCommentsLexer.SNIPPET_ATTRIBUTE; 1269 1270 /** 1271 * Collection of snippet attributes. 1272 */ 1273 public static final int SNIPPET_ATTRIBUTES = JavadocCommentsLexer.SNIPPET_ATTRIBUTES; 1274 1275 /** 1276 * Body content of a {@code @snippet}. 1277 */ 1278 public static final int SNIPPET_BODY = JavadocCommentsLexer.SNIPPET_BODY; 1279 1280 /** 1281 * Field type reference. 1282 */ 1283 public static final int FIELD_TYPE = JavadocCommentsLexer.FIELD_TYPE; 1284 1285 /** 1286 * Parameter name reference. 1287 */ 1288 public static final int PARAMETER_NAME = JavadocCommentsLexer.PARAMETER_NAME; 1289 1290 /** 1291 * String literal inside Javadoc. 1292 */ 1293 public static final int STRING_LITERAL = JavadocCommentsLexer.STRING_LITERAL; 1294 1295 // HTML 1296 1297 /** 1298 * General HTML element. 1299 */ 1300 public static final int HTML_ELEMENT = JavadocCommentsLexer.HTML_ELEMENT; 1301 1302 /** 1303 * Void HTML element (self-closing). 1304 */ 1305 public static final int VOID_ELEMENT = JavadocCommentsLexer.VOID_ELEMENT; 1306 1307 /** 1308 * Content inside an HTML element. 1309 * 1310 * <p>This node represents the textual content between an HTML start tag and 1311 * the corresponding end tag inside a Javadoc comment.</p> 1312 * 1313 * <p><b>Example:</b></p> 1314 * <pre>{@code * <a href="https://example.com">link</a>}</pre> 1315 * 1316 * <b>Tree:</b> 1317 * <pre>{@code 1318 * |--LEADING_ASTERISK -> * 1319 * `--HTML_ELEMENT -> HTML_ELEMENT 1320 * |--HTML_TAG_START -> HTML_TAG_START 1321 * | |--TAG_OPEN -> < 1322 * | |--TAG_NAME -> a 1323 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 1324 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1325 * | | |--TEXT -> (whitespace) 1326 * | | |--TAG_ATTR_NAME -> href 1327 * | | |--EQUALS -> = 1328 * | | `--ATTRIBUTE_VALUE -> "https://example.com" 1329 * | `--TAG_CLOSE -> > 1330 * |--HTML_CONTENT -> HTML_CONTENT 1331 * | `--TEXT -> link 1332 * `--HTML_TAG_END -> HTML_TAG_END 1333 * |--TAG_OPEN -> < 1334 * |--TAG_SLASH -> / 1335 * |--TAG_NAME -> a 1336 * `--TAG_CLOSE -> > 1337 * }</pre> 1338 * 1339 * @see #HTML_ELEMENT 1340 */ 1341 1342 public static final int HTML_CONTENT = JavadocCommentsLexer.HTML_CONTENT; 1343 1344 /** 1345 * {@code HTML_ATTRIBUTE} Single HTML attribute. 1346 * 1347 * <p>Represents one attribute inside an HTML tag.</p> 1348 * 1349 * <p><b>Example:</b></p> 1350 * <pre>{@code 1351 * <input type="text"> 1352 * }</pre> 1353 * 1354 * <b>Tree:</b> 1355 * <pre>{@code 1356 * HTML_ELEMENT -> HTML_ELEMENT 1357 * `--VOID_ELEMENT -> VOID_ELEMENT 1358 * `--HTML_TAG_START -> HTML_TAG_START 1359 * |--TAG_OPEN -> < 1360 * |--TAG_NAME -> input 1361 * |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 1362 * | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1363 * | |--TEXT -> 1364 * | |--TAG_ATTR_NAME -> type 1365 * | |--EQUALS -> = 1366 * | `--ATTRIBUTE_VALUE -> "text" 1367 * `--TAG_CLOSE -> > 1368 * }</pre> 1369 * 1370 * @see #HTML_ATTRIBUTES 1371 */ 1372 public static final int HTML_ATTRIBUTE = JavadocCommentsLexer.HTML_ATTRIBUTE; 1373 1374 /** 1375 * {@code HTML_ATTRIBUTES} represents a collection of HTML attributes 1376 * inside an HTML tag. 1377 * 1378 * <p>Appears in Javadoc comments when documenting HTML elements that contain 1379 * multiple attributes.</p> 1380 * 1381 * <p><b>Example:</b></p> 1382 * <pre>{@code 1383 * <div lang="en" custom-attr="value"></div> 1384 * }</pre> 1385 * 1386 * <p><b>Tree:</b></p> 1387 * <pre>{@code 1388 * HTML_ELEMENT -> HTML_ELEMENT 1389 * |--HTML_TAG_START -> HTML_TAG_START 1390 * | |--TAG_OPEN -> < 1391 * | |--TAG_NAME -> div 1392 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 1393 * | | |--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1394 * | | | |--TEXT -> 1395 * | | | |--TAG_ATTR_NAME -> lang 1396 * | | | |--EQUALS -> = 1397 * | | | `--ATTRIBUTE_VALUE -> "en" 1398 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1399 * | | |--TEXT -> 1400 * | | |--TAG_ATTR_NAME -> custom-attr 1401 * | | |--EQUALS -> = 1402 * | | `--ATTRIBUTE_VALUE -> "value" 1403 * | `--TAG_CLOSE -> > 1404 * }</pre> 1405 * 1406 * @see #HTML_ATTRIBUTE 1407 */ 1408 public static final int HTML_ATTRIBUTES = JavadocCommentsLexer.HTML_ATTRIBUTES; 1409 1410 /** 1411 * Start of an HTML tag (the opening tag node). 1412 * 1413 * <p>This node represents the opening part of an HTML element and contains 1414 * the opening delimiter, tag name, optional attributes, and the closing 1415 * delimiter of the opening tag.</p> 1416 * 1417 * <p><b>Example:</b></p> 1418 * <pre>{@code * <a href="https://example.com">link</a>}</pre> 1419 * 1420 * <b>Tree:</b> 1421 * <pre>{@code 1422 * |--LEADING_ASTERISK -> * 1423 * `--HTML_ELEMENT -> HTML_ELEMENT 1424 * `--HTML_TAG_START -> HTML_TAG_START 1425 * |--TAG_OPEN -> < 1426 * |--TAG_NAME -> a 1427 * |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 1428 * | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1429 * | |--TEXT -> 1430 * | |--TAG_ATTR_NAME -> href 1431 * | |--EQUALS -> = 1432 * | `--ATTRIBUTE_VALUE -> "https://example.com" 1433 * `--TAG_CLOSE -> > 1434 * }</pre> 1435 * 1436 * @see #HTML_ELEMENT 1437 */ 1438 1439 public static final int HTML_TAG_START = JavadocCommentsLexer.HTML_TAG_START; 1440 1441 /** 1442 * End of an HTML tag (the closing tag node). 1443 * 1444 * <p>This node represents the closing part of an HTML element and contains the 1445 * closing delimiter, optional slash, and the tag name.</p> 1446 * 1447 * <p><b>Example:</b></p> 1448 * <pre>{@code * <a href="https://example.com">link</a>}</pre> 1449 * 1450 * <b>Tree:</b> 1451 * <pre>{@code 1452 * |--LEADING_ASTERISK -> * 1453 * `--HTML_ELEMENT -> HTML_ELEMENT 1454 * |--HTML_TAG_START -> HTML_TAG_START 1455 * | |--TAG_OPEN -> < 1456 * | |--TAG_NAME -> a 1457 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 1458 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1459 * | | |--TEXT -> (whitespace) 1460 * | | |--TAG_ATTR_NAME -> href 1461 * | | |--EQUALS -> = 1462 * | | `--ATTRIBUTE_VALUE -> "https://example.com" 1463 * | `--TAG_CLOSE -> > 1464 * |--HTML_CONTENT -> HTML_CONTENT 1465 * | `--TEXT -> link 1466 * `--HTML_TAG_END -> HTML_TAG_END 1467 * |--TAG_OPEN -> < 1468 * |--TAG_SLASH -> / 1469 * |--TAG_NAME -> a 1470 * `--TAG_CLOSE -> > 1471 * }</pre> 1472 * 1473 * @see #HTML_ELEMENT 1474 */ 1475 1476 public static final int HTML_TAG_END = JavadocCommentsLexer.HTML_TAG_END; 1477 1478 /** 1479 * Represents the opening {@literal "<"} symbol of an HTML start tag. 1480 * 1481 * <p><b>Example:</b></p> 1482 * <pre>{@code 1483 * <div class="container" lang="en"></div> 1484 * }</pre> 1485 * 1486 * <b>Tree:</b> 1487 * <pre>{@code 1488 * HTML_ELEMENT -> HTML_ELEMENT 1489 * |--HTML_TAG_START -> HTML_TAG_START 1490 * | |--TAG_OPEN -> < 1491 * | |--TAG_NAME -> div 1492 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 1493 * | | |--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1494 * | | | |--TAG_ATTR_NAME -> class 1495 * | | | |--EQUALS -> = 1496 * | | | `--ATTRIBUTE_VALUE -> "container" 1497 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1498 * | | |--TAG_ATTR_NAME -> lang 1499 * | | |--EQUALS -> = 1500 * | | `--ATTRIBUTE_VALUE -> "en" 1501 * | `--TAG_CLOSE -> > 1502 * `--HTML_TAG_END -> HTML_TAG_END 1503 * |--TAG_OPEN -> < 1504 * |--TAG_SLASH -> / 1505 * |--TAG_NAME -> div 1506 * `--TAG_CLOSE -> > 1507 * }</pre> 1508 * 1509 * @see #HTML_TAG_START 1510 */ 1511 public static final int TAG_OPEN = JavadocCommentsLexer.TAG_OPEN; 1512 1513 /** 1514 * {@code TAG_NAME} Name of an HTML element. 1515 * 1516 * <p>Appears inside an HTML tag within Javadoc comments.</p> 1517 * 1518 * <p><b>Example:</b></p> 1519 * <pre>{@code 1520 * <div class="container"> 1521 * Content 1522 * </div> 1523 * }</pre> 1524 * 1525 * <b>Tree:</b> 1526 * <pre>{@code 1527 * HTML_ELEMENT -> HTML_ELEMENT 1528 * |--HTML_TAG_START -> HTML_TAG_START 1529 * | |--TAG_OPEN -> < 1530 * | |--TAG_NAME -> div 1531 * | |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 1532 * | | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1533 * | | |--TAG_ATTR_NAME -> class 1534 * | | |--EQUALS -> = 1535 * | | `--ATTRIBUTE_VALUE -> "container" 1536 * | `--TAG_CLOSE -> > 1537 * |--HTML_CONTENT -> HTML_CONTENT 1538 * | `--TEXT -> Content 1539 * `--HTML_TAG_END -> HTML_TAG_END 1540 * |--TAG_OPEN -> < 1541 * |--TAG_SLASH -> / 1542 * |--TAG_NAME -> div 1543 * `--TAG_CLOSE -> > 1544 * }</pre> 1545 * 1546 * <p>Here {@code TAG_NAME} corresponds to {@code "div"}.</p> 1547 */ 1548 public static final int TAG_NAME = JavadocCommentsLexer.TAG_NAME; 1549 1550 /** 1551 * {@code TAG_CLOSE} represents the closing {@literal ">"} symbol 1552 * of an HTML tag. 1553 * 1554 * <p>Appears in Javadoc comments when documenting HTML elements.</p> 1555 * 1556 * <p><b>Example:</b></p> 1557 * <pre>{@code 1558 * <p>Some text</p> 1559 * }</pre> 1560 * 1561 * <b>Tree:</b> 1562 * <pre>{@code 1563 * HTML_ELEMENT -> HTML_ELEMENT 1564 * |--HTML_TAG_START -> HTML_TAG_START 1565 * | |--TAG_OPEN -> < 1566 * | |--TAG_NAME -> p 1567 * | `--TAG_CLOSE -> > 1568 * |--HTML_CONTENT -> HTML_CONTENT 1569 * | `--TEXT -> Some text 1570 * `--HTML_TAG_END -> HTML_TAG_END 1571 * |--TAG_OPEN -> < 1572 * |--TAG_SLASH -> / 1573 * |--TAG_NAME -> p 1574 * `--TAG_CLOSE -> > 1575 * }</pre> 1576 * 1577 * @see #HTML_TAG_START 1578 */ 1579 public static final int TAG_CLOSE = JavadocCommentsLexer.TAG_CLOSE; 1580 1581 /** 1582 * {@code />} Self-closing tag delimiter. 1583 * 1584 * <p>Used for void HTML elements.</p> 1585 * 1586 * <p><b>Example:</b></p> 1587 * <pre>{@code * <br />}</pre> 1588 * 1589 * <b>Tree:</b> 1590 * <pre>{@code 1591 * VOID_ELEMENT -> VOID_ELEMENT 1592 * |--TAG_OPEN -> < 1593 * |--TAG_NAME -> br 1594 * `--TAG_SLASH_CLOSE -> /> 1595 * }</pre> 1596 * 1597 * @see #HTML_ELEMENT 1598 */ 1599 public static final int TAG_SLASH_CLOSE = JavadocCommentsLexer.TAG_SLASH_CLOSE; 1600 1601 /** 1602 * {@code TAG_SLASH} represents the slash {@literal "/"} used 1603 * inside an HTML closing tag. 1604 * 1605 * <p>Appears in Javadoc comments when closing HTML elements.</p> 1606 * 1607 * <p><b>Example:</b></p> 1608 * <pre>{@code 1609 * <p>Paragraph text</p> 1610 * }</pre> 1611 * 1612 * <b>Tree:</b> 1613 * <pre>{@code 1614 * HTML_ELEMENT -> HTML_ELEMENT 1615 * |--HTML_TAG_START -> HTML_TAG_START 1616 * | |--TAG_OPEN -> < 1617 * | |--TAG_NAME -> p 1618 * | `--TAG_CLOSE -> > 1619 * |--HTML_CONTENT -> HTML_CONTENT 1620 * | `--TEXT -> Paragraph text 1621 * `--HTML_TAG_END -> HTML_TAG_END 1622 * |--TAG_OPEN -> < 1623 * |--TAG_SLASH -> / 1624 * |--TAG_NAME -> p 1625 * `--TAG_CLOSE -> > 1626 * }</pre> 1627 * 1628 * @see #HTML_TAG_END 1629 */ 1630 public static final int TAG_SLASH = JavadocCommentsLexer.TAG_SLASH; 1631 1632 /** 1633 * {@code TAG_ATTR_NAME} represents the name of an attribute inside an 1634 * HTML element within a Javadoc comment. 1635 * 1636 * <p><b>Example:</b></p> 1637 * <pre>{@code 1638 * <img src="logo.png" alt="Site logo"> 1639 * }</pre> 1640 * 1641 * <p><b>Tree:</b></p> 1642 * <pre>{@code 1643 * HTML_ELEMENT -> HTML_ELEMENT 1644 * `--VOID_ELEMENT -> VOID_ELEMENT 1645 * `--HTML_TAG_START -> HTML_TAG_START 1646 * |--TAG_OPEN -> < 1647 * |--TAG_NAME -> img 1648 * |--HTML_ATTRIBUTES -> HTML_ATTRIBUTES 1649 * | |--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1650 * | | |--TEXT -> 1651 * | | |--TAG_ATTR_NAME -> src 1652 * | | |--EQUALS -> = 1653 * | | `--ATTRIBUTE_VALUE -> "logo.png" 1654 * | `--HTML_ATTRIBUTE -> HTML_ATTRIBUTE 1655 * | |--TEXT -> 1656 * | |--TAG_ATTR_NAME -> alt 1657 * | |--EQUALS -> = 1658 * | `--ATTRIBUTE_VALUE -> "Site logo" 1659 * `--TAG_CLOSE -> > 1660 * }</pre> 1661 * 1662 * @see #HTML_ATTRIBUTES 1663 */ 1664 public static final int TAG_ATTR_NAME = JavadocCommentsLexer.TAG_ATTR_NAME; 1665 1666 /** 1667 * Start of an HTML comment node. 1668 * 1669 * <p>This node represents a full HTML comment inside Javadoc.</p> 1670 * 1671 * <p>This node has three children:</p> 1672 * <ol> 1673 * <li>{@link #HTML_COMMENT_START}</li> 1674 * <li>{@link #HTML_COMMENT_CONTENT}</li> 1675 * <li>{@link #HTML_COMMENT_END}</li> 1676 * </ol> 1677 * 1678 * <p><b>Example:</b></p> 1679 * <pre>{@code * <!-- Hello World! -->}</pre> 1680 * 1681 * <b>Tree:</b> 1682 * <pre>{@code 1683 * JAVADOC_CONTENT -> JAVADOC_CONTENT 1684 * |--TEXT -> /** 1685 * |--NEWLINE -> \r\n 1686 * |--LEADING_ASTERISK -> * 1687 * |--TEXT -> 1688 * |--HTML_COMMENT -> HTML_COMMENT 1689 * |--HTML_COMMENT_START -> <!-- 1690 * |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT 1691 * | `--TEXT -> Hello World! 1692 * `--HTML_COMMENT_END -> --> 1693 * |--NEWLINE -> \r\n 1694 * |--LEADING_ASTERISK -> * 1695 * |--TEXT -> / 1696 * }</pre> 1697 * 1698 * @see #HTML_COMMENT 1699 */ 1700 public static final int HTML_COMMENT = JavadocCommentsLexer.HTML_COMMENT; 1701 1702 /** 1703 * {@code HTML_COMMENT_START} represents the beginning of an HTML comment, 1704 * i.e., the {@literal "<!--"} sequence inside a Javadoc comment. 1705 * 1706 * <p>HTML comments occasionally appear in Javadoc to add internal notes or 1707 * explanations without affecting the rendered output.</p> 1708 * Example: {@code <!-- Note: This method is for demonstration purposes only. -->} 1709 * 1710 * <p><b>Tree:</b></p> 1711 * <pre>{@code 1712 * HTML_COMMENT -> HTML_COMMENT 1713 * |--HTML_COMMENT_START -> <!-- 1714 * |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT 1715 * | `--TEXT -> Note: This method is for demonstration purposes only. 1716 * `--HTML_COMMENT_END -> --> 1717 * }</pre> 1718 * 1719 * @see #HTML_COMMENT_END 1720 */ 1721 public static final int HTML_COMMENT_START = JavadocCommentsLexer.HTML_COMMENT_START; 1722 1723 /** 1724 * Closing part of an HTML comment. 1725 * 1726 * <p>This node represents the closing delimiter of an HTML comment in 1727 * Javadoc (for example {@code -->}).</p> 1728 * 1729 * <p><b>Example:</b></p> 1730 * <pre>{@code * <!-- hidden comment -->}</pre> 1731 * 1732 * <b>Tree:</b> 1733 * <pre>{@code 1734 * |--LEADING_ASTERISK -> * 1735 * |--TEXT -> 1736 * |--HTML_COMMENT -> HTML_COMMENT 1737 * | |--HTML_COMMENT_START -> <!-- 1738 * | |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT 1739 * | | `--TEXT -> hidden comment 1740 * | `--HTML_COMMENT_END -> --> 1741 * }</pre> 1742 * 1743 * @see #HTML_COMMENT 1744 */ 1745 1746 public static final int HTML_COMMENT_END = JavadocCommentsLexer.HTML_COMMENT_END; 1747 1748 /** 1749 * {@code HTML_COMMENT_CONTENT} Content inside an HTML comment. 1750 * 1751 * <p>Text within an HTML comment.</p> 1752 * 1753 * <p><b>Example:</b> {@code <!-- This is a comment -->}</p> 1754 * 1755 * <p><b>Tree:</b></p> 1756 * <pre>{@code 1757 * HTML_COMMENT -> HTML_COMMENT 1758 * |--HTML_COMMENT_START -> <!-- 1759 * |--HTML_COMMENT_CONTENT -> HTML_COMMENT_CONTENT 1760 * | `--TEXT -> This is a comment 1761 * `--HTML_COMMENT_END -> --> 1762 * }</pre> 1763 * 1764 * @see #HTML_COMMENT 1765 */ 1766 public static final int HTML_COMMENT_CONTENT = JavadocCommentsLexer.HTML_COMMENT_CONTENT; 1767 1768 /** Empty private constructor of the current class. */ 1769 private JavadocCommentsTokenTypes() { 1770 } 1771}