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