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.JavadocParser; 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 JavadocTokenTypes { 032 033 // ------------------------------------------------------------------------------------------ // 034 // ----------------- JAVADOC TAGS ------------------------------------------- // 035 // ------------------------------------------------------------------------------------------ // 036 037 /** 038 * '@return' literal in {@code @return} Javadoc tag. 039 * 040 * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p> 041 * 042 * <p><b>Example:</b></p> 043 * <pre>{@code @return true if file exists}</pre> 044 * <b>Tree:</b> 045 * <pre>{@code 046 * JAVADOC_TAG -> JAVADOC_TAG 047 * |--RETURN_LITERAL -> @return 048 * |--WS -> 049 * `--DESCRIPTION -> DESCRIPTION 050 * |--TEXT -> true if file exists 051 * }</pre> 052 * 053 * @see 054 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCDBGG"> 055 * Oracle Docs</a> 056 * @see #JAVADOC_TAG 057 */ 058 public static final int RETURN_LITERAL = JavadocParser.RETURN_LITERAL; 059 060 /** 061 * '{@literal @}deprecated' literal in {@literal @}deprecated Javadoc tag. 062 * 063 * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p> 064 * 065 * <p><b>Example:</b></p> 066 * <pre>{@code @deprecated It is deprecated method}</pre> 067 * <b>Tree:</b> 068 * <pre>{@code 069 * JAVADOC_TAG -> JAVADOC_TAG 070 * |--DEPRECATED_LITERAL -> @deprecated 071 * |--WS -> 072 * `--DESCRIPTION -> DESCRIPTION 073 * |--TEXT -> It is deprecated method 074 * }</pre> 075 * 076 * @see 077 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#deprecated"> 078 * Oracle Docs</a> 079 * @see #JAVADOC_TAG 080 */ 081 public static final int DEPRECATED_LITERAL = JavadocParser.DEPRECATED_LITERAL; 082 083 /** 084 * '@since' literal in {@code @since} Javadoc tag. 085 * 086 * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p> 087 * 088 * <p><b>Example:</b></p> 089 * <pre>{@code @since 3.4 RELEASE}</pre> 090 * <b>Tree:</b> 091 * <pre>{@code 092 * JAVADOC_TAG -> JAVADOC_TAG 093 * |--SINCE_LITERAL -> @since 094 * |--WS -> 095 * `--DESCRIPTION -> DESCRIPTION 096 * |--TEXT -> 3.4 RELEASE 097 * }</pre> 098 * 099 * @see 100 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHGJGD"> 101 * Oracle Docs</a> 102 * @see #JAVADOC_TAG 103 */ 104 public static final int SINCE_LITERAL = JavadocParser.SINCE_LITERAL; 105 106 /** 107 * '@serialData' literal in {@code @serialData} Javadoc tag. 108 * 109 * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p> 110 * 111 * <p><b>Example:</b></p> 112 * <pre>{@code @serialData Two values of Integer type}</pre> 113 * <b>Tree:</b> 114 * <pre>{@code 115 * JAVADOC_TAG -> JAVADOC_TAG 116 * |--SERIAL_DATA_LITERAL -> @serialData 117 * |--WS -> 118 * `--DESCRIPTION -> DESCRIPTION 119 * |--TEXT -> Two values of Integer type 120 * } 121 * </pre> 122 * 123 * @see 124 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDJBFDB"> 125 * Oracle Docs</a> 126 * @see #JAVADOC_TAG 127 */ 128 public static final int SERIAL_DATA_LITERAL = JavadocParser.SERIAL_DATA_LITERAL; 129 130 /** 131 * '@serialField' literal in {@code @serialField} Javadoc tag. 132 * 133 * <p>Such Javadoc tag can have three arguments:</p> 134 * <ol> 135 * <li>{@link #FIELD_NAME}</li> 136 * <li>{@link #FIELD_TYPE}</li> 137 * <li>{@link #DESCRIPTION}</li> 138 * </ol> 139 * 140 * <p><b>Example:</b></p> 141 * <pre>{@code @serialField counter Integer objects counter}</pre> 142 * <b>Tree:</b> 143 * <pre>{@code 144 * JAVADOC_TAG -> JAVADOC_TAG 145 * |--SERIAL_FIELD_LITERAL -> @serialField 146 * |--WS -> 147 * |--FIELD_NAME -> counter 148 * |--WS -> 149 * |--FIELD_TYPE -> Integer 150 * |--WS -> 151 * `--DESCRIPTION -> DESCRIPTION 152 * |--TEXT -> objects counter 153 * }</pre> 154 * 155 * @see 156 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDGHIDG"> 157 * Oracle Docs</a> 158 * @see #JAVADOC_TAG 159 */ 160 public static final int SERIAL_FIELD_LITERAL = JavadocParser.SERIAL_FIELD_LITERAL; 161 162 /** 163 * '@param' literal in {@code @param} Javadoc tag. 164 * 165 * <p>Such Javadoc tag can have two arguments:</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_TAG -> JAVADOC_TAG 176 * |--PARAM_LITERAL -> @param 177 * |--WS -> 178 * |--PARAMETER_NAME -> value 179 * |--WS -> 180 * `--DESCRIPTION -> DESCRIPTION 181 * |--TEXT -> The parameter of method. 182 * }</pre> 183 * 184 * @see 185 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHJECF"> 186 * Oracle Docs</a> 187 * @see #JAVADOC_TAG 188 */ 189 public static final int PARAM_LITERAL = JavadocParser.PARAM_LITERAL; 190 191 /** 192 * '@see' literal in {@code @see} Javadoc tag. 193 * 194 * <p>Such Javadoc tag can have one argument - {@link #REFERENCE}</p> 195 * 196 * <p><b>Example:</b></p> 197 * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre> 198 * <b>Tree:</b> 199 * <pre>{@code 200 * JAVADOC_TAG -> JAVADOC_TAG 201 * |--SEE_LITERAL -> @see 202 * |--WS -> 203 * |--REFERENCE -> REFERENCE 204 * |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator 205 * |--HASH -> # 206 * |--MEMBER -> compare 207 * `--PARAMETERS -> PARAMETERS 208 * |--LEFT_BRACE -> ( 209 * |--ARGUMENT -> Object 210 * `--RIGHT_BRACE -> ) 211 * }</pre> 212 * 213 * @see 214 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDIEDI"> 215 * Oracle Docs</a> 216 * @see #JAVADOC_TAG 217 */ 218 public static final int SEE_LITERAL = JavadocParser.SEE_LITERAL; 219 220 /** 221 * '@serial' literal in {@code @serial} Javadoc tag. 222 * 223 * <p>Such Javadoc tag can have one argument - {@link #REFERENCE} or {@link #LITERAL_EXCLUDE} 224 * or {@link #LITERAL_INCLUDE}</p> 225 * 226 * <p><b>Example:</b></p> 227 * <pre>{@code @serial include}</pre> 228 * <b>Tree:</b> 229 * <pre>{@code 230 * |--JAVADOC_TAG -> JAVADOC_TAG 231 * |--SERIAL_LITERAL -> @serial 232 * |--WS 233 * |--LITERAL_INCLUDE -> include 234 * }</pre> 235 * 236 * <p><b>Example:</b></p> 237 * <pre>{@code @serial serialized company name}</pre> 238 * <b>Tree:</b> 239 * <pre>{@code 240 * |--JAVADOC_TAG-> JAVADOC_TAG 241 * |--SERIAL_LITERAL -> @serial 242 * |--WS 243 * |--DESCRIPTION -> DESCRIPTION 244 * |--TEXT -> serialized company name 245 * }</pre> 246 * 247 * @see 248 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF"> 249 * Oracle Docs</a> 250 * @see #JAVADOC_TAG 251 */ 252 public static final int SERIAL_LITERAL = JavadocParser.SERIAL_LITERAL; 253 254 /** 255 * '@version' literal in {@code @version} Javadoc tag. 256 * 257 * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p> 258 * 259 * <p><b>Example:</b></p> 260 * <pre>{@code @version 1.3}</pre> 261 * <b>Tree:</b> 262 * <pre>{@code 263 * JAVADOC_TAG -> JAVADOC_TAG 264 * |--VERSION_LITERAL -> @version 265 * |--WS -> 266 * `--DESCRIPTION -> DESCRIPTION 267 * |--TEXT -> 1.3 268 * }</pre> 269 * 270 * @see 271 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCHBAE"> 272 * Oracle Docs</a> 273 * @see #JAVADOC_TAG 274 */ 275 public static final int VERSION_LITERAL = JavadocParser.VERSION_LITERAL; 276 277 /** 278 * '@exception' literal in {@code @exception} Javadoc tag. 279 * 280 * <p>Such Javadoc tag can have two argument - {@link #CLASS_NAME} and {@link #DESCRIPTION}</p> 281 * 282 * <p><b>Example:</b></p> 283 * <pre>{@code @exception SQLException if query is not correct}</pre> 284 * <b>Tree:</b> 285 * <pre>{@code 286 * JAVADOC_TAG -> JAVADOC_TAG 287 * |--EXCEPTION_LITERAL -> @exception 288 * |--WS -> 289 * |--CLASS_NAME -> SQLException 290 * |--WS -> 291 * `--DESCRIPTION -> DESCRIPTION 292 * `--TEXT -> if query is not correct 293 * }</pre> 294 * 295 * @see 296 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCEAHH"> 297 * Oracle Docs</a> 298 * @see #JAVADOC_TAG 299 */ 300 public static final int EXCEPTION_LITERAL = JavadocParser.EXCEPTION_LITERAL; 301 302 /** 303 * '@throws' literal in {@code @throws} Javadoc tag. 304 * 305 * <p>Such Javadoc tag can have two argument - {@link #CLASS_NAME} and {@link #DESCRIPTION}</p> 306 * 307 * <p><b>Example:</b></p> 308 * <pre>{@code @throws SQLException if query is not correct}</pre> 309 * <b>Tree:</b> 310 * <pre>{@code 311 * JAVADOC_TAG -> JAVADOC_TAG 312 * |--THROWS_LITERAL -> @throws 313 * |--WS -> 314 * |--CLASS_NAME -> SQLException 315 * |--WS -> 316 * `--DESCRIPTION -> DESCRIPTION 317 * `--TEXT -> if query is not correct 318 * }</pre> 319 * 320 * @see 321 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCHAHD"> 322 * Oracle Docs</a> 323 * @see #JAVADOC_TAG 324 */ 325 public static final int THROWS_LITERAL = JavadocParser.THROWS_LITERAL; 326 327 /** 328 * '@author' literal in {@code @author} Javadoc tag. 329 * 330 * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p> 331 * 332 * <p><b>Example:</b></p> 333 * <pre>{@code @author Baratali Izmailov}</pre> 334 * <b>Tree:</b> 335 * <pre>{@code 336 * JAVADOC_TAG -> JAVADOC_TAG 337 * |--AUTHOR_LITERAL -> @author 338 * |--WS -> 339 * `--DESCRIPTION -> DESCRIPTION 340 * |--TEXT -> Baratali Izmailov 341 * |--NEWLINE -> \r\n 342 * }</pre> 343 * 344 * @see 345 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCBAHA"> 346 * Oracle Docs</a> 347 * @see #JAVADOC_TAG 348 */ 349 public static final int AUTHOR_LITERAL = JavadocParser.AUTHOR_LITERAL; 350 351 /** 352 * Name of custom Javadoc tag (or Javadoc inline tag). 353 * 354 * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p> 355 * 356 * <p><b>Example:</b></p> 357 * <pre>{@code @myJavadocTag some magic}</pre> 358 * <b>Tree:</b> 359 * <pre>{@code 360 * JAVADOC_TAG --> JAVADOC_TAG 361 * |--CUSTOM_NAME --> @myJavadocTag 362 * |--WS --> 363 * `--DESCRIPTION --> DESCRIPTION 364 * |--TEXT --> some magic 365 * }</pre> 366 */ 367 public static final int CUSTOM_NAME = JavadocParser.CUSTOM_NAME; 368 369 /** 370 * First child of {@link #JAVADOC_INLINE_TAG} that represents left curly brace '{'. 371 * 372 * <p><b>Example:</b></p> 373 * <pre><code>{@code Comparable<E>}</code></pre> 374 * <b>Tree:</b> 375 * <pre> 376 * <code> JAVADOC_INLINE_TAG --> JAVADOC_INLINE_TAG 377 * |--JAVADOC_INLINE_TAG_START --> { 378 * |--CODE_LITERAL --> @code 379 * |--WS --> 380 * |--TEXT --> Comparable<E> 381 * `--JAVADOC_INLINE_TAG_END --> } 382 * </code> 383 * </pre> 384 * 385 * @noinspection HtmlTagCanBeJavadocTag 386 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 387 * replaced with Javadoc tag 388 */ 389 public static final int JAVADOC_INLINE_TAG_START = JavadocParser.JAVADOC_INLINE_TAG_START; 390 391 /** 392 * Last child of {@link #JAVADOC_INLINE_TAG} that represents right curly brace '}'. 393 * 394 * <p><b>Example:</b></p> 395 * <pre><code>{@code Comparable<E>}</code></pre> 396 * <b>Tree:</b> 397 * <pre> 398 * <code>JAVADOC_INLINE_TAG --> JAVADOC_INLINE_TAG 399 * |--JAVADOC_INLINE_TAG_START --> { 400 * |--CODE_LITERAL --> @code 401 * |--WS --> 402 * |--TEXT --> Comparable<E> 403 * `--JAVADOC_INLINE_TAG_END --> } 404 * 405 * </code> 406 * </pre> 407 * 408 * @noinspection HtmlTagCanBeJavadocTag 409 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 410 * replaced with Javadoc tag 411 */ 412 public static final int JAVADOC_INLINE_TAG_END = JavadocParser.JAVADOC_INLINE_TAG_END; 413 414 /** 415 * '@code' literal in {@code} Javadoc inline tag. 416 * 417 * <p>Such Javadoc inline tag can have such child nodes:</p> 418 * <ul> 419 * <li>{@link #NEWLINE}</li> 420 * <li>{@link #WS}</li> 421 * <li>{@link #TEXT}</li> 422 * </ul> 423 * 424 * <p><b>Example:</b></p> 425 * <pre><code>{@code Comparable<E>}</code></pre> 426 * <b>Tree:</b> 427 * <pre> 428 * <code>JAVADOC_TAG -> JAVADOC_TAG 429 * |--CUSTOM_NAME -> @code 430 * |--WS -> 431 * `--DESCRIPTION -> DESCRIPTION 432 * |--TEXT -> Comparable<E> 433 * </code> 434 * </pre> 435 * 436 * @see 437 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDFHHBB"> 438 * Oracle Docs</a> 439 * @see #JAVADOC_INLINE_TAG 440 * @noinspection HtmlTagCanBeJavadocTag 441 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 442 * replaced with Javadoc tag 443 */ 444 public static final int CODE_LITERAL = JavadocParser.CODE_LITERAL; 445 446 /** 447 * '@docRoot' literal in {@docRoot} Javadoc inline tag. 448 * 449 * <p>Such Javadoc inline tag does not have any arguments and can have such child nodes:</p> 450 * <ul> 451 * <li>{@link #NEWLINE}</li> 452 * <li>{@link #WS}</li> 453 * </ul> 454 * 455 * <p><b>Example:</b></p> 456 * <pre><code>{@docRoot}</code></pre> 457 * <b>Tree:</b> 458 * <pre> 459 * <code> |--JAVADOC_INLINE_TAG[1x0] : [{@docRoot}] 460 * |--JAVADOC_INLINE_TAG_START[1x0] : [{] 461 * |--DOC_ROOT_LITERAL[1x1] : [@docRoot] 462 * |--JAVADOC_INLINE_TAG_END[2x0] : [}] 463 * </code> 464 * </pre> 465 * 466 * <p><b>Example:</b></p> 467 * <pre><code>{@docRoot 468 * }</code></pre> 469 * <b>Tree:</b> 470 * <pre> 471 * <code> |--JAVADOC_INLINE_TAG[1x0] : [{@docRoot \n}] 472 * |--JAVADOC_INLINE_TAG_START[1x0] : [{] 473 * |--DOC_ROOT_LITERAL[1x1] : [@docRoot] 474 * |--WS[1x9] : [ ] 475 * |--NEWLINE[1x10] : [\n] 476 * |--JAVADOC_INLINE_TAG_END[2x0] : [}] 477 * </code> 478 * </pre> 479 * 480 * @see 481 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDBACBF"> 482 * Oracle Docs</a> 483 * @see #JAVADOC_INLINE_TAG 484 * @noinspection HtmlTagCanBeJavadocTag 485 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 486 * replaced with Javadoc tag 487 */ 488 public static final int DOC_ROOT_LITERAL = JavadocParser.DOC_ROOT_LITERAL; 489 490 /** 491 * '@link' literal in {@link} Javadoc inline tag. 492 * 493 * <p>Such Javadoc inline tag can have one argument - {@link #REFERENCE}</p> 494 * 495 * <p><b>Example:</b></p> 496 * 497 * <pre><code>{@link org.apache.utils.Lists.Comparator#compare(Object)}</code></pre> 498 * 499 * <p><b>Tree:</b></p> 500 * 501 * <pre> 502 * <code> |--JAVADOC_INLINE_TAG[1x0] : 503 * [{@link org.apache.utils.Lists.Comparator#compare(Object)}] 504 * |--JAVADOC_INLINE_TAG_START[1x0] : [{] 505 * |--LINK_LITERAL[1x1] : [@link] 506 * |--WS[1x6] : [ ] 507 * |--REFERENCE[1x7] : [org.apache.utils.Lists.Comparator#compare(Object)] 508 * |--PACKAGE_CLASS[1x7] : [org.apache.utils] 509 * |--DOT[1x23] : [.] 510 * |--CLASS[1x24] : [Lists] 511 * |--DOT[1x29] : [.] 512 * |--CLASS[1x30] : [Comparator] 513 * |--HASH[1x40] : [#] 514 * |--MEMBER[1x41] : [compare] 515 * |--PARAMETERS[1x48] : [(Object)] 516 * |--LEFT_BRACE[1x48] : [(] 517 * |--ARGUMENT[1x49] : [Object] 518 * |--RIGHT_BRACE[1x55] : [)] 519 * |--JAVADOC_INLINE_TAG_END[1x56] : [}] 520 * </code> 521 * </pre> 522 * 523 * @see 524 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDIECH"> 525 * Oracle Docs</a> 526 * @see #JAVADOC_INLINE_TAG 527 * @noinspection HtmlTagCanBeJavadocTag 528 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 529 * replaced with Javadoc tag 530 */ 531 public static final int LINK_LITERAL = JavadocParser.LINK_LITERAL; 532 533 /** 534 * '@inheritDoc' literal in {@inheritDoc} Javadoc inline tag. 535 * 536 * <p>Such Javadoc inline tag does not have any arguments and can have such child nodes:</p> 537 * <ul> 538 * <li>{@link #NEWLINE}</li> 539 * <li>{@link #WS}</li> 540 * </ul> 541 * 542 * <p><b>Example:</b></p> 543 * <pre><code>{@inheritDoc}</code></pre> 544 * <b>Tree:</b> 545 * <pre>{@code 546 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 547 * |--JAVADOC_INLINE_TAG_START -> { 548 * |--INHERIT_DOC_LITERAL -> @inheritDoc 549 * |--JAVADOC_INLINE_TAG_END -> } 550 * }</pre> 551 * 552 * @see 553 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDGJCHC"> 554 * Oracle Docs</a> 555 * @see #JAVADOC_INLINE_TAG 556 * @noinspection HtmlTagCanBeJavadocTag 557 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 558 * replaced with Javadoc tag 559 */ 560 public static final int INHERIT_DOC_LITERAL = JavadocParser.INHERIT_DOC_LITERAL; 561 562 /** 563 * '@linkplain' literal in {@linkplain} Javadoc inline tag. 564 * 565 * <p>Such Javadoc inline tag can have one argument - {@link #REFERENCE}</p> 566 * 567 * <p><b>Example:</b></p> 568 * <pre><code>{@linkplain org.apache.utils.Lists.Comparator#compare(Object) compare}</code> 569 * </pre> 570 * <b>Tree:</b> 571 * <pre>{@code 572 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 573 * |--JAVADOC_INLINE_TAG_START -> { 574 * |--LINKPLAIN_LITERAL -> @linkplain 575 * |--WS -> 576 * |--REFERENCE -> org.apache.utils.Lists.Comparator#compare(Object) 577 * |--PACKAGE_CLASS -> org.apache.utils 578 * |--DOT -> . 579 * |--CLASS -> Lists 580 * |--DOT -> . 581 * |--CLASS -> Comparator 582 * |--HASH -> # 583 * |--MEMBER -> compare 584 * |--PARAMETERS -> (Object) 585 * |--LEFT_BRACE -> ( 586 * |--ARGUMENT -> Object 587 * |--RIGHT_BRACE -> ) 588 * |--DESCRIPTION -> compare 589 * |--TEXT -> compare 590 * |--JAVADOC_INLINE_TAG_END -> } 591 * }</pre> 592 * 593 * @see 594 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDGBICD"> 595 * Oracle Docs</a> 596 * @see #JAVADOC_INLINE_TAG 597 * @noinspection HtmlTagCanBeJavadocTag 598 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 599 * replaced with Javadoc tag 600 */ 601 public static final int LINKPLAIN_LITERAL = JavadocParser.LINKPLAIN_LITERAL; 602 603 /** 604 * '@literal' literal in {@literal} Javadoc inline tag. 605 * 606 * <p>Such Javadoc inline tag can have such child nodes:</p> 607 * <ul> 608 * <li>{@link #NEWLINE}</li> 609 * <li>{@link #WS}</li> 610 * <li>{@link #TEXT}</li> 611 * </ul> 612 * 613 * <p><b>Example:</b></p> 614 * <pre><code>{@literal #compare(Object)}</code></pre> 615 * <b>Tree:</b> 616 * <pre> 617 * <code> 618 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 619 * |--JAVADOC_INLINE_TAG_START -> { 620 * |--LITERAL_LITERAL -> @literal 621 * |--WS -> 622 * |--TEXT -> #compare(Object) 623 * `--JAVADOC_INLINE_TAG_END -> } 624 * </code> 625 * </pre> 626 * 627 * @see 628 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCFJDG"> 629 * Oracle Docs</a> 630 * @see #JAVADOC_INLINE_TAG 631 * @noinspection HtmlTagCanBeJavadocTag 632 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 633 * replaced with Javadoc tag 634 */ 635 public static final int LITERAL_LITERAL = JavadocParser.LITERAL_LITERAL; 636 637 /** 638 * '@value' literal in {@value} Javadoc inline tag. 639 * 640 * <p>Such Javadoc inline tag has one argument {@link #REFERENCE} 641 * and can have such child nodes:</p> 642 * <ul> 643 * <li>{@link #NEWLINE}</li> 644 * <li>{@link #WS}</li> 645 * </ul> 646 * 647 * <p><b>Example:</b></p> 648 * <pre><code>{@value Integer#MAX_VALUE}</code></pre> 649 * <b>Tree:</b> 650 * <pre> 651 * <code> JAVADOC_INLINE_TAG --> JAVADOC_INLINE_TAG 652 * |--JAVADOC_INLINE_TAG_START --> { 653 * |--VALUE_LITERAL --> @value 654 * |--WS --> 655 * |--REFERENCE --> REFERENCE 656 * | |--PACKAGE_CLASS --> Integer 657 * | |--HASH --> # 658 * | `--MEMBER --> MAX_VALUE 659 * `--JAVADOC_INLINE_TAG_END --> } 660 * </code> 661 * </pre> 662 * 663 * @see 664 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDCDHH"> 665 * Oracle Docs</a> 666 * @see #JAVADOC_INLINE_TAG 667 * @noinspection HtmlTagCanBeJavadocTag 668 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 669 * replaced with Javadoc tag 670 */ 671 public static final int VALUE_LITERAL = JavadocParser.VALUE_LITERAL; 672 673 /** 674 * PACKAGE_CLASS represents the package or class which has been referenced in the `@see`, 675 * `@link`, `@linkplain` or `@value` javadoc tags. In the javadoc tree it shall be a child 676 * of {@link #REFERENCE}. 677 * <br> 678 * <strong>IMPORTANT:</strong> Constructs like 679 * {@code package.Class.NestedClassAtDepth1.NestedClassAtDepth2#member} are recognized by 680 * the javadoc tool from oracle, and no assumptions like, package names wouldn't consist of 681 * uppercase characters or class names begin with an uppercase character, are made. 682 * Also, <i>the reference</i> in a javadoc tag can consist just a package name or a 683 * simple class name or even a full class name. Thus, PACKAGE_CLASS can represent a 684 * package name or a simple class name or a full class name i.e. checkstyle doesn't 685 * resolve references at present. 686 * 687 * <p><b>Example:</b></p> 688 * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre> 689 * <b>Tree:</b> 690 * <pre> 691 * {@code 692 * JAVADOC_TAG -> JAVADOC_TAG 693 * |--SEE_LITERAL -> @see 694 * |--WS -> 695 * |--REFERENCE -> REFERENCE 696 * | |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator 697 * | |--HASH -> # 698 * | |--MEMBER -> compare 699 * | `--PARAMETERS -> PARAMETERS 700 * | |--LEFT_BRACE -> ( 701 * | |--ARGUMENT -> Object 702 * | `--RIGHT_BRACE -> ) 703 * |--NEWLINE -> \r\n 704 * `--WS -> 705 * } 706 * </pre> 707 */ 708 public static final int PACKAGE_CLASS = JavadocParser.PACKAGE_CLASS; 709 710 /** 711 * Hash character in {@link #REFERENCE}. 712 * Hash character is used before specifying a class member. 713 * 714 * <p><b>Example:</b></p> 715 * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre> 716 * <b>Tree:</b> 717 * <pre> 718 * {@code 719 * JAVADOC_TAG -> JAVADOC_TAG 720 * |--SEE_LITERAL -> @see 721 * |--WS -> 722 * |--REFERENCE -> REFERENCE 723 * |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator 724 * |--HASH -> # 725 * |--MEMBER -> compare 726 * `--PARAMETERS -> PARAMETERS 727 * |--LEFT_BRACE -> ( 728 * |--ARGUMENT -> Object 729 * `--RIGHT_BRACE -> ) 730 * } 731 * </pre> 732 */ 733 public static final int HASH = JavadocParser.HASH; 734 735 /** 736 * A class member in {@link #REFERENCE}. 737 * Class member is specified after {@link #HASH} symbol. 738 * 739 * <p><b>Example:</b></p> 740 * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre> 741 * <b>Tree:</b> 742 * <pre> 743 * {@code 744 * JAVADOC_TAG -> JAVADOC_TAG 745 * |--SEE_LITERAL -> @see 746 * |--WS -> 747 * |--REFERENCE -> REFERENCE 748 * |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator 749 * |--HASH -> # 750 * |--MEMBER -> compare 751 * `--PARAMETERS -> PARAMETERS 752 * |--LEFT_BRACE -> ( 753 * |--ARGUMENT -> Object 754 * `--RIGHT_BRACE -> ) 755 * } 756 * </pre> 757 */ 758 public static final int MEMBER = JavadocParser.MEMBER; 759 760 /** 761 * Left brace in {@link #PARAMETERS} part of {@link #REFERENCE}. 762 * 763 * <p><b>Example:</b></p> 764 * <pre>{@code @see #method(Processor, String)}</pre> 765 * <b>Tree:</b> 766 * <pre> 767 * {@code JAVADOC_TAG -> JAVADOC_TAG 768 * |--SEE_LITERAL -> @see 769 * |--WS -> 770 * |--REFERENCE -> REFERENCE 771 * | |--HASH -> # 772 * | |--MEMBER -> method 773 * | `--PARAMETERS -> PARAMETERS 774 * | |--LEFT_BRACE -> ( 775 * | |--ARGUMENT -> Processor 776 * | |--COMMA -> , 777 * | |--WS -> 778 * | |--ARGUMENT -> String 779 * | `--RIGHT_BRACE -> ) 780 * } 781 * </pre> 782 */ 783 public static final int LEFT_BRACE = JavadocParser.LEFT_BRACE; 784 785 /** 786 * Right brace in {@link #PARAMETERS} part of {@link #REFERENCE}. 787 * 788 * <p><b>Example:</b></p> 789 * <pre>{@code @see #method(Processor, String)}</pre> 790 * <b>Tree:</b> 791 * <pre> 792 * {@code JAVADOC_TAG -> JAVADOC_TAG 793 * |--SEE_LITERAL -> @see 794 * |--WS -> 795 * |--REFERENCE -> REFERENCE 796 * | |--HASH -> # 797 * | |--MEMBER -> method 798 * | `--PARAMETERS -> PARAMETERS 799 * | |--LEFT_BRACE -> ( 800 * | |--ARGUMENT -> Processor 801 * | |--COMMA -> , 802 * | |--WS -> 803 * | |--ARGUMENT -> String 804 * | `--RIGHT_BRACE -> ) 805 * } 806 * </pre> 807 */ 808 public static final int RIGHT_BRACE = JavadocParser.RIGHT_BRACE; 809 810 /** 811 * Argument definition in {@link #PARAMETERS} part of {@link #REFERENCE}. 812 * 813 * <p><b>Example:</b></p> 814 * <pre>{@code @see #method(Processor, String)}</pre> 815 * <b>Tree:</b> 816 * <pre> 817 * {@code JAVADOC_TAG -> JAVADOC_TAG 818 * |--SEE_LITERAL -> @see 819 * |--WS -> 820 * |--REFERENCE -> REFERENCE 821 * | |--HASH -> # 822 * | |--MEMBER -> method 823 * | `--PARAMETERS -> PARAMETERS 824 * | |--LEFT_BRACE -> ( 825 * | |--ARGUMENT -> Processor 826 * | |--COMMA -> , 827 * | |--WS -> 828 * | |--ARGUMENT -> String 829 * | `--RIGHT_BRACE -> ) 830 * `--NEWLINE -> \n 831 * } 832 * </pre> 833 */ 834 public static final int ARGUMENT = JavadocParser.ARGUMENT; 835 836 /** 837 * Comma separator between parameters in {@link #PARAMETERS} part of {@link #REFERENCE}. 838 * 839 * <p><b>Example:</b></p> 840 * <pre>{@code @see #method(Processor, String)}</pre> 841 * <b>Tree:</b> 842 * <pre> 843 * {@code 844 * JAVADOC_TAG -> JAVADOC_TAG 845 * |--SEE_LITERAL -> @see 846 * |--WS -> 847 * |--REFERENCE -> REFERENCE 848 * | |--HASH -> # 849 * | |--MEMBER -> method 850 * | `--PARAMETERS -> PARAMETERS 851 * | |--LEFT_BRACE -> ( 852 * | |--ARGUMENT -> Processor 853 * | |--COMMA -> , 854 * | |--WS -> 855 * | |--ARGUMENT -> String 856 * | `--RIGHT_BRACE -> ) 857 * |--NEWLINE -> \r\n 858 * `--WS -> 859 * } 860 * </pre> 861 * 862 * @see #PARAMETERS 863 * @see #REFERENCE 864 * @see #ARGUMENT 865 */ 866 public static final int COMMA = JavadocParser.COMMA; 867 868 /** 869 * Quoted text. 870 * One of possible {@code @see} tag arguments. 871 * 872 * <p><b>Example:</b></p> 873 * <pre>{@code @see "Spring Framework"}</pre> 874 * <b>Tree:</b> 875 * <pre> 876 * {@code 877 * JAVADOC_TAG -> JAVADOC_TAG 878 * |--SEE_LITERAL -> @see 879 * |--WS -> 880 * |--STRING -> "Spring Framework" 881 * |--NEWLINE -> \r\n 882 * `--WS -> 883 * } 884 * </pre> 885 * 886 * @see #SEE_LITERAL 887 */ 888 public static final int STRING = JavadocParser.STRING; 889 890 /** 891 * Exception class name. First argument in {@link #THROWS_LITERAL @throws} and 892 * {@link #EXCEPTION_LITERAL @exception} Javadoc tags. 893 * 894 * <p><b>Example:</b></p> 895 * <pre>{@code @throws IOException connection problems}</pre> 896 * <b>Tree:</b> 897 * <pre> 898 * {@code 899 * JAVADOC_TAG -> JAVADOC_TAG 900 * |--THROWS_LITERAL -> @throws 901 * |--WS -> 902 * |--CLASS_NAME -> IOException 903 * |--WS -> 904 * `--DESCRIPTION -> DESCRIPTION 905 * |--TEXT -> connection problems 906 * |--NEWLINE -> \r\n 907 * `--TEXT -> 908 * } 909 * </pre> 910 * 911 * @see #EXCEPTION_LITERAL 912 * @see #THROWS_LITERAL 913 */ 914 public static final int CLASS_NAME = JavadocParser.CLASS_NAME; 915 916 /** 917 * First argument in {@link #PARAM_LITERAL @param} Javadoc tag. 918 * 919 * <p><b>Example:</b></p> 920 * <pre>{@code @param T The bar.}</pre> 921 * <b>Tree:</b> 922 * <pre> 923 * {@code JAVADOC_TAG -> JAVADOC_TAG 924 * |--PARAM_LITERAL -> @param 925 * |--WS -> 926 * |--PARAMETER_NAME -> T 927 * |--WS -> 928 * `--DESCRIPTION -> DESCRIPTION 929 * |--TEXT -> The bar. 930 * |--NEWLINE -> \r\n 931 * `--TEXT -> 932 * } 933 * </pre> 934 * 935 * @see 936 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHJECF"> 937 * Oracle Docs</a> 938 * @see #PARAM_LITERAL 939 */ 940 public static final int PARAMETER_NAME = JavadocParser.PARAMETER_NAME; 941 942 /** 943 * 'exclude' literal. 944 * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments. 945 * 946 * <p><b>Example:</b></p> 947 * <pre>{@code @serial exclude}</pre> 948 * <b>Tree:</b> 949 * <pre> 950 * {@code 951 * JAVADOC_TAG -> JAVADOC_TAG 952 * |--SERIAL_LITERAL -> @serial 953 * |--WS -> 954 * `--DESCRIPTION -> DESCRIPTION 955 * |--TEXT -> serialized company name 956 * |--NEWLINE -> \r\n 957 * `--TEXT -> 958 * } 959 * </pre> 960 * 961 * @see 962 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF"> 963 * Oracle Docs</a> 964 * @see #SERIAL_LITERAL 965 */ 966 public static final int LITERAL_EXCLUDE = JavadocParser.LITERAL_EXCLUDE; 967 968 /** 969 * 'include' literal. 970 * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments. 971 * 972 * <p><b>Example:</b></p> 973 * <pre>{@code @serial include}</pre> 974 * <b>Tree:</b> 975 * <pre> 976 * {@code 977 * JAVADOC_TAG -> JAVADOC_TAG 978 * |--SERIAL_LITERAL -> @serial 979 * |--WS -> 980 * |--LITERAL_INCLUDE -> include 981 * |--NEWLINE -> \r\n 982 * `--WS -> 983 * } 984 * </pre> 985 * 986 * @see 987 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF"> 988 * Oracle Docs</a> 989 * @see #SERIAL_LITERAL 990 */ 991 public static final int LITERAL_INCLUDE = JavadocParser.LITERAL_INCLUDE; 992 993 /** 994 * Field name. First argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag. 995 * 996 * <p><b>Example:</b></p> 997 * <pre>{@code @serialField counter Integer objects counter}</pre> 998 * <b>Tree:</b> 999 * <pre> 1000 * {@code 1001 * JAVADOC_TAG -> JAVADOC_TAG 1002 * |--SERIAL_FIELD_LITERAL -> @serialField 1003 * |--WS -> 1004 * |--FIELD_NAME -> counter 1005 * |--WS -> 1006 * |--FIELD_TYPE -> Integer 1007 * |--WS -> 1008 * `--DESCRIPTION -> DESCRIPTION 1009 * |--TEXT -> objects counter 1010 * |--NEWLINE -> \r\n 1011 * `--TEXT -> 1012 * }</pre> 1013 * 1014 * @see 1015 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF"> 1016 * Oracle Docs</a> 1017 * @see #SERIAL_FIELD_LITERAL 1018 */ 1019 public static final int FIELD_NAME = JavadocParser.FIELD_NAME; 1020 1021 /** 1022 * Field type. Second argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag. 1023 * 1024 * <p><b>Example:</b></p> 1025 * <pre>{@code @serialField counter Integer objects counter}</pre> 1026 * <b>Tree:</b> 1027 * <pre> 1028 * {@code JAVADOC_TAG -> JAVADOC_TAG 1029 * |--SERIAL_FIELD_LITERAL -> @serialField 1030 * |--WS -> 1031 * |--FIELD_NAME -> counter 1032 * |--WS -> 1033 * |--FIELD_TYPE -> Integer 1034 * |--WS -> 1035 * `--DESCRIPTION -> DESCRIPTION 1036 * |--TEXT -> objects counter 1037 * `--NEWLINE -> \n 1038 * } 1039 * </pre> 1040 * 1041 * @see 1042 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF"> 1043 * Oracle Docs</a> 1044 * @see #SERIAL_FIELD_LITERAL 1045 */ 1046 public static final int FIELD_TYPE = JavadocParser.FIELD_TYPE; 1047 1048 // ------------------------------------------------------------------------------------------ // 1049 // ----------------- HTML TAGS ---------------------------------------------- // 1050 // ------------------------------------------------------------------------------------------ // 1051 1052 /** 1053 * Identifier inside HTML tag: tag name or attribute name. 1054 */ 1055 public static final int HTML_TAG_NAME = JavadocParser.HTML_TAG_NAME; 1056 1057 // HTML tag components 1058 1059 /** 1060 * Start html tag component: {@code '<'}. 1061 */ 1062 public static final int START = JavadocParser.START; 1063 1064 /** 1065 * Slash html tag component: {@code '/'}. 1066 */ 1067 public static final int SLASH = JavadocParser.SLASH; 1068 1069 /** 1070 * End html tag component: {@code '>'}. 1071 */ 1072 public static final int END = JavadocParser.END; 1073 1074 /** 1075 * Slash close html tag component: {@code '/>'}. 1076 */ 1077 public static final int SLASH_END = JavadocParser.SLASH_END; 1078 1079 /** 1080 * Equals html tag component: {@code '='}. 1081 */ 1082 public static final int EQUALS = JavadocParser.EQUALS; 1083 1084 /** 1085 * Attribute value html tag component. 1086 */ 1087 public static final int ATTR_VALUE = JavadocParser.ATTR_VALUE; 1088 1089 /////////////////////// HTML TAGS WITH OPTIONAL END TAG ///////////////////////////////////// 1090 /** Paragraph tag name. */ 1091 public static final int P_HTML_TAG_NAME = JavadocParser.P_HTML_TAG_NAME; 1092 1093 /** List item tag name. */ 1094 public static final int LI_HTML_TAG_NAME = JavadocParser.LI_HTML_TAG_NAME; 1095 1096 /** Table row tag name. */ 1097 public static final int TR_HTML_TAG_NAME = JavadocParser.TR_HTML_TAG_NAME; 1098 1099 /** Table cell tag name. */ 1100 public static final int TD_HTML_TAG_NAME = JavadocParser.TD_HTML_TAG_NAME; 1101 1102 /** Table header cell tag name. */ 1103 public static final int TH_HTML_TAG_NAME = JavadocParser.TH_HTML_TAG_NAME; 1104 1105 /** Body tag name. */ 1106 public static final int BODY_HTML_TAG_NAME = JavadocParser.BODY_HTML_TAG_NAME; 1107 1108 /** Colgroup tag name. */ 1109 public static final int COLGROUP_HTML_TAG_NAME = JavadocParser.COLGROUP_HTML_TAG_NAME; 1110 1111 /** Description of a term tag name. */ 1112 public static final int DD_HTML_TAG_NAME = JavadocParser.DD_HTML_TAG_NAME; 1113 1114 /** Description term tag name. */ 1115 public static final int DT_HTML_TAG_NAME = JavadocParser.DT_HTML_TAG_NAME; 1116 1117 /** Head tag name. */ 1118 public static final int HEAD_HTML_TAG_NAME = JavadocParser.HEAD_HTML_TAG_NAME; 1119 1120 /** Html tag name. */ 1121 public static final int HTML_HTML_TAG_NAME = JavadocParser.HTML_HTML_TAG_NAME; 1122 1123 /** Option tag name. */ 1124 public static final int OPTION_HTML_TAG_NAME = JavadocParser.OPTION_HTML_TAG_NAME; 1125 1126 /** Table body tag name. */ 1127 public static final int TBODY_HTML_TAG_NAME = JavadocParser.TBODY_HTML_TAG_NAME; 1128 1129 /** Table foot tag name. */ 1130 public static final int TFOOT_HTML_TAG_NAME = JavadocParser.TFOOT_HTML_TAG_NAME; 1131 1132 /** Table head tag name. */ 1133 public static final int THEAD_HTML_TAG_NAME = JavadocParser.THEAD_HTML_TAG_NAME; 1134 1135 /** `optgroup` tag name. */ 1136 public static final int OPTGROUP_HTML_TAG_NAME = JavadocParser.OPTGROUP_HTML_TAG_NAME; 1137 1138 /** `rb` tag name. */ 1139 public static final int RB_HTML_TAG_NAME = JavadocParser.RB_HTML_TAG_NAME; 1140 1141 /** `rt` tag name. */ 1142 public static final int RT_HTML_TAG_NAME = JavadocParser.RT_HTML_TAG_NAME; 1143 1144 /** `rtc` tag name. */ 1145 public static final int RTC_HTML_TAG_NAME = JavadocParser.RTC_HTML_TAG_NAME; 1146 1147 /** `rp` tag name. */ 1148 public static final int RP_HTML_TAG_NAME = JavadocParser.RP_HTML_TAG_NAME; 1149 /////////////////////////////////////////////////////////////////////////////////////////////// 1150 1151 /////////////////////// SINGLETON HTML TAGS ////////////////////////////////////////////////// 1152 /** Area tag name. */ 1153 public static final int AREA_HTML_TAG_NAME = JavadocParser.AREA_HTML_TAG_NAME; 1154 1155 /** Base tag name. */ 1156 public static final int BASE_HTML_TAG_NAME = JavadocParser.BASE_HTML_TAG_NAME; 1157 1158 /** Basefont tag name. */ 1159 public static final int BASEFONT_HTML_TAG_NAME = JavadocParser.BASEFONT_HTML_TAG_NAME; 1160 1161 /** 1162 * Br tag name. 1163 * 1164 * <p><b>Example:</b></p> 1165 * <pre>{@code text before break < br > text after break}</pre> 1166 * <b>Tree:</b> 1167 * <pre> 1168 * {@code 1169 * JAVADOC -> JAVADOC 1170 * |--NEWLINE -> \r\n 1171 * |--LEADING_ASTERISK -> * 1172 * |--TEXT -> text before break 1173 * |--HTML_ELEMENT -> HTML_ELEMENT 1174 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1175 * | `--BR_TAG -> BR_TAG 1176 * | |--START -> -< 1177 * | |--BR_HTML_TAG_NAME -> br 1178 * | `--END -> > 1179 * |--TEXT -> text after break 1180 * |--NEWLINE -> \r\n 1181 * |--TEXT -> 1182 * } 1183 * </pre> 1184 */ 1185 1186 public static final int BR_HTML_TAG_NAME = JavadocParser.BR_HTML_TAG_NAME; 1187 1188 /** Col tag name. */ 1189 public static final int COL_HTML_TAG_NAME = JavadocParser.COL_HTML_TAG_NAME; 1190 1191 /** Frame tag name. */ 1192 public static final int FRAME_HTML_TAG_NAME = JavadocParser.FRAME_HTML_TAG_NAME; 1193 1194 /** Hr tag name. */ 1195 public static final int HR_HTML_TAG_NAME = JavadocParser.HR_HTML_TAG_NAME; 1196 1197 /** Img tag name. */ 1198 public static final int IMG_HTML_TAG_NAME = JavadocParser.IMG_HTML_TAG_NAME; 1199 1200 /** Input tag name. */ 1201 public static final int INPUT_HTML_TAG_NAME = JavadocParser.INPUT_HTML_TAG_NAME; 1202 1203 /** Isindex tag name. */ 1204 public static final int ISINDEX_HTML_TAG_NAME = JavadocParser.ISINDEX_HTML_TAG_NAME; 1205 1206 /** Link tag name. */ 1207 public static final int LINK_HTML_TAG_NAME = JavadocParser.LINK_HTML_TAG_NAME; 1208 1209 /** Meta tag name. */ 1210 public static final int META_HTML_TAG_NAME = JavadocParser.META_HTML_TAG_NAME; 1211 1212 /** Param tag name. */ 1213 public static final int PARAM_HTML_TAG_NAME = JavadocParser.PARAM_HTML_TAG_NAME; 1214 /** "embed" tag name. */ 1215 public static final int EMBED_HTML_TAG_NAME = JavadocParser.EMBED_HTML_TAG_NAME; 1216 /** "keygen" tag name. */ 1217 public static final int KEYGEN_HTML_TAG_NAME = JavadocParser.KEYGEN_HTML_TAG_NAME; 1218 /** "source" tag name. */ 1219 public static final int SOURCE_HTML_TAG_NAME = JavadocParser.SOURCE_HTML_TAG_NAME; 1220 /** "track" tag name. */ 1221 public static final int TRACK_HTML_TAG_NAME = JavadocParser.TRACK_HTML_TAG_NAME; 1222 /** "wbr" tag name. */ 1223 public static final int WBR_HTML_TAG_NAME = JavadocParser.WBR_HTML_TAG_NAME; 1224 /////////////////////////////////////////////////////////////////////////////////////////////// 1225 1226 /** 1227 * HTML comment start symbol '<!--'. 1228 */ 1229 public static final int HTML_COMMENT_START = JavadocParser.HTML_COMMENT_START; 1230 1231 /** 1232 * HTML comment end symbol '-->'. 1233 */ 1234 public static final int HTML_COMMENT_END = JavadocParser.HTML_COMMENT_END; 1235 1236 // ------------------------------------------------------------------------------------------ // 1237 // ----------------- OTHER -------------------------------------------------- // 1238 // ------------------------------------------------------------------------------------------ // 1239 1240 /** Leading asterisk. */ 1241 public static final int LEADING_ASTERISK = JavadocParser.LEADING_ASTERISK; 1242 1243 /** 1244 * Newline symbol - '\n'. 1245 */ 1246 public static final int NEWLINE = JavadocParser.NEWLINE; 1247 1248 /** 1249 * Any other symbol. 1250 */ 1251 public static final int CHAR = JavadocParser.CHAR; 1252 1253 /** 1254 * Whitespace or tab ('\t') symbol. 1255 */ 1256 public static final int WS = JavadocParser.WS; 1257 1258 /** 1259 * End Of File symbol. Copied from 1260 * {@link org.antlr.v4.runtime.Recognizer#EOF} to avoid ANTLR dependency in 1261 * API. 1262 */ 1263 public static final int EOF = -1; 1264 1265 // ------------------------------------------------------------------------------------------ // 1266 // ------ JAVADOC TAGS DEPENDING ON RULE TYPES OFFSET --------------------------------------- // 1267 // ------------------------------------------------------------------------------------------ // 1268 1269 /** 1270 * Rule types offset. 1271 * RULE_TYPES_OFFSET constant is used to split lexer tokens types and parser rules types. 1272 * We need unique numbers for all tokens, 1273 * ANTLR do not need this and that is why these types are mixed by used values. 1274 * All values we can take a look at 1275 * target/generated-sources/antlr/com/puppycrawl/tools/checkstyle/grammar/javadoc/JavadocParser.java 1276 * For example: LEADING_ASTERISK=1 and RULE_htmlElement = 1. 1277 * RULE_TYPES_OFFSET required to shift parser rules, 1278 * to let them not overlap with types that have prefix "RULE_". 1279 */ 1280 private static final int RULE_TYPES_OFFSET = 10000; 1281 1282 /** 1283 * Root node of any Javadoc comment. 1284 * Last child is always {@link #EOF}. 1285 * 1286 * <p><b>Tree for example:</b></p> 1287 * <pre>{@code 1288 * JAVADOC[3x0] 1289 * |--NEWLINE[3x0] : [\n] 1290 * |--LEADING_ASTERISK[4x0] : [ *] 1291 * |--WS[4x2] : [ ] 1292 * |--JAVADOC_TAG[4x3] : [@param T The bar.\n ] 1293 * |--PARAM_LITERAL[4x3] : [@param] 1294 * |--WS[4x9] : [ ] 1295 * |--PARAMETER_NAME[4x10] : [T] 1296 * |--WS[4x11] : [ ] 1297 * |--DESCRIPTION[4x12] : [The bar.\n ] 1298 * |--TEXT[4x12] : [The bar.] 1299 * |--NEWLINE[4x20] : [\n] 1300 * |--TEXT[5x0] : [ ] 1301 * |--EOF[5x1] : [<EOF>] 1302 * }</pre> 1303 */ 1304 public static final int JAVADOC = JavadocParser.RULE_javadoc + RULE_TYPES_OFFSET; 1305 1306 /** 1307 * Javadoc tag. 1308 * 1309 * <p>Type of Javadoc tag is resolved by literal node that is first child of this node.</p> 1310 * 1311 * <p>As literal could be:</p> 1312 * <ul> 1313 * <li>{@link #RETURN_LITERAL}</li> 1314 * <li>{@link #DEPRECATED_LITERAL}</li> 1315 * <li>{@link #SINCE_LITERAL}</li> 1316 * <li>{@link #SERIAL_DATA_LITERAL}</li> 1317 * <li>{@link #SERIAL_FIELD_LITERAL}</li> 1318 * <li>{@link #PARAM_LITERAL}</li> 1319 * <li>{@link #SEE_LITERAL}</li> 1320 * <li>{@link #SERIAL_LITERAL}</li> 1321 * <li>{@link #VERSION_LITERAL}</li> 1322 * <li>{@link #EXCEPTION_LITERAL}</li> 1323 * <li>{@link #THROWS_LITERAL}</li> 1324 * <li>{@link #AUTHOR_LITERAL}</li> 1325 * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc tag.</li> 1326 * </ul> 1327 * 1328 * <p><b>Example</b></p> 1329 * <pre>{@code @param T The bar.}</pre> 1330 * <b>Tree</b> 1331 * <pre>{@code 1332 * JAVADOC_TAG -> JAVADOC_TAG 1333 * |--PARAM_LITERAL -> @param 1334 * |--WS -> 1335 * |--PARAMETER_NAME -> T 1336 * |--WS -> 1337 * `--DESCRIPTION -> DESCRIPTION 1338 * |--TEXT -> The bar. 1339 * |--NEWLINE -> \r\n 1340 * `--TEXT -> 1341 * }</pre> 1342 */ 1343 1344 public static final int JAVADOC_TAG = JavadocParser.RULE_javadocTag + RULE_TYPES_OFFSET; 1345 /** 1346 * Javadoc inline tag. 1347 * 1348 * <p>Type of Javadoc inline tag is resolved by literal node that is second child of this node. 1349 * First child is always {@link #JAVADOC_INLINE_TAG_START} and last node is always 1350 * {@link #JAVADOC_INLINE_TAG_END}.</p> 1351 * 1352 * <p>As literal could be:</p> 1353 * <ul> 1354 * <li>{@link #CODE_LITERAL}</li> 1355 * <li>{@link #DOC_ROOT_LITERAL}</li> 1356 * <li>{@link #LINK_LITERAL}</li> 1357 * <li>{@link #INHERIT_DOC_LITERAL}</li> 1358 * <li>{@link #LINKPLAIN_LITERAL}</li> 1359 * <li>{@link #LITERAL_LITERAL}</li> 1360 * <li>{@link #VALUE_LITERAL}</li> 1361 * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc inline tag.</li> 1362 * </ul> 1363 * 1364 * <p><b>Example:</b></p> 1365 * <pre><code>{@link String}</code></pre> 1366 * <b>Tree:</b> 1367 * <pre> 1368 * {@code 1369 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1370 * |--JAVADOC_INLINE_TAG_START -> { 1371 * |--LINK_LITERAL -> @link 1372 * |--WS -> 1373 * |--REFERENCE -> REFERENCE 1374 * `--PACKAGE_CLASS -> String 1375 * `--JAVADOC_INLINE_TAG_END -> } 1376 * } 1377 * </pre> 1378 * 1379 * @noinspection HtmlTagCanBeJavadocTag 1380 * @noinspection HtmlTagCanBeJavadocTag 1381 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 1382 * replaced with Javadoc tag 1383 */ 1384 public static final int JAVADOC_INLINE_TAG = JavadocParser.RULE_javadocInlineTag 1385 + RULE_TYPES_OFFSET; 1386 1387 /** 1388 * Parameter of the Javadoc tags listed below. 1389 * <ul> 1390 * <li>{@link #SEE_LITERAL @see}</li> 1391 * <li>{@link #LINK_LITERAL {@link}}</li> 1392 * <li>{@link #LINKPLAIN_LITERAL {@linkplain}}</li> 1393 * <li>{@link #VALUE_LITERAL {@value}}</li> 1394 * </ul> 1395 */ 1396 public static final int REFERENCE = JavadocParser.RULE_reference + RULE_TYPES_OFFSET; 1397 1398 /** 1399 * Parameters part in {@link #REFERENCE}. 1400 * It is used to specify parameters for {@link #MEMBER method}. 1401 * Always contains {@link #LEFT_BRACE} as first child and {@link #RIGHT_BRACE} as last child. 1402 * Each parameter is represented by {@link #ARGUMENT} node. 1403 * Arguments in braces are separated by {@link #COMMA} (and optional {@link #WS}). 1404 * 1405 * <p><b>Example:</b></p> 1406 * <pre>{@code @see #method(Processor, String)}</pre> 1407 * <b>Tree:</b> 1408 * <pre> 1409 * {@code 1410 * JAVADOC_TAG -> JAVADOC_TAG 1411 * |--SEE_LITERAL -> @see 1412 * |--WS -> 1413 * |--REFERENCE -> REFERENCE 1414 * |--HASH -> # 1415 * |--MEMBER -> method 1416 * `--PARAMETERS -> PARAMETERS 1417 * |--LEFT_BRACE -> ( 1418 * |--ARGUMENT -> Processor 1419 * |--COMMA -> , 1420 * |--WS -> 1421 * |--ARGUMENT -> String 1422 * `--RIGHT_BRACE -> ) 1423 * } 1424 * </pre> 1425 */ 1426 public static final int PARAMETERS = JavadocParser.RULE_parameters + RULE_TYPES_OFFSET; 1427 1428 /** 1429 * Description node. It contains: 1430 * <ul> 1431 * <li>{@link #TEXT}</li> 1432 * <li>{@link #WS}</li> 1433 * <li>{@link #NEWLINE}</li> 1434 * <li>{@link #HTML_ELEMENT}</li> 1435 * </ul> 1436 * 1437 * <p>It is argument for many Javadoc tags and inline tags.</p> 1438 * 1439 * <p><b>Example:</b></p> 1440 * <pre>{@code @throws IOException if <b>connection</b> problems occur}</pre> 1441 * <b>Tree:</b> 1442 * <pre> 1443 * {@code 1444 * JAVADOC_TAG -> JAVADOC_TAG 1445 * |--THROWS_LITERAL -> @throws 1446 * |--WS -> 1447 * |--CLASS_NAME -> IOException 1448 * |--WS -> 1449 * `--DESCRIPTION -> DESCRIPTION 1450 * |--TEXT -> if 1451 * |--HTML_ELEMENT -> HTML_ELEMENT 1452 * | `--HTML_TAG -> HTML_TAG 1453 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1454 * | | |--START -> < 1455 * | | |--HTML_TAG_NAME -> b 1456 * | | `--END -> > 1457 * | |--TEXT -> connection 1458 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1459 * | |--START -> -< 1460 * | |--SLASH -> / 1461 * | |--HTML_TAG_NAME -> b 1462 * | `--END -> -> 1463 * |--TEXT -> problems occur 1464 * } 1465 * </pre> 1466 */ 1467 public static final int DESCRIPTION = JavadocParser.RULE_description + RULE_TYPES_OFFSET; 1468 1469 // ------------------------------------------------------------------------------------------ // 1470 // -------- HTML TAGS DEPENDING ON RULE TYPES OFFSET ---------------------------------------- // 1471 // ------------------------------------------------------------------------------------------ // 1472 1473 /** 1474 * Parent node for all html tags. 1475 */ 1476 public static final int HTML_ELEMENT = JavadocParser.RULE_htmlElement 1477 + RULE_TYPES_OFFSET; 1478 1479 /** 1480 * Start html tag: <XXXX>. 1481 */ 1482 public static final int HTML_ELEMENT_START = JavadocParser.RULE_htmlElementStart 1483 + RULE_TYPES_OFFSET; 1484 1485 /** 1486 * End html tag: <XXXX>. 1487 */ 1488 public static final int HTML_ELEMENT_END = JavadocParser.RULE_htmlElementEnd 1489 + RULE_TYPES_OFFSET; 1490 1491 /** 1492 * Non-special HTML tag. 1493 */ 1494 public static final int HTML_TAG = JavadocParser.RULE_htmlTag + RULE_TYPES_OFFSET; 1495 1496 /** 1497 * Html tag attribute. Parent node for: {@code HTML_TAG_IDENT, EQUALS, ATTR_VALUE}. 1498 */ 1499 public static final int ATTRIBUTE = JavadocParser.RULE_attribute 1500 + RULE_TYPES_OFFSET; 1501 1502 /////////////////////// HTML TAGS WITH OPTIONAL END TAG ///////////////////////////////////// 1503 /** Paragraph html tag: {@code <p></p>}. */ 1504 public static final int PARAGRAPH = JavadocParser.RULE_paragraph + RULE_TYPES_OFFSET; 1505 /** Start paragraph tag. */ 1506 public static final int P_TAG_START = JavadocParser.RULE_pTagStart + RULE_TYPES_OFFSET; 1507 /** End paragraph tag. */ 1508 public static final int P_TAG_END = JavadocParser.RULE_pTagEnd + RULE_TYPES_OFFSET; 1509 /** List item html tag: {@code <li></li>}. */ 1510 1511 public static final int LI = JavadocParser.RULE_li + RULE_TYPES_OFFSET; 1512 /** Start list item tag. */ 1513 public static final int LI_TAG_START = JavadocParser.RULE_liTagStart + RULE_TYPES_OFFSET; 1514 /** End list item tag. */ 1515 public static final int LI_TAG_END = JavadocParser.RULE_liTagEnd + RULE_TYPES_OFFSET; 1516 1517 /** 1518 * Table row html tag. 1519 * 1520 * <p><b>Example:</b></p> 1521 * <pre>{@code <tr></tr>}</pre> 1522 * <b>Tree:</b> 1523 * <pre> 1524 * {@code 1525 * JAVADOC -> JAVADOC 1526 * |--NEWLINE -> \r\n 1527 * |--LEADING_ASTERISK -> * 1528 * |--TEXT -> 1529 * |--HTML_ELEMENT -> HTML_ELEMENT 1530 * | `--TR -> TR 1531 * | |--TR_TAG_START -> TR_TAG_START 1532 * | | |--START -> < 1533 * | | |--TR_HTML_TAG_NAME -> tr 1534 * | | `--END -> > 1535 * | `--TR_TAG_END -> TR_TAG_END 1536 * | |--START -> < 1537 * | |--SLASH -> / 1538 * | |--TR_HTML_TAG_NAME -> tr 1539 * | `--END -> > 1540 * |--NEWLINE -> \r\n 1541 * |--TEXT -> 1542 * } 1543 * </pre> 1544 */ 1545 public static final int TR = JavadocParser.RULE_tr + RULE_TYPES_OFFSET; 1546 /** Start table row tag. */ 1547 public static final int TR_TAG_START = JavadocParser.RULE_trTagStart + RULE_TYPES_OFFSET; 1548 /** End table row tag. */ 1549 public static final int TR_TAG_END = JavadocParser.RULE_trTagEnd + RULE_TYPES_OFFSET; 1550 1551 /** Table cell html tag: {@code <td></td>}. */ 1552 public static final int TD = JavadocParser.RULE_td + RULE_TYPES_OFFSET; 1553 /** Start table cell tag. */ 1554 public static final int TD_TAG_START = JavadocParser.RULE_tdTagStart + RULE_TYPES_OFFSET; 1555 /** End table cell tag. */ 1556 public static final int TD_TAG_END = JavadocParser.RULE_tdTagEnd + RULE_TYPES_OFFSET; 1557 1558 /** Table header cell html tag: {@code <th></th>}. */ 1559 public static final int TH = JavadocParser.RULE_th + RULE_TYPES_OFFSET; 1560 /** Start table header cell tag. */ 1561 public static final int TH_TAG_START = JavadocParser.RULE_thTagStart + RULE_TYPES_OFFSET; 1562 /** End table header cell tag. */ 1563 public static final int TH_TAG_END = JavadocParser.RULE_thTagEnd + RULE_TYPES_OFFSET; 1564 1565 /** Body html tag. */ 1566 public static final int BODY = JavadocParser.RULE_body + RULE_TYPES_OFFSET; 1567 /** Start body tag. */ 1568 public static final int BODY_TAG_START = JavadocParser.RULE_bodyTagStart + RULE_TYPES_OFFSET; 1569 /** End body tag. */ 1570 public static final int BODY_TAG_END = JavadocParser.RULE_bodyTagEnd + RULE_TYPES_OFFSET; 1571 1572 /** Colgroup html tag. */ 1573 public static final int COLGROUP = JavadocParser.RULE_colgroup + RULE_TYPES_OFFSET; 1574 /** Start colgroup tag. */ 1575 public static final int COLGROUP_TAG_START = JavadocParser.RULE_colgroupTagStart 1576 + RULE_TYPES_OFFSET; 1577 /** End colgroup tag. */ 1578 public static final int COLGROUP_TAG_END = JavadocParser.RULE_colgroupTagEnd 1579 + RULE_TYPES_OFFSET; 1580 1581 /** Description of a term html tag: {@code <dd></dd>}. */ 1582 public static final int DD = JavadocParser.RULE_dd + RULE_TYPES_OFFSET; 1583 /** Start description of a term tag. */ 1584 public static final int DD_TAG_START = JavadocParser.RULE_ddTagStart + RULE_TYPES_OFFSET; 1585 /** End description of a term tag. */ 1586 public static final int DD_TAG_END = JavadocParser.RULE_ddTagEnd + RULE_TYPES_OFFSET; 1587 1588 /** Description term html tag: {@code <dt></dt>}. */ 1589 public static final int DT = JavadocParser.RULE_dt + RULE_TYPES_OFFSET; 1590 /** Start description term tag. */ 1591 public static final int DT_TAG_START = JavadocParser.RULE_dtTagStart + RULE_TYPES_OFFSET; 1592 /** End description term tag. */ 1593 public static final int DT_TAG_END = JavadocParser.RULE_dtTagEnd + RULE_TYPES_OFFSET; 1594 1595 /** Head html tag. */ 1596 public static final int HEAD = JavadocParser.RULE_head + RULE_TYPES_OFFSET; 1597 /** Start head tag. */ 1598 public static final int HEAD_TAG_START = JavadocParser.RULE_headTagStart + RULE_TYPES_OFFSET; 1599 /** End head tag. */ 1600 public static final int HEAD_TAG_END = JavadocParser.RULE_headTagEnd + RULE_TYPES_OFFSET; 1601 1602 /** Html html tag. */ 1603 public static final int HTML = JavadocParser.RULE_html + RULE_TYPES_OFFSET; 1604 /** Start html tag. */ 1605 public static final int HTML_TAG_START = JavadocParser.RULE_htmlTagStart + RULE_TYPES_OFFSET; 1606 /** End html tag. */ 1607 public static final int HTML_TAG_END = JavadocParser.RULE_htmlTagEnd + RULE_TYPES_OFFSET; 1608 1609 /** Option html tag. */ 1610 public static final int OPTION = JavadocParser.RULE_option + RULE_TYPES_OFFSET; 1611 /** Start option tag. */ 1612 public static final int OPTION_TAG_START = 1613 JavadocParser.RULE_optionTagStart + RULE_TYPES_OFFSET; 1614 /** End option tag. */ 1615 public static final int OPTION_TAG_END = JavadocParser.RULE_optionTagEnd 1616 + RULE_TYPES_OFFSET; 1617 1618 /** Table body html tag. */ 1619 public static final int TBODY = JavadocParser.RULE_tbody + RULE_TYPES_OFFSET; 1620 /** Start table body tag. */ 1621 public static final int TBODY_TAG_START = JavadocParser.RULE_tbodyTagStart + RULE_TYPES_OFFSET; 1622 /** End table body tag. */ 1623 public static final int TBODY_TAG_END = JavadocParser.RULE_tbodyTagEnd + RULE_TYPES_OFFSET; 1624 1625 /** Table foot html tag. */ 1626 public static final int TFOOT = JavadocParser.RULE_tfoot + RULE_TYPES_OFFSET; 1627 /** Start table foot tag. */ 1628 public static final int TFOOT_TAG_START = JavadocParser.RULE_tfootTagStart + RULE_TYPES_OFFSET; 1629 /** End table foot tag. */ 1630 public static final int TFOOT_TAG_END = JavadocParser.RULE_tfootTagEnd + RULE_TYPES_OFFSET; 1631 1632 /** Table head html tag. */ 1633 public static final int THEAD = JavadocParser.RULE_thead + RULE_TYPES_OFFSET; 1634 /** Start table head tag. */ 1635 public static final int THEAD_TAG_START = JavadocParser.RULE_theadTagStart + RULE_TYPES_OFFSET; 1636 /** End table head tag. */ 1637 public static final int THEAD_TAG_END = JavadocParser.RULE_theadTagEnd + RULE_TYPES_OFFSET; 1638 1639 /** `optgroup` html tag. */ 1640 public static final int OPTGROUP = JavadocParser.RULE_optgroup + RULE_TYPES_OFFSET; 1641 /** `optgroup` tag start. */ 1642 public static final int OPTGROUP_TAG_START = 1643 JavadocParser.RULE_optgroupTagStart + RULE_TYPES_OFFSET; 1644 /** `optgroup` tag end. */ 1645 public static final int OPTGROUP_TAG_END = 1646 JavadocParser.RULE_optgroupTagEnd + RULE_TYPES_OFFSET; 1647 1648 /** `rb` html tag. */ 1649 public static final int RB = JavadocParser.RULE_rb + RULE_TYPES_OFFSET; 1650 /** `rb` tag start. */ 1651 public static final int RB_TAG_START = 1652 JavadocParser.RULE_rbTagStart + RULE_TYPES_OFFSET; 1653 /** `rb` tag end. */ 1654 public static final int RB_TAG_END = 1655 JavadocParser.RULE_rbTagEnd + RULE_TYPES_OFFSET; 1656 1657 /** `rt` html tag. */ 1658 public static final int RT = JavadocParser.RULE_rt + RULE_TYPES_OFFSET; 1659 /** `rt` tag start. */ 1660 public static final int RT_TAG_START = 1661 JavadocParser.RULE_rtTagStart + RULE_TYPES_OFFSET; 1662 /** `rt` tag end. */ 1663 public static final int RT_TAG_END = 1664 JavadocParser.RULE_rtTagEnd + RULE_TYPES_OFFSET; 1665 1666 /** `rtc` html tag. */ 1667 public static final int RTC = JavadocParser.RULE_rtc + RULE_TYPES_OFFSET; 1668 /** `rtc` tag start. */ 1669 public static final int RTC_TAG_START = 1670 JavadocParser.RULE_rtcTagStart + RULE_TYPES_OFFSET; 1671 /** `rtc` tag end. */ 1672 public static final int RTC_TAG_END = 1673 JavadocParser.RULE_rtcTagEnd + RULE_TYPES_OFFSET; 1674 1675 /** `rp` html tag. */ 1676 public static final int RP = JavadocParser.RULE_rp + RULE_TYPES_OFFSET; 1677 /** `rp` tag start. */ 1678 public static final int RP_TAG_START = 1679 JavadocParser.RULE_rpTagStart + RULE_TYPES_OFFSET; 1680 /** `rp` tag end. */ 1681 public static final int RP_TAG_END = 1682 JavadocParser.RULE_rpTagEnd + RULE_TYPES_OFFSET; 1683 1684 /////////////////////// SINGLETON HTML TAGS ////////////////////////////////////////////////// 1685 /** 1686 * Parent node for all singleton html tags. 1687 */ 1688 public static final int SINGLETON_ELEMENT = JavadocParser.RULE_singletonElement 1689 + RULE_TYPES_OFFSET; 1690 1691 /** 1692 * Non-special empty html tag. 1693 */ 1694 public static final int EMPTY_TAG = JavadocParser.RULE_emptyTag 1695 + RULE_TYPES_OFFSET; 1696 1697 /** Area html tag. */ 1698 public static final int AREA_TAG = JavadocParser.RULE_areaTag + RULE_TYPES_OFFSET; 1699 1700 /** Base html tag. */ 1701 public static final int BASE_TAG = JavadocParser.RULE_baseTag + RULE_TYPES_OFFSET; 1702 1703 /** Basefont html tag. */ 1704 public static final int BASEFONT_TAG = JavadocParser.RULE_basefontTag + RULE_TYPES_OFFSET; 1705 1706 /** Br html tag. */ 1707 public static final int BR_TAG = JavadocParser.RULE_brTag + RULE_TYPES_OFFSET; 1708 1709 /** Col html tag. */ 1710 public static final int COL_TAG = JavadocParser.RULE_colTag + RULE_TYPES_OFFSET; 1711 1712 /** Frame html tag. */ 1713 public static final int FRAME_TAG = JavadocParser.RULE_frameTag + RULE_TYPES_OFFSET; 1714 1715 /** Hr html tag. */ 1716 public static final int HR_TAG = JavadocParser.RULE_hrTag + RULE_TYPES_OFFSET; 1717 1718 /** Img html tag. */ 1719 public static final int IMG_TAG = JavadocParser.RULE_imgTag + RULE_TYPES_OFFSET; 1720 1721 /** Input html tag. */ 1722 public static final int INPUT_TAG = JavadocParser.RULE_inputTag + RULE_TYPES_OFFSET; 1723 1724 /** Isindex html tag. */ 1725 public static final int ISINDEX_TAG = JavadocParser.RULE_isindexTag + RULE_TYPES_OFFSET; 1726 1727 /** Link html tag. */ 1728 public static final int LINK_TAG = JavadocParser.RULE_linkTag + RULE_TYPES_OFFSET; 1729 1730 /** Meta html tag. */ 1731 public static final int META_TAG = JavadocParser.RULE_metaTag + RULE_TYPES_OFFSET; 1732 1733 /** Param html tag. */ 1734 public static final int PARAM_TAG = JavadocParser.RULE_paramTag + RULE_TYPES_OFFSET; 1735 1736 /** 1737 * HTML void element {@code <embed>}. 1738 * 1739 * @see #SINGLETON_ELEMENT 1740 * @see <a href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-embed"> 1741 * W3 docs</a> 1742 */ 1743 public static final int EMBED_TAG = JavadocParser.RULE_embedTag + RULE_TYPES_OFFSET; 1744 1745 /** 1746 * HTML void element {@code <keygen>}. 1747 * 1748 * @see #SINGLETON_ELEMENT 1749 * @see <a href="https://www.w3.org/TR/html51/sec-forms.html#elementdef-keygen"> 1750 * W3 docs</a> 1751 */ 1752 public static final int KEYGEN_TAG = JavadocParser.RULE_keygenTag + RULE_TYPES_OFFSET; 1753 1754 /** 1755 * HTML void element {@code <source>}. 1756 * 1757 * @see #SINGLETON_ELEMENT 1758 * @see <a href= 1759 * "https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-media-source"> 1760 * W3 docs</a> 1761 */ 1762 public static final int SOURCE_TAG = JavadocParser.RULE_sourceTag + RULE_TYPES_OFFSET; 1763 1764 /** 1765 * HTML void element {@code <track>}. 1766 * 1767 * @see #SINGLETON_ELEMENT 1768 * @see <a 1769 * href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-track"> 1770 * W3 docs</a> 1771 */ 1772 public static final int TRACK_TAG = JavadocParser.RULE_trackTag + RULE_TYPES_OFFSET; 1773 1774 /** 1775 * HTML void element {@code <wbr>}. 1776 * 1777 * @see #SINGLETON_ELEMENT 1778 * @see <a href="https://www.w3.org/TR/html51/textlevel-semantics.html#elementdef-wbr"> 1779 * W3 docs</a> 1780 */ 1781 public static final int WBR_TAG = JavadocParser.RULE_wbrTag + RULE_TYPES_OFFSET; 1782 1783 /////////////////////////////////////////////////////////////////////////////////////////////// 1784 1785 /** 1786 * Html comment: <code><!-- --></code>. 1787 * 1788 * @noinspection HtmlTagCanBeJavadocTag 1789 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 1790 * replaced with Javadoc tag 1791 */ 1792 public static final int HTML_COMMENT = JavadocParser.RULE_htmlComment 1793 + RULE_TYPES_OFFSET; 1794 /** 1795 * CHAR and WS sequence. 1796 */ 1797 public static final int TEXT = JavadocParser.RULE_text + RULE_TYPES_OFFSET; 1798 1799 /** Empty private constructor of the current class. */ 1800 private JavadocTokenTypes() { 1801 } 1802 1803}