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 public static final int LEADING_ASTERISK = JavadocCommentsLexer.LEADING_ASTERISK; 053 054 /** 055 * Newline character in a Javadoc comment. 056 */ 057 public static final int NEWLINE = JavadocCommentsLexer.NEWLINE; 058 059 /** 060 * Plain text content within a Javadoc comment. 061 */ 062 public static final int TEXT = JavadocCommentsLexer.TEXT; 063 064 // Block tags 065 066 /** 067 * General block tag (e.g. {@code @param}, {@code @return}). 068 */ 069 public static final int JAVADOC_BLOCK_TAG = JavadocCommentsLexer.JAVADOC_BLOCK_TAG; 070 071 /** 072 * At-sign {@code @} that starts a block tag. 073 */ 074 public static final int AT_SIGN = JavadocCommentsLexer.AT_SIGN; 075 076 /** 077 * {@code @author} Javadoc block tag. 078 * 079 * <p>Such Javadoc tag can have one child:</p> 080 * <ol> 081 * <li>{@link #DESCRIPTION}</li> 082 * </ol> 083 * 084 * <p><b>Example:</b></p> 085 * <pre>{@code * @author name.}</pre> 086 * <b>Tree:</b> 087 * <pre>{@code 088 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 089 * `--AUTHOR_BLOCK_TAG -> AUTHOR_BLOCK_TAG 090 * |--AT_SIGN -> @ 091 * |--TAG_NAME -> author 092 * `--DESCRIPTION -> DESCRIPTION 093 * `--TEXT -> name. 094 * }</pre> 095 * 096 * @see #JAVADOC_BLOCK_TAG 097 */ 098 public static final int AUTHOR_BLOCK_TAG = JavadocCommentsLexer.AUTHOR_BLOCK_TAG; 099 100 /** 101 * {@code @deprecated} block tag. 102 * 103 * <p>Such Javadoc tag can have one child:</p> 104 * <ol> 105 * <li>{@link #DESCRIPTION}</li> 106 * </ol> 107 * 108 * <p><b>Example:</b></p> 109 * <pre>{@code * @deprecated deprecated text.}</pre> 110 * 111 * <b>Tree:</b> 112 * <pre>{@code 113 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 114 * `--DEPRECATED_BLOCK_TAG -> DEPRECATED_BLOCK_TAG 115 * |--AT_SIGN -> @ 116 * |--TAG_NAME -> deprecated 117 * `--DESCRIPTION -> DESCRIPTION 118 * `--TEXT -> deprecated text. 119 * }</pre> 120 * 121 * @see #JAVADOC_BLOCK_TAG 122 */ 123 public static final int DEPRECATED_BLOCK_TAG = JavadocCommentsLexer.DEPRECATED_BLOCK_TAG; 124 125 /** 126 * {@code @param} Javadoc block tag. 127 * 128 * <p>Such Javadoc tag can have two children:</p> 129 * <ol> 130 * <li>{@link #PARAMETER_NAME}</li> 131 * <li>{@link #DESCRIPTION}</li> 132 * </ol> 133 * 134 * <p><b>Example:</b></p> 135 * <pre>{@code * @param value The parameter of method.}</pre> 136 * <b>Tree:</b> 137 * <pre>{@code 138 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 139 * `--PARAM_BLOCK_TAG -> PARAM_BLOCK_TAG 140 * |--AT_SIGN -> @ 141 * |--TAG_NAME -> param 142 * |--TEXT -> 143 * |--PARAMETER_NAME -> value 144 * `--DESCRIPTION -> DESCRIPTION 145 * `--TEXT -> The parameter of method. 146 * }</pre> 147 * 148 * @see #JAVADOC_BLOCK_TAG 149 */ 150 public static final int PARAM_BLOCK_TAG = JavadocCommentsLexer.PARAM_BLOCK_TAG; 151 152 /** 153 * {@code @return} Javadoc block tag. 154 * 155 * <p>Such Javadoc tag can have one child:</p> 156 * <ol> 157 * <li>{@link #DESCRIPTION}</li> 158 * </ol> 159 * 160 * <p><b>Example:</b></p> 161 * <pre>{@code * @return The return of method.}</pre> 162 * <b>Tree:</b> 163 * <pre>{@code 164 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 165 * `--RETURN_BLOCK_TAG -> RETURN_BLOCK_TAG 166 * |--AT_SIGN -> @ 167 * |--TAG_NAME -> return 168 * `--DESCRIPTION -> DESCRIPTION 169 * `--TEXT -> The return of method. 170 * }</pre> 171 * 172 * @see #JAVADOC_BLOCK_TAG 173 */ 174 public static final int RETURN_BLOCK_TAG = JavadocCommentsLexer.RETURN_BLOCK_TAG; 175 176 /** 177 * {@code @throws} Javadoc block tag. 178 * 179 * <p>Such Javadoc tag can have two children:</p> 180 * <ol> 181 * <li>{@link #IDENTIFIER} - the exception class</li> 182 * <li>{@link #DESCRIPTION} - description</li> 183 * </ol> 184 * 185 * <p><b>Example:</b></p> 186 * <pre>{@code * @throws IOException if an I/O error occurs}</pre> 187 * <b>Tree:</b> 188 * <pre>{@code 189 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 190 * `--THROWS_BLOCK_TAG -> THROWS_BLOCK_TAG 191 * |--AT_SIGN -> @ 192 * |--TAG_NAME -> throws 193 * |--TEXT -> 194 * |--IDENTIFIER -> IOException 195 * `--DESCRIPTION -> DESCRIPTION 196 * `--TEXT -> if an I/O error occurs 197 * }</pre> 198 * 199 * @see #JAVADOC_BLOCK_TAG 200 */ 201 public static final int THROWS_BLOCK_TAG = JavadocCommentsLexer.THROWS_BLOCK_TAG; 202 203 /** 204 * {@code @exception} Javadoc block tag. 205 * 206 * <p>Such Javadoc tag can have two children:</p> 207 * <ol> 208 * <li>{@link #IDENTIFIER}</li> 209 * <li>{@link #DESCRIPTION}</li> 210 * </ol> 211 * 212 * <p><b>Example:</b></p> 213 * <pre>{@code * @exception FileNotFoundException when file is not found.}</pre> 214 * <b>Tree:</b> 215 * <pre>{@code 216 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 217 * `--EXCEPTION_BLOCK_TAG -> EXCEPTION_BLOCK_TAG 218 * |--AT_SIGN -> @ 219 * |--TAG_NAME -> exception 220 * |--TEXT -> 221 * |--IDENTIFIER -> FileNotFoundException 222 * `--DESCRIPTION -> DESCRIPTION 223 * `--TEXT -> when file is not found. 224 * }</pre> 225 * 226 * @see #JAVADOC_BLOCK_TAG 227 */ 228 public static final int EXCEPTION_BLOCK_TAG = JavadocCommentsLexer.EXCEPTION_BLOCK_TAG; 229 230 /** 231 * {@code @since} Javadoc block tag. 232 * 233 * <p>Such Javadoc tag can have one child:</p> 234 * <ol> 235 * <li>{@link #DESCRIPTION}</li> 236 * </ol> 237 * 238 * <p><b>Example:</b></p> 239 * <pre>{@code * @since 1.0}</pre> 240 * 241 * <b>Tree:</b> 242 * <pre>{@code 243 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 244 * `--SINCE_BLOCK_TAG -> SINCE_BLOCK_TAG 245 * |--AT_SIGN -> @ 246 * |--TAG_NAME -> since 247 * `--DESCRIPTION -> DESCRIPTION 248 * `--TEXT -> 1.0 249 * }</pre> 250 * 251 * @see #JAVADOC_BLOCK_TAG 252 */ 253 public static final int SINCE_BLOCK_TAG = JavadocCommentsLexer.SINCE_BLOCK_TAG; 254 255 /** 256 * {@code @version} Javadoc block tag. 257 * 258 * <p>This tag has only one argument — {@link #TEXT}:</p> 259 * 260 * <p><b>Example:</b></p> 261 * <pre>{@code * @version value}</pre> 262 * <b>Tree:</b> 263 * <pre>{@code 264 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 265 * `--VERSION_BLOCK_TAG -> VERSION_BLOCK_TAG 266 * |--AT_SIGN -> @ 267 * |--TAG_NAME -> version 268 * `--DESCRIPTION -> DESCRIPTION 269 * `--TEXT -> value 270 * }</pre> 271 * 272 * @see #JAVADOC_BLOCK_TAG 273 */ 274 public static final int VERSION_BLOCK_TAG = JavadocCommentsLexer.VERSION_BLOCK_TAG; 275 276 /** 277 * {@code @see} Javadoc block tag. 278 * 279 * <p>Such Javadoc tag can have three children:</p> 280 * <ol> 281 * <li>{@link #REFERENCE}</li> 282 * <li>{@link #DESCRIPTION}</li> 283 * <li>{@link #HTML_ELEMENT}</li> 284 * </ol> 285 * 286 * <p><b>Example:</b></p> 287 * <pre>{@code * @see SomeClass#Field}</pre> 288 * 289 * <b>Tree:</b> 290 * <pre>{@code 291 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 292 * `--SEE_BLOCK_TAG -> SEE_BLOCK_TAG 293 * |--AT_SIGN -> @ 294 * |--TAG_NAME -> see 295 * |--TEXT -> 296 * `--REFERENCE -> REFERENCE 297 * |--IDENTIFIER -> SomeClass 298 * |--HASH -> # 299 * `--MEMBER_REFERENCE -> MEMBER_REFERENCE 300 * `--IDENTIFIER -> Field 301 * }</pre> 302 * 303 * @see #JAVADOC_BLOCK_TAG 304 */ 305 public static final int SEE_BLOCK_TAG = JavadocCommentsLexer.SEE_BLOCK_TAG; 306 307 /** 308 * {@code @hidden} Javadoc block tag. 309 * 310 * <p>Such Javadoc tag can have one child:</p> 311 * <ol> 312 * <li>{@link #DESCRIPTION} – optional description text</li> 313 * </ol> 314 * 315 * <p><b>Example:</b></p> 316 * <pre>{@code * @hidden value}</pre> 317 * 318 * <b>Tree:</b> 319 * <pre>{@code 320 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 321 * `--HIDDEN_BLOCK_TAG -> HIDDEN_BLOCK_TAG 322 * |--AT_SIGN -> @ 323 * |--TAG_NAME -> hidden 324 * `--DESCRIPTION -> DESCRIPTION 325 * `--TEXT -> value 326 * }</pre> 327 * 328 * @see #JAVADOC_BLOCK_TAG 329 */ 330 public static final int HIDDEN_BLOCK_TAG = JavadocCommentsLexer.HIDDEN_BLOCK_TAG; 331 332 /** 333 * {@code @uses} Javadoc block tag. 334 * 335 * <p>Such Javadoc tag can have one child:</p> 336 * <ol> 337 * <li>{@link #IDENTIFIER} – the referenced service type</li> 338 * </ol> 339 * 340 * <p><b>Example:</b></p> 341 * <pre>{@code * @uses com.example.app.MyService}</pre> 342 * 343 * <b>Tree:</b> 344 * <pre>{@code 345 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 346 * `--USES_BLOCK_TAG -> USES_BLOCK_TAG 347 * |--AT_SIGN -> @ 348 * |--TAG_NAME -> uses 349 * |--TEXT -> 350 * `--IDENTIFIER -> com.example.app.MyService 351 * }</pre> 352 * 353 * @see #JAVADOC_BLOCK_TAG 354 */ 355 public static final int USES_BLOCK_TAG = JavadocCommentsLexer.USES_BLOCK_TAG; 356 357 /** 358 * {@code @provides} block tag. 359 * 360 * <p>Such Javadoc tag can have two children:</p> 361 * <ol> 362 * <li>{@link #IDENTIFIER}</li> 363 * <li>{@link #DESCRIPTION}</li> 364 * </ol> 365 * 366 * <p><b>Example:</b></p> 367 * <pre>{@code * @provides com.example.MyService with com.example.MyServiceImpl}</pre> 368 * 369 * <b>Tree:</b> 370 * <pre>{@code 371 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 372 * `--PROVIDES_BLOCK_TAG -> PROVIDES_BLOCK_TAG 373 * |--AT_SIGN -> @ 374 * |--TAG_NAME -> provides 375 * |--TEXT -> 376 * |--IDENTIFIER -> com.example.MyService 377 * `--DESCRIPTION -> DESCRIPTION 378 * `--TEXT -> with com.example.MyServiceImpl 379 * }</pre> 380 * 381 * @see #JAVADOC_BLOCK_TAG 382 */ 383 public static final int PROVIDES_BLOCK_TAG = JavadocCommentsLexer.PROVIDES_BLOCK_TAG; 384 385 /** 386 * {@code @serial} block tag. 387 * 388 * <p>Such Javadoc tag can have one child:</p> 389 * <ol> 390 * <li>{@link #DESCRIPTION} – optional description text</li> 391 * </ol> 392 * 393 * <p><b>Example:</b></p> 394 * <pre>{@code * @serial include}</pre> 395 * 396 * <b>Tree:</b> 397 * <pre>{@code 398 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 399 * `--SERIAL_BLOCK_TAG -> SERIAL_BLOCK_TAG 400 * |--AT_SIGN -> @ 401 * |--TAG_NAME -> serial 402 * `--DESCRIPTION -> DESCRIPTION 403 * `--TEXT -> include 404 * }</pre> 405 * 406 * @see #JAVADOC_BLOCK_TAG 407 */ 408 public static final int SERIAL_BLOCK_TAG = JavadocCommentsLexer.SERIAL_BLOCK_TAG; 409 410 /** 411 * {@code @serialData} block tag. 412 * 413 * <p>Such Javadoc tag can have one child:</p> 414 * <ol> 415 * <li>{@link #DESCRIPTION} – optional description text</li> 416 * </ol> 417 * 418 * <p><b>Example:</b></p> 419 * <pre>{@code * @serialData data description value}</pre> 420 * 421 * <b>Tree:</b> 422 * <pre>{@code 423 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 424 * `--SERIAL_DATA_BLOCK_TAG -> SERIAL_DATA_BLOCK_TAG 425 * |--AT_SIGN -> @ 426 * |--TAG_NAME -> serialData 427 * `--DESCRIPTION -> DESCRIPTION 428 * `--TEXT -> data description value 429 * }</pre> 430 * 431 * @see #JAVADOC_BLOCK_TAG 432 */ 433 public static final int SERIAL_DATA_BLOCK_TAG = JavadocCommentsLexer.SERIAL_DATA_BLOCK_TAG; 434 435 /** 436 * {@code @serialField} Javadoc block tag. 437 * 438 * <p>Such Javadoc tag can have three children:</p> 439 * <ol> 440 * <li>{@link #IDENTIFIER} – field name</li> 441 * <li>{@link #FIELD_TYPE} – field type</li> 442 * <li>{@link #DESCRIPTION} – field description</li> 443 * </ol> 444 * 445 * <p><b>Example:</b></p> 446 * <pre>{@code * @serialField name String The person's full name.}</pre> 447 * 448 * <b>Tree:</b> 449 * <pre>{@code 450 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 451 * `--SERIAL_FIELD_BLOCK_TAG -> SERIAL_FIELD_BLOCK_TAG 452 * |--AT_SIGN -> @ 453 * |--TAG_NAME -> serialField 454 * |--TEXT -> 455 * |--IDENTIFIER -> name 456 * |--TEXT -> 457 * |--FIELD_TYPE -> String 458 * `--DESCRIPTION -> DESCRIPTION 459 * `--TEXT -> The person's full name. 460 * }</pre> 461 * 462 * @see #JAVADOC_BLOCK_TAG 463 */ 464 public static final int SERIAL_FIELD_BLOCK_TAG = JavadocCommentsLexer.SERIAL_FIELD_BLOCK_TAG; 465 466 /** 467 * {@code @customBlock} Javadoc block tag. 468 * 469 * <p>This type represents any block tag that is not explicitly recognized by Checkstyle, 470 * such as a project-specific or malformed tag.</p> 471 * 472 * <p><b>Example:</b></p> 473 * <pre>{@code * @mycustomtag This is a custom block tag.}</pre> 474 * <b>Tree:</b> 475 * <pre>{@code 476 * JAVADOC_BLOCK_TAG -> JAVADOC_BLOCK_TAG 477 * `--CUSTOM_BLOCK_TAG -> CUSTOM_BLOCK_TAG 478 * |--AT_SIGN -> @ 479 * |--TAG_NAME -> customBlock 480 * |--TEXT -> 481 * `--DESCRIPTION -> DESCRIPTION 482 * `--TEXT -> This is a custom block tag. 483 * }</pre> 484 * 485 * @see #JAVADOC_BLOCK_TAG 486 */ 487 public static final int CUSTOM_BLOCK_TAG = JavadocCommentsLexer.CUSTOM_BLOCK_TAG; 488 489 // Inline tags 490 491 /** 492 * General inline tag (e.g. {@code @link}). 493 */ 494 public static final int JAVADOC_INLINE_TAG = JavadocCommentsLexer.JAVADOC_INLINE_TAG; 495 496 /** 497 * Start of an inline tag <code>{</code>. 498 */ 499 public static final int JAVADOC_INLINE_TAG_START = 500 JavadocCommentsLexer.JAVADOC_INLINE_TAG_START; 501 502 /** 503 * End of an inline tag <code>}</code>. 504 */ 505 public static final int JAVADOC_INLINE_TAG_END = JavadocCommentsLexer.JAVADOC_INLINE_TAG_END; 506 507 /** 508 * {@code {@code}} Javadoc inline tag. 509 * 510 * <p>Such Javadoc tag can have no children:</p> 511 * 512 * <p><b>Example:</b></p> 513 * <pre>{@code * {@code println("Hello");}}</pre> 514 * 515 * <b>Tree:</b> 516 * <pre>{@code 517 * `--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 518 * |--CODE_INLINE_TAG -> CODE_INLINE_TAG 519 * |--JAVADOC_INLINE_TAG_START -> { @ 520 * |--TAG_NAME -> code 521 * |--TEXT -> println("Hello"); 522 * `--JAVADOC_INLINE_TAG_END -> } 523 * }</pre> 524 * 525 * @see #JAVADOC_INLINE_TAG 526 */ 527 public static final int CODE_INLINE_TAG = JavadocCommentsLexer.CODE_INLINE_TAG; 528 529 /** 530 * {@code {@link}} Javadoc inline tag. 531 * 532 * <p>Such Javadoc tag can have two children:</p> 533 * <ol> 534 * <li>{@link #REFERENCE}</li> 535 * <li>{@link #DESCRIPTION}</li> 536 * </ol> 537 * 538 * <p><b>Example:</b></p> 539 * <pre>{@code * {@link Math#max(int, int) label}}</pre> 540 * 541 * <b>Tree:</b> 542 * <pre>{@code 543 * --JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 544 * `--LINK_INLINE_TAG -> LINK_INLINE_TAG 545 * |--JAVADOC_INLINE_TAG_START -> { @ 546 * |--TAG_NAME -> link 547 * |--TEXT -> 548 * |--REFERENCE -> REFERENCE 549 * | |--IDENTIFIER -> Math 550 * | |--HASH -> # 551 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 552 * | |--IDENTIFIER -> max 553 * | |--LPAREN -> ( 554 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST 555 * | | |--PARAMETER_TYPE -> int 556 * | | |--COMMA -> , 557 * | | |--TEXT -> 558 * | | `--PARAMETER_TYPE -> int 559 * | `--RPAREN -> ) 560 * |--DESCRIPTION -> DESCRIPTION 561 * | `--TEXT -> label 562 * `--JAVADOC_INLINE_TAG_END -> } 563 * }</pre> 564 * 565 * @see #JAVADOC_INLINE_TAG 566 */ 567 public static final int LINK_INLINE_TAG = JavadocCommentsLexer.LINK_INLINE_TAG; 568 569 /** 570 * {@code {@linkplain}} Javadoc inline tag. 571 * 572 * <p>Such Javadoc tag can have two children:</p> 573 * <ol> 574 * <li>{@link #REFERENCE}</li> 575 * <li>{@link #DESCRIPTION}</li> 576 * </ol> 577 * 578 * <p><b>Example:</b></p> 579 * <pre>{@code * {@linkplain String#indexOf(int, int) label}}</pre> 580 * 581 * <b>Tree:</b> 582 * <pre>{@code 583 * --JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 584 * `--LINKPLAIN_INLINE_TAG -> LINKPLAIN_INLINE_TAG 585 * |--JAVADOC_INLINE_TAG_START -> { @ 586 * |--TAG_NAME -> linkplain 587 * |--TEXT -> 588 * |--REFERENCE -> REFERENCE 589 * | |--IDENTIFIER -> String 590 * | |--HASH -> # 591 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 592 * | |--IDENTIFIER -> indexOf 593 * | |--LPAREN -> ( 594 * | |--PARAMETER_TYPE_LIST -> PARAMETER_TYPE_LIST 595 * | | |--PARAMETER_TYPE -> int 596 * | | |--COMMA -> , 597 * | | |--TEXT -> 598 * | | `--PARAMETER_TYPE -> int 599 * | `--RPAREN -> ) 600 * |--DESCRIPTION -> DESCRIPTION 601 * | `--TEXT -> label 602 * `--JAVADOC_INLINE_TAG_END -> } 603 * }</pre> 604 * 605 * @see #JAVADOC_INLINE_TAG 606 */ 607 public static final int LINKPLAIN_INLINE_TAG = JavadocCommentsLexer.LINKPLAIN_INLINE_TAG; 608 609 /** 610 * {@code {@value}} Javadoc inline tag. 611 * 612 * <p>Such Javadoc tag can have one child:</p> 613 * <ol> 614 * <li>{@link #REFERENCE}</li> 615 * </ol> 616 * 617 * <p><b>Example:</b></p> 618 * <pre>{@code * {@value Integer#MAX_VALUE}}</pre> 619 * 620 * <b>Tree:</b> 621 * <pre>{@code 622 * --JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 623 * `--VALUE_INLINE_TAG -> VALUE_INLINE_TAG 624 * |--JAVADOC_INLINE_TAG_START -> { @ 625 * |--TAG_NAME -> value 626 * |--TEXT -> 627 * |--REFERENCE -> REFERENCE 628 * | |--IDENTIFIER -> Integer 629 * | |--HASH -> # 630 * | `--MEMBER_REFERENCE -> MEMBER_REFERENCE 631 * | `--IDENTIFIER -> MAX_VALUE 632 * |--TEXT -> 633 * `--JAVADOC_INLINE_TAG_END -> } 634 * }</pre> 635 * 636 * @see #JAVADOC_INLINE_TAG 637 */ 638 public static final int VALUE_INLINE_TAG = JavadocCommentsLexer.VALUE_INLINE_TAG; 639 640 /** 641 * {@code {@summary}} inline tag. 642 */ 643 public static final int SUMMARY_INLINE_TAG = JavadocCommentsLexer.SUMMARY_INLINE_TAG; 644 645 /** 646 * {@code {@inheritDoc}} inline tag. 647 */ 648 public static final int INHERIT_DOC_INLINE_TAG = JavadocCommentsLexer.INHERIT_DOC_INLINE_TAG; 649 650 /** 651 * {@code {@systemProperty}} inline tag. 652 */ 653 public static final int SYSTEM_PROPERTY_INLINE_TAG = 654 JavadocCommentsLexer.SYSTEM_PROPERTY_INLINE_TAG; 655 656 /** 657 * {@code {@literal}} inline tag. 658 */ 659 public static final int LITERAL_INLINE_TAG = JavadocCommentsLexer.LITERAL_INLINE_TAG; 660 661 /** 662 * {@code {@return}} inline tag. 663 */ 664 public static final int RETURN_INLINE_TAG = JavadocCommentsLexer.RETURN_INLINE_TAG; 665 666 /** 667 * {@code {@index}} inline tag. 668 */ 669 public static final int INDEX_INLINE_TAG = JavadocCommentsLexer.INDEX_INLINE_TAG; 670 671 /** 672 * {@code @snippet} inline tag. 673 */ 674 public static final int SNIPPET_INLINE_TAG = JavadocCommentsLexer.SNIPPET_INLINE_TAG; 675 676 /** 677 * Custom or unrecognized inline tag. 678 */ 679 public static final int CUSTOM_INLINE_TAG = JavadocCommentsLexer.CUSTOM_INLINE_TAG; 680 681 // Components 682 683 /** 684 * Identifier token. 685 */ 686 public static final int IDENTIFIER = JavadocCommentsLexer.IDENTIFIER; 687 688 /** 689 * Hash symbol {@code #} used in references. 690 */ 691 public static final int HASH = JavadocCommentsLexer.HASH; 692 693 /** 694 * Left parenthesis {@code ( }. 695 */ 696 public static final int LPAREN = JavadocCommentsLexer.LPAREN; 697 698 /** 699 * Right parenthesis {@code ) }. 700 */ 701 public static final int RPAREN = JavadocCommentsLexer.RPAREN; 702 703 /** 704 * Comma symbol {@code , }. 705 */ 706 public static final int COMMA = JavadocCommentsLexer.COMMA; 707 708 /** 709 * Slash symbol {@code / }. 710 */ 711 public static final int SLASH = JavadocCommentsLexer.SLASH; 712 713 /** 714 * Question mark symbol {@code ? }. 715 */ 716 public static final int QUESTION = JavadocCommentsLexer.QUESTION; 717 718 /** 719 * Less-than symbol {@code < }. 720 */ 721 public static final int LT = JavadocCommentsLexer.LT; 722 723 /** 724 * Greater-than symbol {@code > }. 725 */ 726 public static final int GT = JavadocCommentsLexer.GT; 727 728 /** 729 * Keyword {@code extends} in type parameters. 730 */ 731 public static final int EXTENDS = JavadocCommentsLexer.EXTENDS; 732 733 /** 734 * Keyword {@code super} in type parameters. 735 */ 736 public static final int SUPER = JavadocCommentsLexer.SUPER; 737 738 /** 739 * Parameter type reference. 740 */ 741 public static final int PARAMETER_TYPE = JavadocCommentsLexer.PARAMETER_TYPE; 742 743 /** 744 * General reference within Javadoc. 745 */ 746 public static final int REFERENCE = JavadocCommentsLexer.REFERENCE; 747 748 /** 749 * Type name reference. 750 */ 751 public static final int TYPE_NAME = JavadocCommentsLexer.TYPE_NAME; 752 753 /** 754 * Member reference (e.g. method or field). 755 */ 756 public static final int MEMBER_REFERENCE = JavadocCommentsLexer.MEMBER_REFERENCE; 757 758 /** 759 * List of parameter types in a reference. 760 */ 761 public static final int PARAMETER_TYPE_LIST = JavadocCommentsLexer.PARAMETER_TYPE_LIST; 762 763 /** 764 * Type arguments in generics. 765 */ 766 public static final int TYPE_ARGUMENTS = JavadocCommentsLexer.TYPE_ARGUMENTS; 767 768 /** 769 * Single type argument in generics. 770 */ 771 public static final int TYPE_ARGUMENT = JavadocCommentsLexer.TYPE_ARGUMENT; 772 773 /** 774 * Description part of a Javadoc tag. 775 */ 776 public static final int DESCRIPTION = JavadocCommentsLexer.DESCRIPTION; 777 778 /** 779 * Format specifier inside Javadoc content. 780 */ 781 public static final int FORMAT_SPECIFIER = JavadocCommentsLexer.FORMAT_SPECIFIER; 782 783 /** 784 * Attribute name in a {@code @snippet}. 785 */ 786 public static final int SNIPPET_ATTR_NAME = JavadocCommentsLexer.SNIPPET_ATTR_NAME; 787 788 /** 789 * Equals sign {@code = }. 790 */ 791 public static final int EQUALS = JavadocCommentsLexer.EQUALS; 792 793 /** 794 * Value assigned to an attribute. 795 */ 796 public static final int ATTRIBUTE_VALUE = JavadocCommentsLexer.ATTRIBUTE_VALUE; 797 798 /** 799 * Colon symbol {@code : }. 800 */ 801 public static final int COLON = JavadocCommentsLexer.COLON; 802 803 /** 804 * Term used in {@code {@index}} tag. 805 */ 806 public static final int INDEX_TERM = JavadocCommentsLexer.INDEX_TERM; 807 808 /** 809 * Single snippet attribute. 810 */ 811 public static final int SNIPPET_ATTRIBUTE = JavadocCommentsLexer.SNIPPET_ATTRIBUTE; 812 813 /** 814 * Collection of snippet attributes. 815 */ 816 public static final int SNIPPET_ATTRIBUTES = JavadocCommentsLexer.SNIPPET_ATTRIBUTES; 817 818 /** 819 * Body content of a {@code @snippet}. 820 */ 821 public static final int SNIPPET_BODY = JavadocCommentsLexer.SNIPPET_BODY; 822 823 /** 824 * Field type reference. 825 */ 826 public static final int FIELD_TYPE = JavadocCommentsLexer.FIELD_TYPE; 827 828 /** 829 * Parameter name reference. 830 */ 831 public static final int PARAMETER_NAME = JavadocCommentsLexer.PARAMETER_NAME; 832 833 /** 834 * String literal inside Javadoc. 835 */ 836 public static final int STRING_LITERAL = JavadocCommentsLexer.STRING_LITERAL; 837 838 // HTML 839 840 /** 841 * General HTML element. 842 */ 843 public static final int HTML_ELEMENT = JavadocCommentsLexer.HTML_ELEMENT; 844 845 /** 846 * Void HTML element (self-closing). 847 */ 848 public static final int VOID_ELEMENT = JavadocCommentsLexer.VOID_ELEMENT; 849 850 /** 851 * Content inside an HTML element. 852 */ 853 public static final int HTML_CONTENT = JavadocCommentsLexer.HTML_CONTENT; 854 855 /** 856 * Single HTML attribute. 857 */ 858 public static final int HTML_ATTRIBUTE = JavadocCommentsLexer.HTML_ATTRIBUTE; 859 860 /** 861 * List of HTML attributes. 862 */ 863 public static final int HTML_ATTRIBUTES = JavadocCommentsLexer.HTML_ATTRIBUTES; 864 865 /** 866 * Start of an HTML tag. 867 */ 868 public static final int HTML_TAG_START = JavadocCommentsLexer.HTML_TAG_START; 869 870 /** 871 * End of an HTML tag. 872 */ 873 public static final int HTML_TAG_END = JavadocCommentsLexer.HTML_TAG_END; 874 875 /** 876 * Opening tag delimiter {@code < }. 877 */ 878 public static final int TAG_OPEN = JavadocCommentsLexer.TAG_OPEN; 879 880 /** 881 * HTML tag name. 882 */ 883 public static final int TAG_NAME = JavadocCommentsLexer.TAG_NAME; 884 885 /** 886 * Closing tag delimiter {@code > }. 887 */ 888 public static final int TAG_CLOSE = JavadocCommentsLexer.TAG_CLOSE; 889 890 /** 891 * Self-closing tag delimiter {@code /> }. 892 */ 893 public static final int TAG_SLASH_CLOSE = JavadocCommentsLexer.TAG_SLASH_CLOSE; 894 895 /** 896 * Slash symbol inside a closing tag. 897 */ 898 public static final int TAG_SLASH = JavadocCommentsLexer.TAG_SLASH; 899 900 /** 901 * Attribute name inside an HTML tag. 902 */ 903 public static final int TAG_ATTR_NAME = JavadocCommentsLexer.TAG_ATTR_NAME; 904 905 /** 906 * Full HTML comment. 907 */ 908 public static final int HTML_COMMENT = JavadocCommentsLexer.HTML_COMMENT; 909 910 /** 911 * Opening part of an HTML comment. 912 */ 913 public static final int HTML_COMMENT_START = JavadocCommentsLexer.HTML_COMMENT_START; 914 915 /** 916 * Closing part of an HTML comment. 917 */ 918 public static final int HTML_COMMENT_END = JavadocCommentsLexer.HTML_COMMENT_END; 919 920 /** 921 * Content inside an HTML comment. 922 */ 923 public static final int HTML_COMMENT_CONTENT = JavadocCommentsLexer.HTML_COMMENT_CONTENT; 924 925 /** Empty private constructor of the current class. */ 926 private JavadocCommentsTokenTypes() { 927 } 928}