001/////////////////////////////////////////////////////////////////////////////////////////////// 002// checkstyle: Checks Java source code and other text files for adherence to a set of rules. 003// Copyright (C) 2001-2024 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_INLINE_TAG[3x0] : [{@code Comparable<E>}] 429 * |--JAVADOC_INLINE_TAG_START[3x0] : [{] 430 * |--CODE_LITERAL[3x1] : [@code] 431 * |--WS[3x6] : [ ] 432 * |--TEXT[3x7] : [Comparable<E>] 433 * |--JAVADOC_INLINE_TAG_END[3x21] : [}] 434 * </code> 435 * </pre> 436 * 437 * @see 438 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDFHHBB"> 439 * Oracle Docs</a> 440 * @see #JAVADOC_INLINE_TAG 441 * @noinspection HtmlTagCanBeJavadocTag 442 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 443 * replaced with Javadoc tag 444 */ 445 public static final int CODE_LITERAL = JavadocParser.CODE_LITERAL; 446 447 /** 448 * '@docRoot' literal in {@docRoot} Javadoc inline tag. 449 * 450 * <p>Such Javadoc inline tag does not have any arguments and can have such child nodes:</p> 451 * <ul> 452 * <li>{@link #NEWLINE}</li> 453 * <li>{@link #WS}</li> 454 * </ul> 455 * 456 * <p><b>Example:</b></p> 457 * <pre><code>{@docRoot}</code></pre> 458 * <b>Tree:</b> 459 * <pre> 460 * <code> |--JAVADOC_INLINE_TAG[1x0] : [{@docRoot}] 461 * |--JAVADOC_INLINE_TAG_START[1x0] : [{] 462 * |--DOC_ROOT_LITERAL[1x1] : [@docRoot] 463 * |--JAVADOC_INLINE_TAG_END[2x0] : [}] 464 * </code> 465 * </pre> 466 * 467 * <p><b>Example:</b></p> 468 * <pre><code>{@docRoot 469 * }</code></pre> 470 * <b>Tree:</b> 471 * <pre> 472 * <code> |--JAVADOC_INLINE_TAG[1x0] : [{@docRoot \n}] 473 * |--JAVADOC_INLINE_TAG_START[1x0] : [{] 474 * |--DOC_ROOT_LITERAL[1x1] : [@docRoot] 475 * |--WS[1x9] : [ ] 476 * |--NEWLINE[1x10] : [\n] 477 * |--JAVADOC_INLINE_TAG_END[2x0] : [}] 478 * </code> 479 * </pre> 480 * 481 * @see 482 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDBACBF"> 483 * Oracle Docs</a> 484 * @see #JAVADOC_INLINE_TAG 485 * @noinspection HtmlTagCanBeJavadocTag 486 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 487 * replaced with Javadoc tag 488 */ 489 public static final int DOC_ROOT_LITERAL = JavadocParser.DOC_ROOT_LITERAL; 490 491 /** 492 * '@link' literal in {@link} Javadoc inline tag. 493 * 494 * <p>Such Javadoc inline tag can have one argument - {@link #REFERENCE}</p> 495 * 496 * <p><b>Example:</b></p> 497 * 498 * <pre><code>{@link org.apache.utils.Lists.Comparator#compare(Object)}</code></pre> 499 * 500 * <p><b>Tree:</b></p> 501 * 502 * <pre> 503 * <code> |--JAVADOC_INLINE_TAG[1x0] : 504 * [{@link org.apache.utils.Lists.Comparator#compare(Object)}] 505 * |--JAVADOC_INLINE_TAG_START[1x0] : [{] 506 * |--LINK_LITERAL[1x1] : [@link] 507 * |--WS[1x6] : [ ] 508 * |--REFERENCE[1x7] : [org.apache.utils.Lists.Comparator#compare(Object)] 509 * |--PACKAGE_CLASS[1x7] : [org.apache.utils] 510 * |--DOT[1x23] : [.] 511 * |--CLASS[1x24] : [Lists] 512 * |--DOT[1x29] : [.] 513 * |--CLASS[1x30] : [Comparator] 514 * |--HASH[1x40] : [#] 515 * |--MEMBER[1x41] : [compare] 516 * |--PARAMETERS[1x48] : [(Object)] 517 * |--LEFT_BRACE[1x48] : [(] 518 * |--ARGUMENT[1x49] : [Object] 519 * |--RIGHT_BRACE[1x55] : [)] 520 * |--JAVADOC_INLINE_TAG_END[1x56] : [}] 521 * </code> 522 * </pre> 523 * 524 * @see 525 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDIECH"> 526 * Oracle Docs</a> 527 * @see #JAVADOC_INLINE_TAG 528 * @noinspection HtmlTagCanBeJavadocTag 529 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 530 * replaced with Javadoc tag 531 */ 532 public static final int LINK_LITERAL = JavadocParser.LINK_LITERAL; 533 534 /** 535 * '@inheritDoc' literal in {@inheritDoc} Javadoc inline tag. 536 * 537 * <p>Such Javadoc inline tag does not have any arguments and can have such child nodes:</p> 538 * <ul> 539 * <li>{@link #NEWLINE}</li> 540 * <li>{@link #WS}</li> 541 * </ul> 542 * 543 * <p><b>Example:</b></p> 544 * <pre><code>{@inheritDoc}</code></pre> 545 * <b>Tree:</b> 546 * <pre>{@code 547 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 548 * |--JAVADOC_INLINE_TAG_START -> { 549 * |--INHERIT_DOC_LITERAL -> @inheritDoc 550 * |--JAVADOC_INLINE_TAG_END -> } 551 * }</pre> 552 * 553 * @see 554 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDGJCHC"> 555 * Oracle Docs</a> 556 * @see #JAVADOC_INLINE_TAG 557 * @noinspection HtmlTagCanBeJavadocTag 558 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 559 * replaced with Javadoc tag 560 */ 561 public static final int INHERIT_DOC_LITERAL = JavadocParser.INHERIT_DOC_LITERAL; 562 563 /** 564 * '@linkplain' literal in {@linkplain} Javadoc inline tag. 565 * 566 * <p>Such Javadoc inline tag can have one argument - {@link #REFERENCE}</p> 567 * 568 * <p><b>Example:</b></p> 569 * <pre><code>{@linkplain org.apache.utils.Lists.Comparator#compare(Object) compare}</code> 570 * </pre> 571 * <b>Tree:</b> 572 * <pre>{@code 573 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 574 * |--JAVADOC_INLINE_TAG_START -> { 575 * |--LINKPLAIN_LITERAL -> @linkplain 576 * |--WS -> 577 * |--REFERENCE -> org.apache.utils.Lists.Comparator#compare(Object) 578 * |--PACKAGE_CLASS -> org.apache.utils 579 * |--DOT -> . 580 * |--CLASS -> Lists 581 * |--DOT -> . 582 * |--CLASS -> Comparator 583 * |--HASH -> # 584 * |--MEMBER -> compare 585 * |--PARAMETERS -> (Object) 586 * |--LEFT_BRACE -> ( 587 * |--ARGUMENT -> Object 588 * |--RIGHT_BRACE -> ) 589 * |--DESCRIPTION -> compare 590 * |--TEXT -> compare 591 * |--JAVADOC_INLINE_TAG_END -> } 592 * }</pre> 593 * 594 * @see 595 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDGBICD"> 596 * Oracle Docs</a> 597 * @see #JAVADOC_INLINE_TAG 598 * @noinspection HtmlTagCanBeJavadocTag 599 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 600 * replaced with Javadoc tag 601 */ 602 public static final int LINKPLAIN_LITERAL = JavadocParser.LINKPLAIN_LITERAL; 603 604 /** 605 * '@literal' literal in {@literal} Javadoc inline tag. 606 * 607 * <p>Such Javadoc inline tag can have such child nodes:</p> 608 * <ul> 609 * <li>{@link #NEWLINE}</li> 610 * <li>{@link #WS}</li> 611 * <li>{@link #TEXT}</li> 612 * </ul> 613 * 614 * <p><b>Example:</b></p> 615 * <pre><code>{@literal #compare(Object)}</code></pre> 616 * <b>Tree:</b> 617 * <pre> 618 * <code> 619 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 620 * |--JAVADOC_INLINE_TAG_START -> { 621 * |--LITERAL_LITERAL -> @literal 622 * |--WS -> 623 * |--TEXT -> #compare(Object) 624 * `--JAVADOC_INLINE_TAG_END -> } 625 * </code> 626 * </pre> 627 * 628 * @see 629 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCFJDG"> 630 * Oracle Docs</a> 631 * @see #JAVADOC_INLINE_TAG 632 * @noinspection HtmlTagCanBeJavadocTag 633 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 634 * replaced with Javadoc tag 635 */ 636 public static final int LITERAL_LITERAL = JavadocParser.LITERAL_LITERAL; 637 638 /** 639 * '@value' literal in {@value} Javadoc inline tag. 640 * 641 * <p>Such Javadoc inline tag has one argument {@link #REFERENCE} 642 * and can have such child nodes:</p> 643 * <ul> 644 * <li>{@link #NEWLINE}</li> 645 * <li>{@link #WS}</li> 646 * </ul> 647 * 648 * <p><b>Example:</b></p> 649 * <pre><code>{@value Integer#MAX_VALUE}</code></pre> 650 * <b>Tree:</b> 651 * <pre> 652 * <code> JAVADOC_INLINE_TAG --> JAVADOC_INLINE_TAG 653 * |--JAVADOC_INLINE_TAG_START --> { 654 * |--VALUE_LITERAL --> @value 655 * |--WS --> 656 * |--REFERENCE --> REFERENCE 657 * | |--PACKAGE_CLASS --> Integer 658 * | |--HASH --> # 659 * | `--MEMBER --> MAX_VALUE 660 * `--JAVADOC_INLINE_TAG_END --> } 661 * </code> 662 * </pre> 663 * 664 * @see 665 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDCDHH"> 666 * Oracle Docs</a> 667 * @see #JAVADOC_INLINE_TAG 668 * @noinspection HtmlTagCanBeJavadocTag 669 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 670 * replaced with Javadoc tag 671 */ 672 public static final int VALUE_LITERAL = JavadocParser.VALUE_LITERAL; 673 674 /** 675 * PACKAGE_CLASS represents the package or class which has been referenced in the `@see`, 676 * `@link`, `@linkplain` or `@value` javadoc tags. In the javadoc tree it shall be a child 677 * of {@link #REFERENCE}. 678 * <br> 679 * <strong>IMPORTANT:</strong> Constructs like 680 * {@code package.Class.NestedClassAtDepth1.NestedClassAtDepth2#member} are recognized by 681 * the javadoc tool from oracle, and no assumptions like, package names wouldn't consist of 682 * uppercase characters or class names begin with an uppercase character, are made. 683 * Also, <i>the reference</i> in a javadoc tag can consist just a package name or a 684 * simple class name or even a full class name. Thus, PACKAGE_CLASS can represent a 685 * package name or a simple class name or a full class name i.e. checkstyle doesn't 686 * resolve references at present. 687 * 688 * <p><b>Example:</b></p> 689 * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre> 690 * <b>Tree:</b> 691 * <pre> 692 * {@code |--JAVADOC_TAG[3x0] : [@see org.apache.utils.Lists.Comparator#compare(Object)] 693 * |--SEE_LITERAL[3x0] : [@see] 694 * |--WS[3x4] : [ ] 695 * |--REFERENCE[3x5] : [org.apache.utils.Lists.Comparator#compare(Object)] 696 * |--PACKAGE_CLASS[3x5] : [org.apache.utils] 697 * |--DOT[3x21] : [.] 698 * |--CLASS[3x22] : [Lists] 699 * |--DOT[3x27] : [.] 700 * |--CLASS[3x28] : [Comparator] 701 * |--HASH[3x38] : [#] 702 * |--MEMBER[3x39] : [compare] 703 * |--PARAMETERS[3x46] : [(Object)] 704 * |--LEFT_BRACE[3x46] : [(] 705 * |--ARGUMENT[3x47] : [Object] 706 * |--RIGHT_BRACE[3x53] : [)] 707 * } 708 * </pre> 709 */ 710 public static final int PACKAGE_CLASS = JavadocParser.PACKAGE_CLASS; 711 712 /** 713 * Hash character in {@link #REFERENCE}. 714 * Hash character is used before specifying a class member. 715 * 716 * <p><b>Example:</b></p> 717 * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre> 718 * <b>Tree:</b> 719 * <pre> 720 * {@code |--JAVADOC_TAG[3x0] : [@see org.apache.utils.Lists.Comparator#compare(Object)] 721 * |--SEE_LITERAL[3x0] : [@see] 722 * |--WS[3x4] : [ ] 723 * |--REFERENCE[3x5] : [org.apache.utils.Lists.Comparator#compare(Object)] 724 * |--PACKAGE_CLASS[3x5] : [org.apache.utils] 725 * |--DOT[3x21] : [.] 726 * |--CLASS[3x22] : [Lists] 727 * |--DOT[3x27] : [.] 728 * |--CLASS[3x28] : [Comparator] 729 * |--HASH[3x38] : [#] 730 * |--MEMBER[3x39] : [compare] 731 * |--PARAMETERS[3x46] : [(Object)] 732 * |--LEFT_BRACE[3x46] : [(] 733 * |--ARGUMENT[3x47] : [Object] 734 * |--RIGHT_BRACE[3x53] : [)] 735 * } 736 * </pre> 737 */ 738 public static final int HASH = JavadocParser.HASH; 739 740 /** 741 * A class member in {@link #REFERENCE}. 742 * Class member is specified after {@link #HASH} symbol. 743 * 744 * <p><b>Example:</b></p> 745 * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre> 746 * <b>Tree:</b> 747 * <pre> 748 * {@code |--JAVADOC_TAG[3x0] : [@see org.apache.utils.Lists.Comparator#compare(Object)] 749 * |--SEE_LITERAL[3x0] : [@see] 750 * |--WS[3x4] : [ ] 751 * |--REFERENCE[3x5] : [org.apache.utils.Lists.Comparator#compare(Object)] 752 * |--PACKAGE_CLASS[3x5] : [org.apache.utils] 753 * |--DOT[3x21] : [.] 754 * |--CLASS[3x22] : [Lists] 755 * |--DOT[3x27] : [.] 756 * |--CLASS[3x28] : [Comparator] 757 * |--HASH[3x38] : [#] 758 * |--MEMBER[3x39] : [compare] 759 * |--PARAMETERS[3x46] : [(Object)] 760 * |--LEFT_BRACE[3x46] : [(] 761 * |--ARGUMENT[3x47] : [Object] 762 * |--RIGHT_BRACE[3x53] : [)] 763 * } 764 * </pre> 765 */ 766 public static final int MEMBER = JavadocParser.MEMBER; 767 768 /** 769 * Left brace in {@link #PARAMETERS} part of {@link #REFERENCE}. 770 * 771 * <p><b>Example:</b></p> 772 * <pre>{@code @see #method(Processor, String)}</pre> 773 * <b>Tree:</b> 774 * <pre> 775 * {@code |--JAVADOC_TAG[1x0] : [@see #method(Processor, String)] 776 * |--SEE_LITERAL[1x0] : [@see] 777 * |--WS[1x4] : [ ] 778 * |--REFERENCE[1x5] : [#method(Processor, String)] 779 * |--HASH[1x5] : [#] 780 * |--MEMBER[1x6] : [method] 781 * |--PARAMETERS[1x12] : [(Processor, String)] 782 * |--LEFT_BRACE[1x12] : [(] 783 * |--ARGUMENT[1x13] : [Processor] 784 * |--COMMA[1x22] : [,] 785 * |--WS[1x23] : [ ] 786 * |--ARGUMENT[1x24] : [String] 787 * |--RIGHT_BRACE[1x30] : [)] 788 * } 789 * </pre> 790 */ 791 public static final int LEFT_BRACE = JavadocParser.LEFT_BRACE; 792 793 /** 794 * Right brace in {@link #PARAMETERS} part of {@link #REFERENCE}. 795 * 796 * <p><b>Example:</b></p> 797 * <pre>{@code @see #method(Processor, String)}</pre> 798 * <b>Tree:</b> 799 * <pre> 800 * {@code |--JAVADOC_TAG[1x0] : [@see #method(Processor, String)] 801 * |--SEE_LITERAL[1x0] : [@see] 802 * |--WS[1x4] : [ ] 803 * |--REFERENCE[1x5] : [#method(Processor, String)] 804 * |--HASH[1x5] : [#] 805 * |--MEMBER[1x6] : [method] 806 * |--PARAMETERS[1x12] : [(Processor, String)] 807 * |--LEFT_BRACE[1x12] : [(] 808 * |--ARGUMENT[1x13] : [Processor] 809 * |--COMMA[1x22] : [,] 810 * |--WS[1x23] : [ ] 811 * |--ARGUMENT[1x24] : [String] 812 * |--RIGHT_BRACE[1x30] : [)] 813 * } 814 * </pre> 815 */ 816 public static final int RIGHT_BRACE = JavadocParser.RIGHT_BRACE; 817 818 /** 819 * Argument definition in {@link #PARAMETERS} part of {@link #REFERENCE}. 820 * 821 * <p><b>Example:</b></p> 822 * <pre>{@code @see #method(Processor, String)}</pre> 823 * <b>Tree:</b> 824 * <pre> 825 * {@code |--JAVADOC_TAG[1x0] : [@see #method(Processor, String)] 826 * |--SEE_LITERAL[1x0] : [@see] 827 * |--WS[1x4] : [ ] 828 * |--REFERENCE[1x5] : [#method(Processor, String)] 829 * |--HASH[1x5] : [#] 830 * |--MEMBER[1x6] : [method] 831 * |--PARAMETERS[1x12] : [(Processor, String)] 832 * |--LEFT_BRACE[1x12] : [(] 833 * |--ARGUMENT[1x13] : [Processor] 834 * |--COMMA[1x22] : [,] 835 * |--WS[1x23] : [ ] 836 * |--ARGUMENT[1x24] : [String] 837 * |--RIGHT_BRACE[1x30] : [)] 838 * } 839 * </pre> 840 */ 841 public static final int ARGUMENT = JavadocParser.ARGUMENT; 842 843 /** 844 * Comma separator between parameters in {@link #PARAMETERS} part of {@link #REFERENCE}. 845 * 846 * <p><b>Example:</b></p> 847 * <pre>{@code @see #method(Processor, String)}</pre> 848 * <b>Tree:</b> 849 * <pre> 850 * {@code |--JAVADOC_TAG[1x0] : [@see #method(Processor, String)] 851 * |--SEE_LITERAL[1x0] : [@see] 852 * |--WS[1x4] : [ ] 853 * |--REFERENCE[1x5] : [#method(Processor, String)] 854 * |--HASH[1x5] : [#] 855 * |--MEMBER[1x6] : [method] 856 * |--PARAMETERS[1x12] : [(Processor, String)] 857 * |--LEFT_BRACE[1x12] : [(] 858 * |--ARGUMENT[1x13] : [Processor] 859 * |--COMMA[1x22] : [,] 860 * |--WS[1x23] : [ ] 861 * |--ARGUMENT[1x24] : [String] 862 * |--RIGHT_BRACE[1x30] : [)] 863 * } 864 * </pre> 865 * 866 * @see #PARAMETERS 867 * @see #REFERENCE 868 * @see #ARGUMENT 869 */ 870 public static final int COMMA = JavadocParser.COMMA; 871 872 /** 873 * Quoted text. 874 * One of possible {@code @see} tag arguments. 875 * 876 * <p><b>Example:</b></p> 877 * <pre>{@code @see "Spring Framework"}</pre> 878 * <b>Tree:</b> 879 * <pre> 880 * {@code |--JAVADOC_TAG[1x0] : [@see "Spring Framework"] 881 * |--SEE_LITERAL[1x0] : [@see] 882 * |--WS[1x4] : [ ] 883 * |--STRING[1x5] : ["Spring Framework"] 884 * } 885 * </pre> 886 * 887 * @see #SEE_LITERAL 888 */ 889 public static final int STRING = JavadocParser.STRING; 890 891 /** 892 * Exception class name. First argument in {@link #THROWS_LITERAL @throws} and 893 * {@link #EXCEPTION_LITERAL @exception} Javadoc tags. 894 * 895 * <p><b>Example:</b></p> 896 * <pre>{@code @throws IOException connection problems}</pre> 897 * <b>Tree:</b> 898 * <pre> 899 * {@code |--JAVADOC_TAG[1x0] : [@throws IOException connection problems] 900 * |--THROWS_LITERAL[1x0] : [@throws] 901 * |--WS[1x7] : [ ] 902 * |--CLASS_NAME[1x8] : [IOException] 903 * |--WS[1x19] : [ ] 904 * |--DESCRIPTION[1x20] : [connection problems] 905 * |--TEXT[1x20] : [connection problems] 906 * } 907 * </pre> 908 * 909 * @see #EXCEPTION_LITERAL 910 * @see #THROWS_LITERAL 911 */ 912 public static final int CLASS_NAME = JavadocParser.CLASS_NAME; 913 914 /** 915 * First argument in {@link #PARAM_LITERAL @param} Javadoc tag. 916 * 917 * <p><b>Example:</b></p> 918 * <pre>{@code @param T The bar.}</pre> 919 * <b>Tree:</b> 920 * <pre> 921 * {@code |--JAVADOC_TAG[4x3] : [@param T The bar.] 922 * |--PARAM_LITERAL[4x3] : [@param] 923 * |--WS[4x9] : [ ] 924 * |--PARAMETER_NAME[4x10] : [T] 925 * |--WS[4x11] : [ ] 926 * |--DESCRIPTION[4x12] : [The bar.] 927 * |--TEXT[4x12] : [The bar.] 928 * } 929 * </pre> 930 * 931 * @see 932 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHJECF"> 933 * Oracle Docs</a> 934 * @see #PARAM_LITERAL 935 */ 936 public static final int PARAMETER_NAME = JavadocParser.PARAMETER_NAME; 937 938 /** 939 * 'exclude' literal. 940 * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments. 941 * 942 * <p><b>Example:</b></p> 943 * <pre>{@code @serial exclude}</pre> 944 * <b>Tree:</b> 945 * <pre> 946 * {@code |--JAVADOC_TAG[1x0] : [@serial exclude] 947 * |--SERIAL_LITERAL[1x0] : [@serial] 948 * |--WS[1x7] : [ ] 949 * |--LITERAL_EXCLUDE[1x8] : [exclude] 950 * } 951 * </pre> 952 * 953 * @see 954 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF"> 955 * Oracle Docs</a> 956 * @see #SERIAL_LITERAL 957 */ 958 public static final int LITERAL_EXCLUDE = JavadocParser.LITERAL_EXCLUDE; 959 960 /** 961 * 'include' literal. 962 * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments. 963 * 964 * <p><b>Example:</b></p> 965 * <pre>{@code @serial include}</pre> 966 * <b>Tree:</b> 967 * <pre> 968 * {@code |--JAVADOC_TAG[1x0] : [@serial include] 969 * |--SERIAL_LITERAL[1x0] : [@serial] 970 * |--WS[1x7] : [ ] 971 * |--LITERAL_INCLUDE[1x8] : [include] 972 * } 973 * </pre> 974 * 975 * @see 976 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF"> 977 * Oracle Docs</a> 978 * @see #SERIAL_LITERAL 979 */ 980 public static final int LITERAL_INCLUDE = JavadocParser.LITERAL_INCLUDE; 981 982 /** 983 * Field name. First argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag. 984 * 985 * <p><b>Example:</b></p> 986 * <pre>{@code @serialField counter Integer objects counter}</pre> 987 * <b>Tree:</b> 988 * <pre> 989 * {@code |--JAVADOC_TAG[3x0] : [@serialField counter Integer objects counter] 990 * |--SERIAL_FIELD_LITERAL[3x0] : [@serialField] 991 * |--WS[3x12] : [ ] 992 * |--FIELD_NAME[3x13] : [counter] 993 * |--WS[3x20] : [ ] 994 * |--FIELD_TYPE[3x21] : [Integer] 995 * |--WS[3x28] : [ ] 996 * |--DESCRIPTION[3x29] : [objects counter] 997 * |--TEXT[3x29] : [objects counter] 998 * } 999 * </pre> 1000 * 1001 * @see 1002 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF"> 1003 * Oracle Docs</a> 1004 * @see #SERIAL_FIELD_LITERAL 1005 */ 1006 public static final int FIELD_NAME = JavadocParser.FIELD_NAME; 1007 1008 /** 1009 * Field type. Second argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag. 1010 * 1011 * <p><b>Example:</b></p> 1012 * <pre>{@code @serialField counter Integer objects counter}</pre> 1013 * <b>Tree:</b> 1014 * <pre> 1015 * {@code |--JAVADOC_TAG[3x0] : [@serialField counter Integer objects counter] 1016 * |--SERIAL_FIELD_LITERAL[3x0] : [@serialField] 1017 * |--WS[3x12] : [ ] 1018 * |--FIELD_NAME[3x13] : [counter] 1019 * |--WS[3x20] : [ ] 1020 * |--FIELD_TYPE[3x21] : [Integer] 1021 * |--WS[3x28] : [ ] 1022 * |--DESCRIPTION[3x29] : [objects counter] 1023 * |--TEXT[3x29] : [objects counter] 1024 * } 1025 * </pre> 1026 * 1027 * @see 1028 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF"> 1029 * Oracle Docs</a> 1030 * @see #SERIAL_FIELD_LITERAL 1031 */ 1032 public static final int FIELD_TYPE = JavadocParser.FIELD_TYPE; 1033 1034 // ------------------------------------------------------------------------------------------ // 1035 // ----------------- HTML TAGS ---------------------------------------------- // 1036 // ------------------------------------------------------------------------------------------ // 1037 1038 /** 1039 * Identifier inside HTML tag: tag name or attribute name. 1040 */ 1041 public static final int HTML_TAG_NAME = JavadocParser.HTML_TAG_NAME; 1042 1043 // HTML tag components 1044 1045 /** 1046 * Start html tag component: {@code '<'}. 1047 */ 1048 public static final int START = JavadocParser.START; 1049 1050 /** 1051 * Slash html tag component: {@code '/'}. 1052 */ 1053 public static final int SLASH = JavadocParser.SLASH; 1054 1055 /** 1056 * End html tag component: {@code '>'}. 1057 */ 1058 public static final int END = JavadocParser.END; 1059 1060 /** 1061 * Slash close html tag component: {@code '/>'}. 1062 */ 1063 public static final int SLASH_END = JavadocParser.SLASH_END; 1064 1065 /** 1066 * Equals html tag component: {@code '='}. 1067 */ 1068 public static final int EQUALS = JavadocParser.EQUALS; 1069 1070 /** 1071 * Attribute value html tag component. 1072 */ 1073 public static final int ATTR_VALUE = JavadocParser.ATTR_VALUE; 1074 1075 /////////////////////// HTML TAGS WITH OPTIONAL END TAG ///////////////////////////////////// 1076 /** Paragraph tag name. */ 1077 public static final int P_HTML_TAG_NAME = JavadocParser.P_HTML_TAG_NAME; 1078 1079 /** List item tag name. */ 1080 public static final int LI_HTML_TAG_NAME = JavadocParser.LI_HTML_TAG_NAME; 1081 1082 /** Table row tag name. */ 1083 public static final int TR_HTML_TAG_NAME = JavadocParser.TR_HTML_TAG_NAME; 1084 1085 /** Table cell tag name. */ 1086 public static final int TD_HTML_TAG_NAME = JavadocParser.TD_HTML_TAG_NAME; 1087 1088 /** Table header cell tag name. */ 1089 public static final int TH_HTML_TAG_NAME = JavadocParser.TH_HTML_TAG_NAME; 1090 1091 /** Body tag name. */ 1092 public static final int BODY_HTML_TAG_NAME = JavadocParser.BODY_HTML_TAG_NAME; 1093 1094 /** Colgroup tag name. */ 1095 public static final int COLGROUP_HTML_TAG_NAME = JavadocParser.COLGROUP_HTML_TAG_NAME; 1096 1097 /** Description of a term tag name. */ 1098 public static final int DD_HTML_TAG_NAME = JavadocParser.DD_HTML_TAG_NAME; 1099 1100 /** Description term tag name. */ 1101 public static final int DT_HTML_TAG_NAME = JavadocParser.DT_HTML_TAG_NAME; 1102 1103 /** Head tag name. */ 1104 public static final int HEAD_HTML_TAG_NAME = JavadocParser.HEAD_HTML_TAG_NAME; 1105 1106 /** Html tag name. */ 1107 public static final int HTML_HTML_TAG_NAME = JavadocParser.HTML_HTML_TAG_NAME; 1108 1109 /** Option tag name. */ 1110 public static final int OPTION_HTML_TAG_NAME = JavadocParser.OPTION_HTML_TAG_NAME; 1111 1112 /** Table body tag name. */ 1113 public static final int TBODY_HTML_TAG_NAME = JavadocParser.TBODY_HTML_TAG_NAME; 1114 1115 /** Table foot tag name. */ 1116 public static final int TFOOT_HTML_TAG_NAME = JavadocParser.TFOOT_HTML_TAG_NAME; 1117 1118 /** Table head tag name. */ 1119 public static final int THEAD_HTML_TAG_NAME = JavadocParser.THEAD_HTML_TAG_NAME; 1120 1121 /** `optgroup` tag name. */ 1122 public static final int OPTGROUP_HTML_TAG_NAME = JavadocParser.OPTGROUP_HTML_TAG_NAME; 1123 1124 /** `rb` tag name. */ 1125 public static final int RB_HTML_TAG_NAME = JavadocParser.RB_HTML_TAG_NAME; 1126 1127 /** `rt` tag name. */ 1128 public static final int RT_HTML_TAG_NAME = JavadocParser.RT_HTML_TAG_NAME; 1129 1130 /** `rtc` tag name. */ 1131 public static final int RTC_HTML_TAG_NAME = JavadocParser.RTC_HTML_TAG_NAME; 1132 1133 /** `rp` tag name. */ 1134 public static final int RP_HTML_TAG_NAME = JavadocParser.RP_HTML_TAG_NAME; 1135 /////////////////////////////////////////////////////////////////////////////////////////////// 1136 1137 /////////////////////// SINGLETON HTML TAGS ////////////////////////////////////////////////// 1138 /** Area tag name. */ 1139 public static final int AREA_HTML_TAG_NAME = JavadocParser.AREA_HTML_TAG_NAME; 1140 1141 /** Base tag name. */ 1142 public static final int BASE_HTML_TAG_NAME = JavadocParser.BASE_HTML_TAG_NAME; 1143 1144 /** Basefont tag name. */ 1145 public static final int BASEFONT_HTML_TAG_NAME = JavadocParser.BASEFONT_HTML_TAG_NAME; 1146 1147 /** Br tag name. */ 1148 public static final int BR_HTML_TAG_NAME = JavadocParser.BR_HTML_TAG_NAME; 1149 1150 /** Col tag name. */ 1151 public static final int COL_HTML_TAG_NAME = JavadocParser.COL_HTML_TAG_NAME; 1152 1153 /** Frame tag name. */ 1154 public static final int FRAME_HTML_TAG_NAME = JavadocParser.FRAME_HTML_TAG_NAME; 1155 1156 /** Hr tag name. */ 1157 public static final int HR_HTML_TAG_NAME = JavadocParser.HR_HTML_TAG_NAME; 1158 1159 /** Img tag name. */ 1160 public static final int IMG_HTML_TAG_NAME = JavadocParser.IMG_HTML_TAG_NAME; 1161 1162 /** Input tag name. */ 1163 public static final int INPUT_HTML_TAG_NAME = JavadocParser.INPUT_HTML_TAG_NAME; 1164 1165 /** Isindex tag name. */ 1166 public static final int ISINDEX_HTML_TAG_NAME = JavadocParser.ISINDEX_HTML_TAG_NAME; 1167 1168 /** Link tag name. */ 1169 public static final int LINK_HTML_TAG_NAME = JavadocParser.LINK_HTML_TAG_NAME; 1170 1171 /** Meta tag name. */ 1172 public static final int META_HTML_TAG_NAME = JavadocParser.META_HTML_TAG_NAME; 1173 1174 /** Param tag name. */ 1175 public static final int PARAM_HTML_TAG_NAME = JavadocParser.PARAM_HTML_TAG_NAME; 1176 /** "embed" tag name. */ 1177 public static final int EMBED_HTML_TAG_NAME = JavadocParser.EMBED_HTML_TAG_NAME; 1178 /** "keygen" tag name. */ 1179 public static final int KEYGEN_HTML_TAG_NAME = JavadocParser.KEYGEN_HTML_TAG_NAME; 1180 /** "source" tag name. */ 1181 public static final int SOURCE_HTML_TAG_NAME = JavadocParser.SOURCE_HTML_TAG_NAME; 1182 /** "track" tag name. */ 1183 public static final int TRACK_HTML_TAG_NAME = JavadocParser.TRACK_HTML_TAG_NAME; 1184 /** "wbr" tag name. */ 1185 public static final int WBR_HTML_TAG_NAME = JavadocParser.WBR_HTML_TAG_NAME; 1186 /////////////////////////////////////////////////////////////////////////////////////////////// 1187 1188 /** 1189 * HTML comment start symbol '<!--'. 1190 */ 1191 public static final int HTML_COMMENT_START = JavadocParser.HTML_COMMENT_START; 1192 1193 /** 1194 * HTML comment end symbol '-->'. 1195 */ 1196 public static final int HTML_COMMENT_END = JavadocParser.HTML_COMMENT_END; 1197 1198 // ------------------------------------------------------------------------------------------ // 1199 // ----------------- OTHER -------------------------------------------------- // 1200 // ------------------------------------------------------------------------------------------ // 1201 1202 /** Leading asterisk. */ 1203 public static final int LEADING_ASTERISK = JavadocParser.LEADING_ASTERISK; 1204 1205 /** 1206 * Newline symbol - '\n'. 1207 */ 1208 public static final int NEWLINE = JavadocParser.NEWLINE; 1209 1210 /** 1211 * Any other symbol. 1212 */ 1213 public static final int CHAR = JavadocParser.CHAR; 1214 1215 /** 1216 * Whitespace or tab ('\t') symbol. 1217 */ 1218 public static final int WS = JavadocParser.WS; 1219 1220 /** 1221 * End Of File symbol. Copied from 1222 * {@link org.antlr.v4.runtime.Recognizer#EOF} to avoid ANTLR dependency in 1223 * API. 1224 */ 1225 public static final int EOF = -1; 1226 1227 // ------------------------------------------------------------------------------------------ // 1228 // ------ JAVADOC TAGS DEPENDING ON RULE TYPES OFFSET --------------------------------------- // 1229 // ------------------------------------------------------------------------------------------ // 1230 1231 /** 1232 * Rule types offset. 1233 * RULE_TYPES_OFFSET constant is used to split lexer tokens types and parser rules types. 1234 * We need unique numbers for all tokens, 1235 * ANTLR do not need this and that is why these types are mixed by used values. 1236 * All values we can take a look at 1237 * target/generated-sources/antlr/com/puppycrawl/tools/checkstyle/grammar/javadoc/JavadocParser.java 1238 * For example: LEADING_ASTERISK=1 and RULE_htmlElement = 1. 1239 * RULE_TYPES_OFFSET required to shift parser rules, 1240 * to let them not overlap with types that have prefix "RULE_". 1241 */ 1242 private static final int RULE_TYPES_OFFSET = 10000; 1243 1244 /** 1245 * Root node of any Javadoc comment. 1246 * Last child is always {@link #EOF}. 1247 * 1248 * <p><b>Tree for example:</b></p> 1249 * <pre>{@code 1250 * JAVADOC[3x0] 1251 * |--NEWLINE[3x0] : [\n] 1252 * |--LEADING_ASTERISK[4x0] : [ *] 1253 * |--WS[4x2] : [ ] 1254 * |--JAVADOC_TAG[4x3] : [@param T The bar.\n ] 1255 * |--PARAM_LITERAL[4x3] : [@param] 1256 * |--WS[4x9] : [ ] 1257 * |--PARAMETER_NAME[4x10] : [T] 1258 * |--WS[4x11] : [ ] 1259 * |--DESCRIPTION[4x12] : [The bar.\n ] 1260 * |--TEXT[4x12] : [The bar.] 1261 * |--NEWLINE[4x20] : [\n] 1262 * |--TEXT[5x0] : [ ] 1263 * |--EOF[5x1] : [<EOF>] 1264 * }</pre> 1265 */ 1266 public static final int JAVADOC = JavadocParser.RULE_javadoc + RULE_TYPES_OFFSET; 1267 1268 /** 1269 * Javadoc tag. 1270 * 1271 * <p>Type of Javadoc tag is resolved by literal node that is first child of this node.</p> 1272 * 1273 * <p>As literal could be:</p> 1274 * <ul> 1275 * <li>{@link #RETURN_LITERAL}</li> 1276 * <li>{@link #DEPRECATED_LITERAL}</li> 1277 * <li>{@link #SINCE_LITERAL}</li> 1278 * <li>{@link #SERIAL_DATA_LITERAL}</li> 1279 * <li>{@link #SERIAL_FIELD_LITERAL}</li> 1280 * <li>{@link #PARAM_LITERAL}</li> 1281 * <li>{@link #SEE_LITERAL}</li> 1282 * <li>{@link #SERIAL_LITERAL}</li> 1283 * <li>{@link #VERSION_LITERAL}</li> 1284 * <li>{@link #EXCEPTION_LITERAL}</li> 1285 * <li>{@link #THROWS_LITERAL}</li> 1286 * <li>{@link #AUTHOR_LITERAL}</li> 1287 * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc tag.</li> 1288 * </ul> 1289 * 1290 * <p><b>Example</b></p> 1291 * <pre>{@code @param T The bar.}</pre> 1292 * <b>Tree</b> 1293 * <pre>{@code 1294 * |--JAVADOC_TAG[4x3] : [@param T The bar.] 1295 * |--PARAM_LITERAL[4x3] : [@param] 1296 * |--WS[4x9] : [ ] 1297 * |--PARAMETER_NAME[4x10] : [T] 1298 * |--WS[4x11] : [ ] 1299 * |--DESCRIPTION[4x12] : [The bar.] 1300 * |--TEXT[4x12] : [The bar.] 1301 * }</pre> 1302 */ 1303 1304 public static final int JAVADOC_TAG = JavadocParser.RULE_javadocTag + RULE_TYPES_OFFSET; 1305 /** 1306 * Javadoc inline tag. 1307 * 1308 * <p>Type of Javadoc inline tag is resolved by literal node that is second child of this node. 1309 * First child is always {@link #JAVADOC_INLINE_TAG_START} and last node is always 1310 * {@link #JAVADOC_INLINE_TAG_END}.</p> 1311 * 1312 * <p>As literal could be:</p> 1313 * <ul> 1314 * <li>{@link #CODE_LITERAL}</li> 1315 * <li>{@link #DOC_ROOT_LITERAL}</li> 1316 * <li>{@link #LINK_LITERAL}</li> 1317 * <li>{@link #INHERIT_DOC_LITERAL}</li> 1318 * <li>{@link #LINKPLAIN_LITERAL}</li> 1319 * <li>{@link #LITERAL_LITERAL}</li> 1320 * <li>{@link #VALUE_LITERAL}</li> 1321 * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc inline tag.</li> 1322 * </ul> 1323 * 1324 * <p><b>Example:</b></p> 1325 * <pre><code>{@link String}</code></pre> 1326 * <b>Tree:</b> 1327 * <pre> 1328 * <code> |--JAVADOC_INLINE_TAG[4x3] : [@link String}] 1329 * |--JAVADOC_INLINE_TAG_START[4x3] : [{] 1330 * |--LINK_LITERAL[4x4] : [@link] 1331 * |--WS[4x9] : [ ] 1332 * |--REFERENCE[4x10] : [String] 1333 * |--CLASS[4x10] : [String] 1334 * |--JAVADOC_INLINE_TAG_END[4x16] : [}] 1335 * </code> 1336 * </pre> 1337 * 1338 * @noinspection HtmlTagCanBeJavadocTag 1339 * @noinspection HtmlTagCanBeJavadocTag 1340 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 1341 * replaced with Javadoc tag 1342 */ 1343 public static final int JAVADOC_INLINE_TAG = JavadocParser.RULE_javadocInlineTag 1344 + RULE_TYPES_OFFSET; 1345 1346 /** 1347 * Parameter of the Javadoc tags listed below. 1348 * <ul> 1349 * <li>{@link #SEE_LITERAL @see}</li> 1350 * <li>{@link #LINK_LITERAL {@link}}</li> 1351 * <li>{@link #LINKPLAIN_LITERAL {@linkplain}}</li> 1352 * <li>{@link #VALUE_LITERAL {@value}}</li> 1353 * </ul> 1354 */ 1355 public static final int REFERENCE = JavadocParser.RULE_reference + RULE_TYPES_OFFSET; 1356 1357 /** 1358 * Parameters part in {@link #REFERENCE}. 1359 * It is used to specify parameters for {@link #MEMBER method}. 1360 * Always contains {@link #LEFT_BRACE} as first child and {@link #RIGHT_BRACE} as last child. 1361 * Each parameter is represented by {@link #ARGUMENT} node. 1362 * Arguments in braces are separated by {@link #COMMA} (and optional {@link #WS}). 1363 * 1364 * <p><b>Example:</b></p> 1365 * <pre>{@code @see #method(Processor, String)}</pre> 1366 * <b>Tree:</b> 1367 * <pre> 1368 * {@code |--JAVADOC_TAG[1x0] : [@see #method(Processor, String)] 1369 * |--SEE_LITERAL[1x0] : [@see] 1370 * |--WS[1x4] : [ ] 1371 * |--REFERENCE[1x5] : [#method(Processor, String)] 1372 * |--HASH[1x5] : [#] 1373 * |--MEMBER[1x6] : [method] 1374 * |--PARAMETERS[1x12] : [(Processor, String)] 1375 * |--LEFT_BRACE[1x12] : [(] 1376 * |--ARGUMENT[1x13] : [Processor] 1377 * |--COMMA[1x22] : [,] 1378 * |--WS[1x23] : [ ] 1379 * |--ARGUMENT[1x24] : [String] 1380 * |--RIGHT_BRACE[1x30] : [)] 1381 * } 1382 * </pre> 1383 */ 1384 public static final int PARAMETERS = JavadocParser.RULE_parameters + RULE_TYPES_OFFSET; 1385 1386 /** 1387 * Description node. It contains: 1388 * <ul> 1389 * <li>{@link #TEXT}</li> 1390 * <li>{@link #WS}</li> 1391 * <li>{@link #NEWLINE}</li> 1392 * <li>{@link #HTML_ELEMENT}</li> 1393 * </ul> 1394 * 1395 * <p>It is argument for many Javadoc tags and inline tags.</p> 1396 * 1397 * <p><b>Example:</b></p> 1398 * <pre>{@code @throws IOException if <b>connection</b> problems occur}</pre> 1399 * <b>Tree:</b> 1400 * <pre> 1401 * {@code |--JAVADOC_TAG[1x0] : [@throws IOException if <b>connection</b> problems occur] 1402 * |--THROWS_LITERAL[1x0] : [@throws] 1403 * |--WS[1x7] : [ ] 1404 * |--CLASS_NAME[1x8] : [IOException] 1405 * |--WS[1x19] : [ ] 1406 * |--DESCRIPTION[1x20] : [if <b>connection</b> problems occur] 1407 * |--TEXT[1x20] : [if ] 1408 * |--HTML_ELEMENT[1x23] : [<b>connection</b>] 1409 * |--HTML_TAG[1x23] : [<b>connection</b>] 1410 * |--HTML_ELEMENT_START[1x23] : [<b>] 1411 * |--START[1x23] : [<] 1412 * |--HTML_TAG_NAME[1x24] : [b] 1413 * |--END[1x25] : [>] 1414 * |--TEXT[1x26] : [connection] 1415 * |--HTML_ELEMENT_END[1x36] : [</b>] 1416 * |--START[1x36] : [<] 1417 * |--SLASH[1x37] : [/] 1418 * |--HTML_TAG_NAME[1x38] : [b] 1419 * |--END[1x39] : [>] 1420 * |--TEXT[1x40] : [ problems occur] 1421 * } 1422 * </pre> 1423 */ 1424 public static final int DESCRIPTION = JavadocParser.RULE_description + RULE_TYPES_OFFSET; 1425 1426 // ------------------------------------------------------------------------------------------ // 1427 // -------- HTML TAGS DEPENDING ON RULE TYPES OFFSET ---------------------------------------- // 1428 // ------------------------------------------------------------------------------------------ // 1429 1430 /** 1431 * Parent node for all html tags. 1432 */ 1433 public static final int HTML_ELEMENT = JavadocParser.RULE_htmlElement 1434 + RULE_TYPES_OFFSET; 1435 1436 /** 1437 * Start html tag: <XXXX>. 1438 */ 1439 public static final int HTML_ELEMENT_START = JavadocParser.RULE_htmlElementStart 1440 + RULE_TYPES_OFFSET; 1441 1442 /** 1443 * End html tag: <XXXX>. 1444 */ 1445 public static final int HTML_ELEMENT_END = JavadocParser.RULE_htmlElementEnd 1446 + RULE_TYPES_OFFSET; 1447 1448 /** 1449 * Non-special HTML tag. 1450 */ 1451 public static final int HTML_TAG = JavadocParser.RULE_htmlTag + RULE_TYPES_OFFSET; 1452 1453 /** 1454 * Html tag attribute. Parent node for: {@code HTML_TAG_IDENT, EQUALS, ATTR_VALUE}. 1455 */ 1456 public static final int ATTRIBUTE = JavadocParser.RULE_attribute 1457 + RULE_TYPES_OFFSET; 1458 1459 /////////////////////// HTML TAGS WITH OPTIONAL END TAG ///////////////////////////////////// 1460 /** Paragraph html tag: {@code <p></p>}. */ 1461 public static final int PARAGRAPH = JavadocParser.RULE_paragraph + RULE_TYPES_OFFSET; 1462 /** Start paragraph tag. */ 1463 public static final int P_TAG_START = JavadocParser.RULE_pTagStart + RULE_TYPES_OFFSET; 1464 /** End paragraph tag. */ 1465 public static final int P_TAG_END = JavadocParser.RULE_pTagEnd + RULE_TYPES_OFFSET; 1466 /** List item html tag: {@code <li></li>}. */ 1467 1468 public static final int LI = JavadocParser.RULE_li + RULE_TYPES_OFFSET; 1469 /** Start list item tag. */ 1470 public static final int LI_TAG_START = JavadocParser.RULE_liTagStart + RULE_TYPES_OFFSET; 1471 /** End list item tag. */ 1472 public static final int LI_TAG_END = JavadocParser.RULE_liTagEnd + RULE_TYPES_OFFSET; 1473 1474 /** Table row html tag: {@code <tr></tr>}. */ 1475 public static final int TR = JavadocParser.RULE_tr + RULE_TYPES_OFFSET; 1476 /** Start table row tag. */ 1477 public static final int TR_TAG_START = JavadocParser.RULE_trTagStart + RULE_TYPES_OFFSET; 1478 /** End table row tag. */ 1479 public static final int TR_TAG_END = JavadocParser.RULE_trTagEnd + RULE_TYPES_OFFSET; 1480 1481 /** Table cell html tag: {@code <td></td>}. */ 1482 public static final int TD = JavadocParser.RULE_td + RULE_TYPES_OFFSET; 1483 /** Start table cell tag. */ 1484 public static final int TD_TAG_START = JavadocParser.RULE_tdTagStart + RULE_TYPES_OFFSET; 1485 /** End table cell tag. */ 1486 public static final int TD_TAG_END = JavadocParser.RULE_tdTagEnd + RULE_TYPES_OFFSET; 1487 1488 /** Table header cell html tag: {@code <th></th>}. */ 1489 public static final int TH = JavadocParser.RULE_th + RULE_TYPES_OFFSET; 1490 /** Start table header cell tag. */ 1491 public static final int TH_TAG_START = JavadocParser.RULE_thTagStart + RULE_TYPES_OFFSET; 1492 /** End table header cell tag. */ 1493 public static final int TH_TAG_END = JavadocParser.RULE_thTagEnd + RULE_TYPES_OFFSET; 1494 1495 /** Body html tag. */ 1496 public static final int BODY = JavadocParser.RULE_body + RULE_TYPES_OFFSET; 1497 /** Start body tag. */ 1498 public static final int BODY_TAG_START = JavadocParser.RULE_bodyTagStart + RULE_TYPES_OFFSET; 1499 /** End body tag. */ 1500 public static final int BODY_TAG_END = JavadocParser.RULE_bodyTagEnd + RULE_TYPES_OFFSET; 1501 1502 /** Colgroup html tag. */ 1503 public static final int COLGROUP = JavadocParser.RULE_colgroup + RULE_TYPES_OFFSET; 1504 /** Start colgroup tag. */ 1505 public static final int COLGROUP_TAG_START = JavadocParser.RULE_colgroupTagStart 1506 + RULE_TYPES_OFFSET; 1507 /** End colgroup tag. */ 1508 public static final int COLGROUP_TAG_END = JavadocParser.RULE_colgroupTagEnd 1509 + RULE_TYPES_OFFSET; 1510 1511 /** Description of a term html tag: {@code <dd></dd>}. */ 1512 public static final int DD = JavadocParser.RULE_dd + RULE_TYPES_OFFSET; 1513 /** Start description of a term tag. */ 1514 public static final int DD_TAG_START = JavadocParser.RULE_ddTagStart + RULE_TYPES_OFFSET; 1515 /** End description of a term tag. */ 1516 public static final int DD_TAG_END = JavadocParser.RULE_ddTagEnd + RULE_TYPES_OFFSET; 1517 1518 /** Description term html tag: {@code <dt></dt>}. */ 1519 public static final int DT = JavadocParser.RULE_dt + RULE_TYPES_OFFSET; 1520 /** Start description term tag. */ 1521 public static final int DT_TAG_START = JavadocParser.RULE_dtTagStart + RULE_TYPES_OFFSET; 1522 /** End description term tag. */ 1523 public static final int DT_TAG_END = JavadocParser.RULE_dtTagEnd + RULE_TYPES_OFFSET; 1524 1525 /** Head html tag. */ 1526 public static final int HEAD = JavadocParser.RULE_head + RULE_TYPES_OFFSET; 1527 /** Start head tag. */ 1528 public static final int HEAD_TAG_START = JavadocParser.RULE_headTagStart + RULE_TYPES_OFFSET; 1529 /** End head tag. */ 1530 public static final int HEAD_TAG_END = JavadocParser.RULE_headTagEnd + RULE_TYPES_OFFSET; 1531 1532 /** Html html tag. */ 1533 public static final int HTML = JavadocParser.RULE_html + RULE_TYPES_OFFSET; 1534 /** Start html tag. */ 1535 public static final int HTML_TAG_START = JavadocParser.RULE_htmlTagStart + RULE_TYPES_OFFSET; 1536 /** End html tag. */ 1537 public static final int HTML_TAG_END = JavadocParser.RULE_htmlTagEnd + RULE_TYPES_OFFSET; 1538 1539 /** Option html tag. */ 1540 public static final int OPTION = JavadocParser.RULE_option + RULE_TYPES_OFFSET; 1541 /** Start option tag. */ 1542 public static final int OPTION_TAG_START = 1543 JavadocParser.RULE_optionTagStart + RULE_TYPES_OFFSET; 1544 /** End option tag. */ 1545 public static final int OPTION_TAG_END = JavadocParser.RULE_optionTagEnd 1546 + RULE_TYPES_OFFSET; 1547 1548 /** Table body html tag. */ 1549 public static final int TBODY = JavadocParser.RULE_tbody + RULE_TYPES_OFFSET; 1550 /** Start table body tag. */ 1551 public static final int TBODY_TAG_START = JavadocParser.RULE_tbodyTagStart + RULE_TYPES_OFFSET; 1552 /** End table body tag. */ 1553 public static final int TBODY_TAG_END = JavadocParser.RULE_tbodyTagEnd + RULE_TYPES_OFFSET; 1554 1555 /** Table foot html tag. */ 1556 public static final int TFOOT = JavadocParser.RULE_tfoot + RULE_TYPES_OFFSET; 1557 /** Start table foot tag. */ 1558 public static final int TFOOT_TAG_START = JavadocParser.RULE_tfootTagStart + RULE_TYPES_OFFSET; 1559 /** End table foot tag. */ 1560 public static final int TFOOT_TAG_END = JavadocParser.RULE_tfootTagEnd + RULE_TYPES_OFFSET; 1561 1562 /** Table head html tag. */ 1563 public static final int THEAD = JavadocParser.RULE_thead + RULE_TYPES_OFFSET; 1564 /** Start table head tag. */ 1565 public static final int THEAD_TAG_START = JavadocParser.RULE_theadTagStart + RULE_TYPES_OFFSET; 1566 /** End table head tag. */ 1567 public static final int THEAD_TAG_END = JavadocParser.RULE_theadTagEnd + RULE_TYPES_OFFSET; 1568 1569 /** `optgroup` html tag. */ 1570 public static final int OPTGROUP = JavadocParser.RULE_optgroup + RULE_TYPES_OFFSET; 1571 /** `optgroup` tag start. */ 1572 public static final int OPTGROUP_TAG_START = 1573 JavadocParser.RULE_optgroupTagStart + RULE_TYPES_OFFSET; 1574 /** `optgroup` tag end. */ 1575 public static final int OPTGROUP_TAG_END = 1576 JavadocParser.RULE_optgroupTagEnd + RULE_TYPES_OFFSET; 1577 1578 /** `rb` html tag. */ 1579 public static final int RB = JavadocParser.RULE_rb + RULE_TYPES_OFFSET; 1580 /** `rb` tag start. */ 1581 public static final int RB_TAG_START = 1582 JavadocParser.RULE_rbTagStart + RULE_TYPES_OFFSET; 1583 /** `rb` tag end. */ 1584 public static final int RB_TAG_END = 1585 JavadocParser.RULE_rbTagEnd + RULE_TYPES_OFFSET; 1586 1587 /** `rt` html tag. */ 1588 public static final int RT = JavadocParser.RULE_rt + RULE_TYPES_OFFSET; 1589 /** `rt` tag start. */ 1590 public static final int RT_TAG_START = 1591 JavadocParser.RULE_rtTagStart + RULE_TYPES_OFFSET; 1592 /** `rt` tag end. */ 1593 public static final int RT_TAG_END = 1594 JavadocParser.RULE_rtTagEnd + RULE_TYPES_OFFSET; 1595 1596 /** `rtc` html tag. */ 1597 public static final int RTC = JavadocParser.RULE_rtc + RULE_TYPES_OFFSET; 1598 /** `rtc` tag start. */ 1599 public static final int RTC_TAG_START = 1600 JavadocParser.RULE_rtcTagStart + RULE_TYPES_OFFSET; 1601 /** `rtc` tag end. */ 1602 public static final int RTC_TAG_END = 1603 JavadocParser.RULE_rtcTagEnd + RULE_TYPES_OFFSET; 1604 1605 /** `rp` html tag. */ 1606 public static final int RP = JavadocParser.RULE_rp + RULE_TYPES_OFFSET; 1607 /** `rp` tag start. */ 1608 public static final int RP_TAG_START = 1609 JavadocParser.RULE_rpTagStart + RULE_TYPES_OFFSET; 1610 /** `rp` tag end. */ 1611 public static final int RP_TAG_END = 1612 JavadocParser.RULE_rpTagEnd + RULE_TYPES_OFFSET; 1613 1614 /////////////////////// SINGLETON HTML TAGS ////////////////////////////////////////////////// 1615 /** 1616 * Parent node for all singleton html tags. 1617 */ 1618 public static final int SINGLETON_ELEMENT = JavadocParser.RULE_singletonElement 1619 + RULE_TYPES_OFFSET; 1620 1621 /** 1622 * Non-special empty html tag. 1623 */ 1624 public static final int EMPTY_TAG = JavadocParser.RULE_emptyTag 1625 + RULE_TYPES_OFFSET; 1626 1627 /** Area html tag. */ 1628 public static final int AREA_TAG = JavadocParser.RULE_areaTag + RULE_TYPES_OFFSET; 1629 1630 /** Base html tag. */ 1631 public static final int BASE_TAG = JavadocParser.RULE_baseTag + RULE_TYPES_OFFSET; 1632 1633 /** Basefont html tag. */ 1634 public static final int BASEFONT_TAG = JavadocParser.RULE_basefontTag + RULE_TYPES_OFFSET; 1635 1636 /** Br html tag. */ 1637 public static final int BR_TAG = JavadocParser.RULE_brTag + RULE_TYPES_OFFSET; 1638 1639 /** Col html tag. */ 1640 public static final int COL_TAG = JavadocParser.RULE_colTag + RULE_TYPES_OFFSET; 1641 1642 /** Frame html tag. */ 1643 public static final int FRAME_TAG = JavadocParser.RULE_frameTag + RULE_TYPES_OFFSET; 1644 1645 /** Hr html tag. */ 1646 public static final int HR_TAG = JavadocParser.RULE_hrTag + RULE_TYPES_OFFSET; 1647 1648 /** Img html tag. */ 1649 public static final int IMG_TAG = JavadocParser.RULE_imgTag + RULE_TYPES_OFFSET; 1650 1651 /** Input html tag. */ 1652 public static final int INPUT_TAG = JavadocParser.RULE_inputTag + RULE_TYPES_OFFSET; 1653 1654 /** Isindex html tag. */ 1655 public static final int ISINDEX_TAG = JavadocParser.RULE_isindexTag + RULE_TYPES_OFFSET; 1656 1657 /** Link html tag. */ 1658 public static final int LINK_TAG = JavadocParser.RULE_linkTag + RULE_TYPES_OFFSET; 1659 1660 /** Meta html tag. */ 1661 public static final int META_TAG = JavadocParser.RULE_metaTag + RULE_TYPES_OFFSET; 1662 1663 /** Param html tag. */ 1664 public static final int PARAM_TAG = JavadocParser.RULE_paramTag + RULE_TYPES_OFFSET; 1665 1666 /** 1667 * HTML void element {@code <embed>}. 1668 * 1669 * @see #SINGLETON_ELEMENT 1670 * @see <a href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-embed"> 1671 * W3 docs</a> 1672 */ 1673 public static final int EMBED_TAG = JavadocParser.RULE_embedTag + RULE_TYPES_OFFSET; 1674 1675 /** 1676 * HTML void element {@code <keygen>}. 1677 * 1678 * @see #SINGLETON_ELEMENT 1679 * @see <a href="https://www.w3.org/TR/html51/sec-forms.html#elementdef-keygen"> 1680 * W3 docs</a> 1681 */ 1682 public static final int KEYGEN_TAG = JavadocParser.RULE_keygenTag + RULE_TYPES_OFFSET; 1683 1684 /** 1685 * HTML void element {@code <source>}. 1686 * 1687 * @see #SINGLETON_ELEMENT 1688 * @see <a href= 1689 * "https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-media-source"> 1690 * W3 docs</a> 1691 */ 1692 public static final int SOURCE_TAG = JavadocParser.RULE_sourceTag + RULE_TYPES_OFFSET; 1693 1694 /** 1695 * HTML void element {@code <track>}. 1696 * 1697 * @see #SINGLETON_ELEMENT 1698 * @see <a 1699 * href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-track"> 1700 * W3 docs</a> 1701 */ 1702 public static final int TRACK_TAG = JavadocParser.RULE_trackTag + RULE_TYPES_OFFSET; 1703 1704 /** 1705 * HTML void element {@code <wbr>}. 1706 * 1707 * @see #SINGLETON_ELEMENT 1708 * @see <a href="https://www.w3.org/TR/html51/textlevel-semantics.html#elementdef-wbr"> 1709 * W3 docs</a> 1710 */ 1711 public static final int WBR_TAG = JavadocParser.RULE_wbrTag + RULE_TYPES_OFFSET; 1712 1713 /////////////////////////////////////////////////////////////////////////////////////////////// 1714 1715 /** 1716 * Html comment: <code><!-- --></code>. 1717 * 1718 * @noinspection HtmlTagCanBeJavadocTag 1719 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 1720 * replaced with Javadoc tag 1721 */ 1722 public static final int HTML_COMMENT = JavadocParser.RULE_htmlComment 1723 + RULE_TYPES_OFFSET; 1724 /** 1725 * CHAR and WS sequence. 1726 */ 1727 public static final int TEXT = JavadocParser.RULE_text + RULE_TYPES_OFFSET; 1728 1729 /** Empty private constructor of the current class. */ 1730 private JavadocTokenTypes() { 1731 } 1732 1733}