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 * |--NEWLINE -> \r\n 319 * `--TEXT -> 320 * }</pre> 321 * 322 * @see 323 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCHAHD"> 324 * Oracle Docs</a> 325 * @see #JAVADOC_TAG 326 */ 327 public static final int THROWS_LITERAL = JavadocParser.THROWS_LITERAL; 328 329 /** 330 * '@author' literal in {@code @author} Javadoc tag. 331 * 332 * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p> 333 * 334 * <p><b>Example:</b></p> 335 * <pre>{@code @author Baratali Izmailov}</pre> 336 * <b>Tree:</b> 337 * <pre>{@code 338 * JAVADOC_TAG -> JAVADOC_TAG 339 * |--AUTHOR_LITERAL -> @author 340 * |--WS -> 341 * `--DESCRIPTION -> DESCRIPTION 342 * |--TEXT -> Baratali Izmailov 343 * |--NEWLINE -> \r\n 344 * }</pre> 345 * 346 * @see 347 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCBAHA"> 348 * Oracle Docs</a> 349 * @see #JAVADOC_TAG 350 */ 351 public static final int AUTHOR_LITERAL = JavadocParser.AUTHOR_LITERAL; 352 353 /** 354 * Name of custom Javadoc tag (or Javadoc inline tag). 355 * 356 * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p> 357 * 358 * <p><b>Example:</b></p> 359 * <pre>{@code @myJavadocTag some magic}</pre> 360 * <b>Tree:</b> 361 * <pre>{@code 362 * JAVADOC_TAG --> JAVADOC_TAG 363 * |--CUSTOM_NAME --> @myJavadocTag 364 * |--WS --> 365 * `--DESCRIPTION --> DESCRIPTION 366 * |--TEXT --> some magic 367 * }</pre> 368 */ 369 public static final int CUSTOM_NAME = JavadocParser.CUSTOM_NAME; 370 371 /** 372 * First child of {@link #JAVADOC_INLINE_TAG} that represents left curly brace '{'. 373 * 374 * <p><b>Example:</b></p> 375 * <pre><code>{@code Comparable<E>}</code></pre> 376 * <b>Tree:</b> 377 * <pre> 378 * <code> JAVADOC_INLINE_TAG --> JAVADOC_INLINE_TAG 379 * |--JAVADOC_INLINE_TAG_START --> { 380 * |--CODE_LITERAL --> @code 381 * |--WS --> 382 * |--TEXT --> Comparable<E> 383 * `--JAVADOC_INLINE_TAG_END --> } 384 * </code> 385 * </pre> 386 * 387 * @noinspection HtmlTagCanBeJavadocTag 388 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 389 * replaced with Javadoc tag 390 */ 391 public static final int JAVADOC_INLINE_TAG_START = JavadocParser.JAVADOC_INLINE_TAG_START; 392 393 /** 394 * Last child of {@link #JAVADOC_INLINE_TAG} that represents right curly brace '}'. 395 * 396 * <p><b>Example:</b></p> 397 * <pre><code>{@code Comparable<E>}</code></pre> 398 * <b>Tree:</b> 399 * <pre> 400 * <code>JAVADOC_INLINE_TAG --> JAVADOC_INLINE_TAG 401 * |--JAVADOC_INLINE_TAG_START --> { 402 * |--CODE_LITERAL --> @code 403 * |--WS --> 404 * |--TEXT --> Comparable<E> 405 * `--JAVADOC_INLINE_TAG_END --> } 406 * 407 * </code> 408 * </pre> 409 * 410 * @noinspection HtmlTagCanBeJavadocTag 411 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 412 * replaced with Javadoc tag 413 */ 414 public static final int JAVADOC_INLINE_TAG_END = JavadocParser.JAVADOC_INLINE_TAG_END; 415 416 /** 417 * '@code' literal in {@code} Javadoc inline tag. 418 * 419 * <p>Such Javadoc inline tag can have such child nodes:</p> 420 * <ul> 421 * <li>{@link #NEWLINE}</li> 422 * <li>{@link #WS}</li> 423 * <li>{@link #TEXT}</li> 424 * </ul> 425 * 426 * <p><b>Example:</b></p> 427 * <pre><code>{@code Comparable<E>}</code></pre> 428 * <b>Tree:</b> 429 * <pre> 430 * <code>JAVADOC_TAG -> JAVADOC_TAG 431 * |--CUSTOM_NAME -> @code 432 * |--WS -> 433 * `--DESCRIPTION -> DESCRIPTION 434 * |--TEXT -> Comparable<E> 435 * </code> 436 * </pre> 437 * 438 * @see 439 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDFHHBB"> 440 * Oracle Docs</a> 441 * @see #JAVADOC_INLINE_TAG 442 * @noinspection HtmlTagCanBeJavadocTag 443 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 444 * replaced with Javadoc tag 445 */ 446 public static final int CODE_LITERAL = JavadocParser.CODE_LITERAL; 447 448 /** 449 * '@docRoot' literal in {@docRoot} Javadoc inline tag. 450 * 451 * <p>Such Javadoc inline tag does not have any arguments and can have such child nodes:</p> 452 * <ul> 453 * <li>{@link #NEWLINE}</li> 454 * <li>{@link #WS}</li> 455 * </ul> 456 * 457 * <p><b>Example:</b></p> 458 * <pre><code>{@docRoot}</code></pre> 459 * <b>Tree:</b> 460 * <pre> 461 * <code> 462 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 463 * |--JAVADOC_INLINE_TAG_START -> { 464 * |--DOC_ROOT_LITERAL -> @docRoot 465 * `--JAVADOC_INLINE_TAG_END -> } 466 * </code> 467 * </pre> 468 * 469 * <pre><code>Example :{@docRoot 470 * } in a Javadoc comment. 471 * </code></pre> 472 * <b>Tree:</b> 473 * <pre> 474 * <code> 475 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 476 * |--JAVADOC_INLINE_TAG_START -> { 477 * |--DOC_ROOT_LITERAL -> @docRoot 478 * |--NEWLINE -> \r\n 479 * |--LEADING_ASTERISK -> * 480 * |--WS -> 481 * `--JAVADOC_INLINE_TAG_END -> } 482 * </code> 483 * </pre> 484 * 485 * @see 486 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDBACBF"> 487 * Oracle Docs</a> 488 * @see #JAVADOC_INLINE_TAG 489 * @noinspection HtmlTagCanBeJavadocTag 490 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 491 * replaced with Javadoc tag 492 */ 493 public static final int DOC_ROOT_LITERAL = JavadocParser.DOC_ROOT_LITERAL; 494 495 /** 496 * '@link' literal in {@link} Javadoc inline tag. 497 * 498 * <p>Such Javadoc inline tag can have one argument - {@link #REFERENCE}</p> 499 * 500 * <p><b>Example:</b></p> 501 * 502 * <pre><code>{@link org.apache.utils.Lists.Comparator#compare(Object)}</code></pre> 503 * 504 * <p><b>Tree:</b></p> 505 * 506 * <pre> 507 * <code> 508 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 509 * |--JAVADOC_INLINE_TAG_START -> { 510 * |--LINK_LITERAL -> @link 511 * |--WS -> 512 * |--REFERENCE -> REFERENCE 513 * | |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator 514 * | |--HASH -> # 515 * | |--MEMBER -> compare 516 * | `--PARAMETERS -> PARAMETERS 517 * | |--LEFT_BRACE -> ( 518 * | |--ARGUMENT -> Object 519 * | `--RIGHT_BRACE -> ) 520 * `--JAVADOC_INLINE_TAG_END -> } 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 693 * JAVADOC_TAG -> JAVADOC_TAG 694 * |--SEE_LITERAL -> @see 695 * |--WS -> 696 * |--REFERENCE -> REFERENCE 697 * | |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator 698 * | |--HASH -> # 699 * | |--MEMBER -> compare 700 * | `--PARAMETERS -> PARAMETERS 701 * | |--LEFT_BRACE -> ( 702 * | |--ARGUMENT -> Object 703 * | `--RIGHT_BRACE -> ) 704 * |--NEWLINE -> \r\n 705 * `--WS -> 706 * } 707 * </pre> 708 */ 709 public static final int PACKAGE_CLASS = JavadocParser.PACKAGE_CLASS; 710 711 /** 712 * Hash character in {@link #REFERENCE}. 713 * Hash character is used before specifying a class member. 714 * 715 * <p><b>Example:</b></p> 716 * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre> 717 * <b>Tree:</b> 718 * <pre> 719 * {@code 720 * JAVADOC_TAG -> JAVADOC_TAG 721 * |--SEE_LITERAL -> @see 722 * |--WS -> 723 * |--REFERENCE -> REFERENCE 724 * |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator 725 * |--HASH -> # 726 * |--MEMBER -> compare 727 * `--PARAMETERS -> PARAMETERS 728 * |--LEFT_BRACE -> ( 729 * |--ARGUMENT -> Object 730 * `--RIGHT_BRACE -> ) 731 * } 732 * </pre> 733 */ 734 public static final int HASH = JavadocParser.HASH; 735 736 /** 737 * A class member in {@link #REFERENCE}. 738 * Class member is specified after {@link #HASH} symbol. 739 * 740 * <p><b>Example:</b></p> 741 * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre> 742 * <b>Tree:</b> 743 * <pre> 744 * {@code 745 * JAVADOC_TAG -> JAVADOC_TAG 746 * |--SEE_LITERAL -> @see 747 * |--WS -> 748 * |--REFERENCE -> REFERENCE 749 * |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator 750 * |--HASH -> # 751 * |--MEMBER -> compare 752 * `--PARAMETERS -> PARAMETERS 753 * |--LEFT_BRACE -> ( 754 * |--ARGUMENT -> Object 755 * `--RIGHT_BRACE -> ) 756 * } 757 * </pre> 758 */ 759 public static final int MEMBER = JavadocParser.MEMBER; 760 761 /** 762 * Left brace in {@link #PARAMETERS} part of {@link #REFERENCE}. 763 * 764 * <p><b>Example:</b></p> 765 * <pre>{@code @see #method(Processor, String)}</pre> 766 * <b>Tree:</b> 767 * <pre> 768 * {@code JAVADOC_TAG -> JAVADOC_TAG 769 * |--SEE_LITERAL -> @see 770 * |--WS -> 771 * |--REFERENCE -> REFERENCE 772 * | |--HASH -> # 773 * | |--MEMBER -> method 774 * | `--PARAMETERS -> PARAMETERS 775 * | |--LEFT_BRACE -> ( 776 * | |--ARGUMENT -> Processor 777 * | |--COMMA -> , 778 * | |--WS -> 779 * | |--ARGUMENT -> String 780 * | `--RIGHT_BRACE -> ) 781 * } 782 * </pre> 783 */ 784 public static final int LEFT_BRACE = JavadocParser.LEFT_BRACE; 785 786 /** 787 * Right brace in {@link #PARAMETERS} part of {@link #REFERENCE}. 788 * 789 * <p><b>Example:</b></p> 790 * <pre>{@code @see #method(Processor, String)}</pre> 791 * <b>Tree:</b> 792 * <pre> 793 * {@code JAVADOC_TAG -> JAVADOC_TAG 794 * |--SEE_LITERAL -> @see 795 * |--WS -> 796 * |--REFERENCE -> REFERENCE 797 * | |--HASH -> # 798 * | |--MEMBER -> method 799 * | `--PARAMETERS -> PARAMETERS 800 * | |--LEFT_BRACE -> ( 801 * | |--ARGUMENT -> Processor 802 * | |--COMMA -> , 803 * | |--WS -> 804 * | |--ARGUMENT -> String 805 * | `--RIGHT_BRACE -> ) 806 * } 807 * </pre> 808 */ 809 public static final int RIGHT_BRACE = JavadocParser.RIGHT_BRACE; 810 811 /** 812 * Argument definition in {@link #PARAMETERS} part of {@link #REFERENCE}. 813 * 814 * <p><b>Example:</b></p> 815 * <pre>{@code @see #method(Processor, String)}</pre> 816 * <b>Tree:</b> 817 * <pre> 818 * {@code JAVADOC_TAG -> JAVADOC_TAG 819 * |--SEE_LITERAL -> @see 820 * |--WS -> 821 * |--REFERENCE -> REFERENCE 822 * | |--HASH -> # 823 * | |--MEMBER -> method 824 * | `--PARAMETERS -> PARAMETERS 825 * | |--LEFT_BRACE -> ( 826 * | |--ARGUMENT -> Processor 827 * | |--COMMA -> , 828 * | |--WS -> 829 * | |--ARGUMENT -> String 830 * | `--RIGHT_BRACE -> ) 831 * `--NEWLINE -> \n 832 * } 833 * </pre> 834 */ 835 public static final int ARGUMENT = JavadocParser.ARGUMENT; 836 837 /** 838 * Comma separator between parameters in {@link #PARAMETERS} part of {@link #REFERENCE}. 839 * 840 * <p><b>Example:</b></p> 841 * <pre>{@code @see #method(Processor, String)}</pre> 842 * <b>Tree:</b> 843 * <pre> 844 * {@code 845 * JAVADOC_TAG -> JAVADOC_TAG 846 * |--SEE_LITERAL -> @see 847 * |--WS -> 848 * |--REFERENCE -> REFERENCE 849 * | |--HASH -> # 850 * | |--MEMBER -> method 851 * | `--PARAMETERS -> PARAMETERS 852 * | |--LEFT_BRACE -> ( 853 * | |--ARGUMENT -> Processor 854 * | |--COMMA -> , 855 * | |--WS -> 856 * | |--ARGUMENT -> String 857 * | `--RIGHT_BRACE -> ) 858 * |--NEWLINE -> \r\n 859 * `--WS -> 860 * } 861 * </pre> 862 * 863 * @see #PARAMETERS 864 * @see #REFERENCE 865 * @see #ARGUMENT 866 */ 867 public static final int COMMA = JavadocParser.COMMA; 868 869 /** 870 * Quoted text. 871 * One of possible {@code @see} tag arguments. 872 * 873 * <p><b>Example:</b></p> 874 * <pre>{@code @see "Spring Framework"}</pre> 875 * <b>Tree:</b> 876 * <pre> 877 * {@code 878 * JAVADOC_TAG -> JAVADOC_TAG 879 * |--SEE_LITERAL -> @see 880 * |--WS -> 881 * |--STRING -> "Spring Framework" 882 * |--NEWLINE -> \r\n 883 * `--WS -> 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 900 * JAVADOC_TAG -> JAVADOC_TAG 901 * |--THROWS_LITERAL -> @throws 902 * |--WS -> 903 * |--CLASS_NAME -> IOException 904 * |--WS -> 905 * `--DESCRIPTION -> DESCRIPTION 906 * |--TEXT -> connection problems 907 * |--NEWLINE -> \r\n 908 * `--TEXT -> 909 * } 910 * </pre> 911 * 912 * @see #EXCEPTION_LITERAL 913 * @see #THROWS_LITERAL 914 */ 915 public static final int CLASS_NAME = JavadocParser.CLASS_NAME; 916 917 /** 918 * First argument in {@link #PARAM_LITERAL @param} Javadoc tag. 919 * 920 * <p><b>Example:</b></p> 921 * <pre>{@code @param T The bar.}</pre> 922 * <b>Tree:</b> 923 * <pre> 924 * {@code 925 * --JAVADOC_TAG -> JAVADOC_TAG 926 * |--PARAM_LITERAL -> @param 927 * |--WS -> 928 * |--PARAMETER_NAME -> T 929 * |--WS -> 930 * `--DESCRIPTION -> DESCRIPTION 931 * |--TEXT -> The bar. 932 * |--NEWLINE -> \r\n 933 * `--TEXT -> 934 * } 935 * </pre> 936 * 937 * @see 938 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHJECF"> 939 * Oracle Docs</a> 940 * @see #PARAM_LITERAL 941 */ 942 public static final int PARAMETER_NAME = JavadocParser.PARAMETER_NAME; 943 944 /** 945 * 'exclude' literal. 946 * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments. 947 * 948 * <p><b>Example:</b></p> 949 * <pre>{@code @serial exclude}</pre> 950 * <b>Tree:</b> 951 * <pre> 952 * {@code 953 * JAVADOC_TAG -> JAVADOC_TAG 954 * |--SERIAL_LITERAL -> @serial 955 * |--WS -> 956 * `--DESCRIPTION -> DESCRIPTION 957 * |--TEXT -> serialized company name 958 * |--NEWLINE -> \r\n 959 * `--TEXT -> 960 * } 961 * </pre> 962 * 963 * @see 964 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF"> 965 * Oracle Docs</a> 966 * @see #SERIAL_LITERAL 967 */ 968 public static final int LITERAL_EXCLUDE = JavadocParser.LITERAL_EXCLUDE; 969 970 /** 971 * 'include' literal. 972 * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments. 973 * 974 * <p><b>Example:</b></p> 975 * <pre>{@code @serial include}</pre> 976 * <b>Tree:</b> 977 * <pre> 978 * {@code 979 * JAVADOC_TAG -> JAVADOC_TAG 980 * |--SERIAL_LITERAL -> @serial 981 * |--WS -> 982 * |--LITERAL_INCLUDE -> include 983 * |--NEWLINE -> \r\n 984 * `--WS -> 985 * } 986 * </pre> 987 * 988 * @see 989 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF"> 990 * Oracle Docs</a> 991 * @see #SERIAL_LITERAL 992 */ 993 public static final int LITERAL_INCLUDE = JavadocParser.LITERAL_INCLUDE; 994 995 /** 996 * Field name. First argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag. 997 * 998 * <p><b>Example:</b></p> 999 * <pre>{@code @serialField counter Integer objects counter}</pre> 1000 * <b>Tree:</b> 1001 * <pre> 1002 * {@code 1003 * --JAVADOC_TAG -> JAVADOC_TAG 1004 * |--SERIAL_FIELD_LITERAL -> @serialField 1005 * |--WS -> 1006 * |--LITERAL_INCLUDE -> include 1007 * |--NEWLINE -> \r\n 1008 * `--WS -> 1009 * `--DESCRIPTION -> DESCRIPTION 1010 * |--TEXT -> objects counter 1011 * |--NEWLINE -> \r\n 1012 * `--TEXT -> 1013 * }</pre> 1014 * 1015 * @see 1016 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF"> 1017 * Oracle Docs</a> 1018 * @see #SERIAL_FIELD_LITERAL 1019 */ 1020 public static final int FIELD_NAME = JavadocParser.FIELD_NAME; 1021 1022 /** 1023 * Field type. Second argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag. 1024 * 1025 * <p><b>Example:</b></p> 1026 * <pre>{@code @serialField counter Integer objects counter}</pre> 1027 * <b>Tree:</b> 1028 * <pre> 1029 * {@code 1030 * --JAVADOC_TAG -> JAVADOC_TAG 1031 * |--SERIAL_FIELD_LITERAL -> @serialField 1032 * |--WS -> 1033 * |--FIELD_NAME -> counter 1034 * |--WS -> 1035 * |--FIELD_TYPE -> Integer 1036 * |--WS -> 1037 * `--DESCRIPTION -> DESCRIPTION 1038 * |--TEXT -> objects counter 1039 * |--NEWLINE -> \r\n 1040 * `--TEXT -> 1041 * } 1042 * </pre> 1043 * 1044 * @see 1045 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF"> 1046 * Oracle Docs</a> 1047 * @see #SERIAL_FIELD_LITERAL 1048 */ 1049 public static final int FIELD_TYPE = JavadocParser.FIELD_TYPE; 1050 1051 // ------------------------------------------------------------------------------------------ // 1052 // ----------------- HTML TAGS ---------------------------------------------- // 1053 // ------------------------------------------------------------------------------------------ // 1054 1055 /** 1056 * Identifier inside HTML tag: tag name or attribute name. 1057 */ 1058 public static final int HTML_TAG_NAME = JavadocParser.HTML_TAG_NAME; 1059 1060 // HTML tag components 1061 1062 /** 1063 * Start html tag component: {@code '<'}. 1064 */ 1065 public static final int START = JavadocParser.START; 1066 1067 /** 1068 * Slash html tag component: {@code '/'}. 1069 */ 1070 public static final int SLASH = JavadocParser.SLASH; 1071 1072 /** 1073 * End html tag component: {@code '>'}. 1074 */ 1075 public static final int END = JavadocParser.END; 1076 1077 /** 1078 * Slash close html tag component: {@code '/>'}. 1079 */ 1080 public static final int SLASH_END = JavadocParser.SLASH_END; 1081 1082 /** 1083 * Equals html tag component: {@code '='}. 1084 */ 1085 public static final int EQUALS = JavadocParser.EQUALS; 1086 1087 /** 1088 * Attribute value HTML tag component. 1089 * 1090 * <p><b>Example:</b></p> 1091 * 1092 * <pre>{@code 1093 * <tag_name attr_name="attr_value">Content</tag_name> 1094 * }</pre> 1095 * 1096 * <p><b>Tree:</b></p> 1097 * <pre>{@code 1098 * JAVADOC -> JAVADOC 1099 * |--NEWLINE -> \r\n 1100 * |--LEADING_ASTERISK -> * 1101 * |--TEXT -> 1102 * |--HTML_ELEMENT -> HTML_ELEMENT 1103 * | `--HTML_TAG -> HTML_TAG 1104 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1105 * | | |--START -> < 1106 * | | |--HTML_TAG_NAME -> tag_name 1107 * | | |--WS -> 1108 * | | |--ATTRIBUTE -> ATTRIBUTE 1109 * | | | |--HTML_TAG_NAME -> attr_name 1110 * | | | |--EQUALS -> = 1111 * | | | `--ATTR_VALUE -> "attr_value" 1112 * | | `--END -> > 1113 * | |--TEXT -> Content 1114 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1115 * | |--START -> < 1116 * | |--SLASH -> / 1117 * | |--HTML_TAG_NAME -> tag_name 1118 * | `--END -> > 1119 * }</pre> 1120 */ 1121 public static final int ATTR_VALUE = JavadocParser.ATTR_VALUE; 1122 1123 /////////////////////// HTML TAGS WITH OPTIONAL END TAG ///////////////////////////////////// 1124 1125 /** 1126 * Paragraph tag name. 1127 * 1128 * <p><b>Example:</b></p> 1129 * <pre>{@code <p>Paragraph Tag.</p>}</pre> 1130 * <b>Tree:</b> 1131 * <pre> 1132 * {@code 1133 * `--HTML_ELEMENT -> HTML_ELEMENT 1134 * `--PARAGRAPH -> PARAGRAPH 1135 * |--P_TAG_START -> P_TAG_START 1136 * | |--START -> < 1137 * | |--P_HTML_TAG_NAME -> p 1138 * | `--END -> > 1139 * |--TEXT -> Paragraph Tag. 1140 * `--P_TAG_END -> P_TAG_END 1141 * |--START -> < 1142 * |--SLASH -> / 1143 * |--P_HTML_TAG_NAME -> p 1144 * `--END -> > 1145 * } 1146 * </pre> 1147 * 1148 * @see 1149 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1150 * Comments are written in HTML</a> 1151 * @see #P_HTML_TAG_NAME 1152 */ 1153 public static final int P_HTML_TAG_NAME = JavadocParser.P_HTML_TAG_NAME; 1154 1155 /** 1156 * List item tag name. 1157 * 1158 * <p><b>Example:</b></p> 1159 * <pre>{@code 1160 * <ol> 1161 * <li>banana</li> 1162 * </ol> 1163 * }</pre> 1164 * <b>Tree:</b> 1165 * <pre> 1166 * {@code 1167 * HTML_ELEMENT -> HTML_ELEMENT 1168 * `--HTML_TAG -> HTML_TAG 1169 * |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1170 * | |--START -> < 1171 * | |--HTML_TAG_NAME -> ol 1172 * | `--END -> > 1173 * |--NEWLINE -> \r\n 1174 * |--LEADING_ASTERISK -> * 1175 * |--TEXT -> 1176 * |--HTML_ELEMENT -> HTML_ELEMENT 1177 * | `--LI -> LI 1178 * | |--LI_TAG_START -> LI_TAG_START 1179 * | | |--START -> < 1180 * | | |--LI_HTML_TAG_NAME -> li 1181 * | | `--END -> > 1182 * | |--TEXT -> banana 1183 * | `--LI_TAG_END -> LI_TAG_END 1184 * | |--START -> < 1185 * | |--SLASH -> / 1186 * | |--LI_HTML_TAG_NAME -> li 1187 * | `--END -> > 1188 * |--NEWLINE -> \r\n 1189 * |--LEADING_ASTERISK -> * 1190 * |--TEXT -> 1191 * `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1192 * |--START -> < 1193 * |--SLASH -> / 1194 * |--HTML_TAG_NAME -> ol 1195 * `--END -> > 1196 * } 1197 * </pre> 1198 * 1199 * @see 1200 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1201 * comments are written in HTML</a> 1202 * @see #LI_HTML_TAG_NAME 1203 */ 1204 public static final int LI_HTML_TAG_NAME = JavadocParser.LI_HTML_TAG_NAME; 1205 1206 /** 1207 * Table row tag name. 1208 * 1209 * <p><b>Example:</b></p> 1210 * <pre>{@code 1211 * <table> 1212 * <tr>Table Row</tr> 1213 * </table> 1214 * }</pre> 1215 * <b>Tree:</b> 1216 * <pre> 1217 * {@code 1218 * HTML_ELEMENT -> HTML_ELEMENT 1219 * `--HTML_TAG -> HTML_TAG 1220 * |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1221 * | |--START -> < 1222 * | |--HTML_TAG_NAME -> table 1223 * | `--END -> > 1224 * |--NEWLINE -> \r\n 1225 * |--LEADING_ASTERISK -> * 1226 * |--TEXT -> 1227 * |--HTML_ELEMENT -> HTML_ELEMENT 1228 * | `--TR -> TR 1229 * | |--TR_TAG_START -> TR_TAG_START 1230 * | | |--START -> < 1231 * | | |--TR_HTML_TAG_NAME -> tr 1232 * | | `--END -> > 1233 * | |--TEXT -> Table Row 1234 * | `--TR_TAG_END -> TR_TAG_END 1235 * | |--START -> < 1236 * | |--SLASH -> / 1237 * | |--TR_HTML_TAG_NAME -> tr 1238 * | `--END -> > 1239 * |--NEWLINE -> \r\n 1240 * |--LEADING_ASTERISK -> * 1241 * |--TEXT -> 1242 * `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1243 * |--START -> < 1244 * |--SLASH -> / 1245 * |--HTML_TAG_NAME -> table 1246 * `--END -> > 1247 * } 1248 * </pre> 1249 * 1250 * @see 1251 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1252 * comments are written in HTML</a> 1253 * @see #TR_HTML_TAG_NAME 1254 */ 1255 public static final int TR_HTML_TAG_NAME = JavadocParser.TR_HTML_TAG_NAME; 1256 1257 /** 1258 * Table cell tag name. 1259 * 1260 * <p><b>Example:</b></p> 1261 * <pre>{@code 1262 * <tr> 1263 * <td>Cell 1</td> 1264 * </tr> 1265 * }</pre> 1266 * <b>Tree:</b> 1267 * <pre> 1268 * {@code 1269 * HTML_ELEMENT -> HTML_ELEMENT 1270 * `--TR -> TR 1271 * |--TR_TAG_START -> TR_TAG_START 1272 * | |--START -> < 1273 * | |--TR_HTML_TAG_NAME -> tr 1274 * | `--END -> > 1275 * |--NEWLINE -> \r\n 1276 * |--LEADING_ASTERISK -> * 1277 * |--TEXT -> 1278 * |--TD -> TD 1279 * | |--TD_TAG_START -> TD_TAG_START 1280 * | | |--START -> < 1281 * | | |--TD_HTML_TAG_NAME -> td 1282 * | | `--END -> > 1283 * | |--TEXT -> Cell 1 1284 * | `--TD_TAG_END -> TD_TAG_END 1285 * | |--START -> < 1286 * | |--SLASH -> / 1287 * | |--TD_HTML_TAG_NAME -> td 1288 * | `--END -> > 1289 * |--NEWLINE -> \r\n 1290 * |--LEADING_ASTERISK -> * 1291 * |--TEXT -> 1292 * `--TR_TAG_END -> TR_TAG_END 1293 * |--START -> < 1294 * |--SLASH -> / 1295 * |--TR_HTML_TAG_NAME -> tr 1296 * `--END -> > 1297 * } 1298 * </pre> 1299 * 1300 * @see 1301 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1302 * comments are written in HTML</a> 1303 * @see #TD_HTML_TAG_NAME 1304 */ 1305 public static final int TD_HTML_TAG_NAME = JavadocParser.TD_HTML_TAG_NAME; 1306 1307 /** Table header cell tag name. */ 1308 public static final int TH_HTML_TAG_NAME = JavadocParser.TH_HTML_TAG_NAME; 1309 1310 /** Body tag name. */ 1311 public static final int BODY_HTML_TAG_NAME = JavadocParser.BODY_HTML_TAG_NAME; 1312 1313 /** 1314 * Colgroup tag name. 1315 * 1316 * <p><b>Example:</b></p> 1317 * <pre>{@code <colgroup><col span="2"></colgroup>}</pre> 1318 * <b>Tree:</b> 1319 * <pre> 1320 * {@code 1321 * |--HTML_ELEMENT -> HTML_ELEMENT 1322 * | `--COLGROUP -> COLGROUP 1323 * | |--COLGROUP_TAG_START -> COLGROUP_TAG_START 1324 * | | |--START -> < 1325 * | | |--COLGROUP_HTML_TAG_NAME -> colgroup 1326 * | | `--END -> > 1327 * | |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1328 * | | `--COL_TAG -> COL_TAG 1329 * | | |--START -> < 1330 * | | |--COL_HTML_TAG_NAME -> col 1331 * | | |--WS -> 1332 * | | |--ATTRIBUTE -> ATTRIBUTE 1333 * | | | |--HTML_TAG_NAME -> span 1334 * | | | |--EQUALS -> = 1335 * | | | `--ATTR_VALUE -> "2" 1336 * | | `--END -> > 1337 * | `--COLGROUP_TAG_END -> COLGROUP_TAG_END 1338 * | |--START -> < 1339 * | |--SLASH -> / 1340 * | |--COLGROUP_HTML_TAG_NAME -> colgroup 1341 * | `--END -> > 1342 * |--TEXT -> 1343 * `--EOF -> <EOF> 1344 * } 1345 * </pre> 1346 * 1347 * @see #COLGROUP_HTML_TAG_NAME 1348 */ 1349 public static final int COLGROUP_HTML_TAG_NAME = JavadocParser.COLGROUP_HTML_TAG_NAME; 1350 1351 /** 1352 * Description of a term tag name. 1353 * 1354 * <p><b>Example:</b></p> 1355 * <pre>{@code 1356 * <dl> 1357 * <dt>Java</dt> 1358 * <dd>A high-level programming language.</dd> 1359 * </dl> 1360 * }</pre> 1361 * <b>Tree:</b> 1362 * <pre> 1363 * {@code 1364 * HTML_ELEMENT -> HTML_ELEMENT 1365 * `--HTML_TAG -> HTML_TAG 1366 * |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1367 * | |--START -> < 1368 * | |--HTML_TAG_NAME -> dl 1369 * | `--END -> > 1370 * |--NEWLINE -> \r\n 1371 * |--LEADING_ASTERISK -> * 1372 * |--TEXT -> 1373 * |--HTML_ELEMENT -> HTML_ELEMENT 1374 * | `--DT -> DT 1375 * | |--DT_TAG_START -> DT_TAG_START 1376 * | | |--START -> < 1377 * | | |--DT_HTML_TAG_NAME -> dt 1378 * | | `--END -> > 1379 * | |--TEXT -> Java 1380 * | `--DT_TAG_END -> DT_TAG_END 1381 * | |--START -> < 1382 * | |--SLASH -> / 1383 * | |--DT_HTML_TAG_NAME -> dt 1384 * | `--END -> > 1385 * |--NEWLINE -> \r\n 1386 * |--LEADING_ASTERISK -> * 1387 * |--TEXT -> 1388 * |--HTML_ELEMENT -> HTML_ELEMENT 1389 * | `--DD -> DD 1390 * | |--DD_TAG_START -> DD_TAG_START 1391 * | | |--START -> < 1392 * | | |--DD_HTML_TAG_NAME -> dd 1393 * | | `--END -> > 1394 * | |--TEXT -> A high-level programming language. 1395 * | `--DD_TAG_END -> DD_TAG_END 1396 * | |--START -> < 1397 * | |--SLASH -> / 1398 * | |--DD_HTML_TAG_NAME -> dd 1399 * | `--END -> > 1400 * |--NEWLINE -> \r\n 1401 * |--LEADING_ASTERISK -> * 1402 * |--TEXT -> 1403 * `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1404 * |--START -> < 1405 * |--SLASH -> / 1406 * |--HTML_TAG_NAME -> dl 1407 * `--END -> > 1408 * } 1409 * </pre> 1410 * 1411 * @see #DD_HTML_TAG_NAME 1412 */ 1413 public static final int DD_HTML_TAG_NAME = JavadocParser.DD_HTML_TAG_NAME; 1414 1415 /** Description term tag name. */ 1416 public static final int DT_HTML_TAG_NAME = JavadocParser.DT_HTML_TAG_NAME; 1417 1418 /** Head tag name. */ 1419 public static final int HEAD_HTML_TAG_NAME = JavadocParser.HEAD_HTML_TAG_NAME; 1420 1421 /** Html tag name. */ 1422 public static final int HTML_HTML_TAG_NAME = JavadocParser.HTML_HTML_TAG_NAME; 1423 1424 /** Option tag name. */ 1425 public static final int OPTION_HTML_TAG_NAME = JavadocParser.OPTION_HTML_TAG_NAME; 1426 1427 /** Table body tag name. */ 1428 public static final int TBODY_HTML_TAG_NAME = JavadocParser.TBODY_HTML_TAG_NAME; 1429 1430 /** Table foot tag name. */ 1431 public static final int TFOOT_HTML_TAG_NAME = JavadocParser.TFOOT_HTML_TAG_NAME; 1432 1433 /** Table head tag name. */ 1434 public static final int THEAD_HTML_TAG_NAME = JavadocParser.THEAD_HTML_TAG_NAME; 1435 1436 /** `optgroup` tag name. */ 1437 public static final int OPTGROUP_HTML_TAG_NAME = JavadocParser.OPTGROUP_HTML_TAG_NAME; 1438 1439 /** `rb` tag name. */ 1440 public static final int RB_HTML_TAG_NAME = JavadocParser.RB_HTML_TAG_NAME; 1441 1442 /** `rt` tag name. */ 1443 public static final int RT_HTML_TAG_NAME = JavadocParser.RT_HTML_TAG_NAME; 1444 1445 /** `rtc` tag name. */ 1446 public static final int RTC_HTML_TAG_NAME = JavadocParser.RTC_HTML_TAG_NAME; 1447 1448 /** `rp` tag name. */ 1449 public static final int RP_HTML_TAG_NAME = JavadocParser.RP_HTML_TAG_NAME; 1450 /////////////////////////////////////////////////////////////////////////////////////////////// 1451 1452 /////////////////////// SINGLETON HTML TAGS ////////////////////////////////////////////////// 1453 /** 1454 * Area tag name. 1455 * 1456 * <p><b>Example:</b></p> 1457 * <pre>{@code < area shape="rect" >}</pre> 1458 * <b>Tree:</b> 1459 * <pre> 1460 * {@code 1461 * JAVADOC -> JAVADOC 1462 * |--NEWLINE -> \n 1463 * |--LEADING_ASTERISK -> * 1464 * |--TEXT -> 1465 * |--HTML_ELEMENT -> HTML_ELEMENT 1466 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1467 * | `--AREA_TAG -> AREA_TAG 1468 * | |--START -> < 1469 * | |--AREA_HTML_TAG_NAME -> area 1470 * | |--WS -> 1471 * | |--ATTRIBUTE -> ATTRIBUTE 1472 * | | |--HTML_TAG_NAME -> shape 1473 * | | |--EQUALS -> = 1474 * | | `--ATTR_VALUE -> "rect" 1475 * | `--END -> > 1476 * |--TEXT -> 1477 * |--NEWLINE -> \n 1478 * |--TEXT -> 1479 * } 1480 * </pre> 1481 */ 1482 1483 public static final int AREA_HTML_TAG_NAME = JavadocParser.AREA_HTML_TAG_NAME; 1484 1485 /** Base tag name. */ 1486 public static final int BASE_HTML_TAG_NAME = JavadocParser.BASE_HTML_TAG_NAME; 1487 1488 /** Basefont tag name. */ 1489 public static final int BASEFONT_HTML_TAG_NAME = JavadocParser.BASEFONT_HTML_TAG_NAME; 1490 1491 /** 1492 * Br tag name. 1493 * 1494 * <p><b>Example:</b></p> 1495 * <pre>{@code text before break < br > text after break}</pre> 1496 * <b>Tree:</b> 1497 * <pre> 1498 * {@code 1499 * JAVADOC ->; JAVADOC 1500 * |--NEWLINE ->; \r\n 1501 * |--LEADING_ASTERISK ->; * 1502 * |--TEXT ->; text before break 1503 * |--HTML_ELEMENT ->; HTML_ELEMENT 1504 * | `--SINGLETON_ELEMENT ->; SINGLETON_ELEMENT 1505 * | `--BR_TAG ->; BR_TAG 1506 * | |--START ->; -<; 1507 * | |--BR_HTML_TAG_NAME ->; br 1508 * | `--END ->; >; 1509 * |--TEXT ->; text after break 1510 * |--NEWLINE ->; \r\n 1511 * |--TEXT ->; 1512 * } 1513 * </pre> 1514 */ 1515 1516 public static final int BR_HTML_TAG_NAME = JavadocParser.BR_HTML_TAG_NAME; 1517 1518 /** Col tag name. */ 1519 public static final int COL_HTML_TAG_NAME = JavadocParser.COL_HTML_TAG_NAME; 1520 1521 /** Frame tag name. */ 1522 public static final int FRAME_HTML_TAG_NAME = JavadocParser.FRAME_HTML_TAG_NAME; 1523 1524 /** 1525 * Hr tag name. 1526 * 1527 * <p><b>Example:</b></p> 1528 * <pre>{@code text before horizontal rule < hr > text after horizontal rule}</pre> 1529 * <b>Tree:</b> 1530 * <pre> 1531 * {@code 1532 * |--TEXT -> text before horizontal rule 1533 * |--HTML_ELEMENT -> HTML_ELEMENT 1534 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1535 * | `--HR_TAG -> HR_TAG 1536 * | |--START -> < 1537 * | |--HR_HTML_TAG_NAME -> hr 1538 * | `--END -> > 1539 * |--TEXT -> text after horizontal rule 1540 * |--NEWLINE -> \r\n 1541 * } 1542 * </pre> 1543 */ 1544 1545 public static final int HR_HTML_TAG_NAME = JavadocParser.HR_HTML_TAG_NAME; 1546 1547 /** Img tag name. */ 1548 public static final int IMG_HTML_TAG_NAME = JavadocParser.IMG_HTML_TAG_NAME; 1549 1550 /** 1551 * Input tag name. 1552 * 1553 * <p><b>Example:</b></p> 1554 * <pre>{@code <input name="Name" type="text" placeholder="Enter your name"/>}</pre> 1555 * <b>Tree:</b> 1556 * <pre> 1557 * {@code 1558 * HTML_ELEMENT -> HTML_ELEMENT 1559 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1560 * `--INPUT_TAG -> INPUT_TAG 1561 * |--START -> < 1562 * |--INPUT_HTML_TAG_NAME -> input 1563 * |--WS -> 1564 * |--ATTRIBUTE -> ATTRIBUTE 1565 * | |--HTML_TAG_NAME -> name 1566 * | |--EQUALS -> = 1567 * | `--ATTR_VALUE -> "Name" 1568 * |--WS -> 1569 * |--ATTRIBUTE -> ATTRIBUTE 1570 * | |--HTML_TAG_NAME -> type 1571 * | |--EQUALS -> = 1572 * | `--ATTR_VALUE -> "text" 1573 * |--WS -> 1574 * |--ATTRIBUTE -> ATTRIBUTE 1575 * | |--HTML_TAG_NAME -> placeholder 1576 * | |--EQUALS -> = 1577 * | `--ATTR_VALUE -> "Enter your name" 1578 * `--SLASH_END -> /> 1579 * } 1580 * </pre> 1581 * 1582 * @see 1583 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1584 * comments are written in HTML</a> 1585 * @see #INPUT_HTML_TAG_NAME 1586 */ 1587 public static final int INPUT_HTML_TAG_NAME = JavadocParser.INPUT_HTML_TAG_NAME; 1588 1589 /** Isindex tag name. */ 1590 public static final int ISINDEX_HTML_TAG_NAME = JavadocParser.ISINDEX_HTML_TAG_NAME; 1591 1592 /** 1593 * Link tag name. 1594 * 1595 * <p><b>Example:</b></p> 1596 * <pre>{@code <link rel="stylesheet" href="Style.css">}</pre> 1597 * <b>Tree:</b> 1598 * <pre> 1599 * {@code 1600 * HTML_ELEMENT -> HTML_ELEMENT 1601 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1602 * `--LINK_TAG -> LINK_TAG 1603 * |--START -> < 1604 * |--LINK_HTML_TAG_NAME -> link 1605 * |--WS -> 1606 * |--ATTRIBUTE -> ATTRIBUTE 1607 * | |--HTML_TAG_NAME -> rel 1608 * | |--EQUALS -> = 1609 * | `--ATTR_VALUE -> "stylesheet" 1610 * |--WS -> 1611 * |--ATTRIBUTE -> ATTRIBUTE 1612 * | |--HTML_TAG_NAME -> href 1613 * | |--EQUALS -> = 1614 * | `--ATTR_VALUE -> "Style.css" 1615 * `--END -> > 1616 * } 1617 * </pre> 1618 * 1619 * @see 1620 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1621 * comments are written in HTML</a> 1622 * @see #LINK_HTML_TAG_NAME 1623 */ 1624 public static final int LINK_HTML_TAG_NAME = JavadocParser.LINK_HTML_TAG_NAME; 1625 1626 /** Meta tag name. */ 1627 public static final int META_HTML_TAG_NAME = JavadocParser.META_HTML_TAG_NAME; 1628 1629 /** Param tag name. */ 1630 public static final int PARAM_HTML_TAG_NAME = JavadocParser.PARAM_HTML_TAG_NAME; 1631 /** "embed" tag name. */ 1632 public static final int EMBED_HTML_TAG_NAME = JavadocParser.EMBED_HTML_TAG_NAME; 1633 /** "keygen" tag name. */ 1634 public static final int KEYGEN_HTML_TAG_NAME = JavadocParser.KEYGEN_HTML_TAG_NAME; 1635 /** "source" tag name. */ 1636 public static final int SOURCE_HTML_TAG_NAME = JavadocParser.SOURCE_HTML_TAG_NAME; 1637 /** "track" tag name. */ 1638 public static final int TRACK_HTML_TAG_NAME = JavadocParser.TRACK_HTML_TAG_NAME; 1639 /** "wbr" tag name. */ 1640 public static final int WBR_HTML_TAG_NAME = JavadocParser.WBR_HTML_TAG_NAME; 1641 /////////////////////////////////////////////////////////////////////////////////////////////// 1642 1643 /** 1644 * HTML comment start symbol '<!--'. 1645 * 1646 * <p><b>Example:</b></p> 1647 * <pre>{@code 1648 * <!-- 1649 * This is an HTML multi-line comment: 1650 * This is another comment 1651 * --> 1652 * }</pre> 1653 * <b>Tree:</b> 1654 * <pre> 1655 * {@code 1656 * HTML_COMMENT -> HTML_COMMENT 1657 * |--HTML_COMMENT_START -> <!-- 1658 * |--NEWLINE -> \n 1659 * |--LEADING_ASTERISK -> * 1660 * |--TEXT -> This is an HTML multi-line comment: 1661 * |--NEWLINE -> \n 1662 * |--LEADING_ASTERISK -> * 1663 * |--TEXT -> This is another comment 1664 * |--NEWLINE -> \n 1665 * |--LEADING_ASTERISK -> * 1666 * |--TEXT -> 1667 * `--HTML_COMMENT_END -> --> 1668 * } 1669 * </pre> 1670 */ 1671 public static final int HTML_COMMENT_START = JavadocParser.HTML_COMMENT_START; 1672 1673 /** 1674 * HTML comment end symbol '-->'. 1675 * 1676 * <p><b>Example:</b></p> 1677 * <pre>{@code 1678 * <!-- 1679 * This is an HTML multi-line comment: 1680 * This is another comment 1681 * --> 1682 * }</pre> 1683 * <b>Tree:</b> 1684 * <pre> 1685 * {@code 1686 * HTML_COMMENT -> HTML_COMMENT 1687 * |--HTML_COMMENT_START -> <!-- 1688 * |--NEWLINE -> \n 1689 * |--LEADING_ASTERISK -> * 1690 * |--TEXT -> This is an HTML multi-line comment: 1691 * |--NEWLINE -> \n 1692 * |--LEADING_ASTERISK -> * 1693 * |--TEXT -> This is another comment 1694 * |--NEWLINE -> \n 1695 * |--LEADING_ASTERISK -> * 1696 * |--TEXT -> 1697 * `--HTML_COMMENT_END -> --> 1698 * } 1699 * </pre> 1700 */ 1701 public static final int HTML_COMMENT_END = JavadocParser.HTML_COMMENT_END; 1702 1703 // ------------------------------------------------------------------------------------------ // 1704 // ----------------- OTHER -------------------------------------------------- // 1705 // ------------------------------------------------------------------------------------------ // 1706 1707 /** Leading asterisk. */ 1708 public static final int LEADING_ASTERISK = JavadocParser.LEADING_ASTERISK; 1709 1710 /** 1711 * Newline symbol - '\n'. 1712 */ 1713 public static final int NEWLINE = JavadocParser.NEWLINE; 1714 1715 /** 1716 * Any other symbol. 1717 */ 1718 public static final int CHAR = JavadocParser.CHAR; 1719 1720 /** 1721 * Whitespace or tab ('\t') symbol. 1722 */ 1723 public static final int WS = JavadocParser.WS; 1724 1725 /** 1726 * End Of File symbol. Copied from 1727 * {@link org.antlr.v4.runtime.Recognizer#EOF} to avoid ANTLR dependency in 1728 * API. 1729 */ 1730 public static final int EOF = -1; 1731 1732 // ------------------------------------------------------------------------------------------ // 1733 // ------ JAVADOC TAGS DEPENDING ON RULE TYPES OFFSET --------------------------------------- // 1734 // ------------------------------------------------------------------------------------------ // 1735 1736 /** 1737 * Rule types offset. 1738 * RULE_TYPES_OFFSET constant is used to split lexer tokens types and parser rules types. 1739 * We need unique numbers for all tokens, 1740 * ANTLR do not need this and that is why these types are mixed by used values. 1741 * All values we can take a look at 1742 * target/generated-sources/antlr/com/puppycrawl/tools/checkstyle/grammar/javadoc/JavadocParser.java 1743 * For example: LEADING_ASTERISK=1 and RULE_htmlElement = 1. 1744 * RULE_TYPES_OFFSET required to shift parser rules, 1745 * to let them not overlap with types that have prefix "RULE_". 1746 */ 1747 private static final int RULE_TYPES_OFFSET = 10000; 1748 1749 /** 1750 * Root node of any Javadoc comment. 1751 * Last child is always {@link #EOF}. 1752 * 1753 * <p><b>Tree for example:</b></p> 1754 * <pre>{@code 1755 * JAVADOC -> JAVADOC 1756 * |--NEWLINE -> \n 1757 * |--LEADING_ASTERISK -> * 1758 * |--WS -> 1759 * |--JAVADOC_TAG -> JAVADOC_TAG 1760 * | |--PARAM_LITERAL -> @param 1761 * | |--WS -> 1762 * | |--PARAMETER_NAME -> T 1763 * | |--WS -> 1764 * | `--DESCRIPTION -> DESCRIPTION 1765 * | |--TEXT -> The bar. 1766 * | |--NEWLINE -> \n 1767 * | `--TEXT -> 1768 * `--EOF -> <EOF> 1769 * }</pre> 1770 */ 1771 public static final int JAVADOC = JavadocParser.RULE_javadoc + RULE_TYPES_OFFSET; 1772 1773 /** 1774 * Javadoc tag. 1775 * 1776 * <p>Type of Javadoc tag is resolved by literal node that is first child of this node.</p> 1777 * 1778 * <p>As literal could be:</p> 1779 * <ul> 1780 * <li>{@link #RETURN_LITERAL}</li> 1781 * <li>{@link #DEPRECATED_LITERAL}</li> 1782 * <li>{@link #SINCE_LITERAL}</li> 1783 * <li>{@link #SERIAL_DATA_LITERAL}</li> 1784 * <li>{@link #SERIAL_FIELD_LITERAL}</li> 1785 * <li>{@link #PARAM_LITERAL}</li> 1786 * <li>{@link #SEE_LITERAL}</li> 1787 * <li>{@link #SERIAL_LITERAL}</li> 1788 * <li>{@link #VERSION_LITERAL}</li> 1789 * <li>{@link #EXCEPTION_LITERAL}</li> 1790 * <li>{@link #THROWS_LITERAL}</li> 1791 * <li>{@link #AUTHOR_LITERAL}</li> 1792 * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc tag.</li> 1793 * </ul> 1794 * 1795 * <p><b>Example</b></p> 1796 * <pre>{@code @param T The bar.}</pre> 1797 * <b>Tree</b> 1798 * <pre>{@code 1799 * JAVADOC_TAG -> JAVADOC_TAG 1800 * |--PARAM_LITERAL -> @param 1801 * |--WS -> 1802 * |--PARAMETER_NAME -> T 1803 * |--WS -> 1804 * `--DESCRIPTION -> DESCRIPTION 1805 * |--TEXT -> The bar. 1806 * |--NEWLINE -> \r\n 1807 * `--TEXT -> 1808 * }</pre> 1809 */ 1810 1811 public static final int JAVADOC_TAG = JavadocParser.RULE_javadocTag + RULE_TYPES_OFFSET; 1812 /** 1813 * Javadoc inline tag. 1814 * 1815 * <p>Type of Javadoc inline tag is resolved by literal node that is second child of this node. 1816 * First child is always {@link #JAVADOC_INLINE_TAG_START} and last node is always 1817 * {@link #JAVADOC_INLINE_TAG_END}.</p> 1818 * 1819 * <p>As literal could be:</p> 1820 * <ul> 1821 * <li>{@link #CODE_LITERAL}</li> 1822 * <li>{@link #DOC_ROOT_LITERAL}</li> 1823 * <li>{@link #LINK_LITERAL}</li> 1824 * <li>{@link #INHERIT_DOC_LITERAL}</li> 1825 * <li>{@link #LINKPLAIN_LITERAL}</li> 1826 * <li>{@link #LITERAL_LITERAL}</li> 1827 * <li>{@link #VALUE_LITERAL}</li> 1828 * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc inline tag.</li> 1829 * </ul> 1830 * 1831 * <p><b>Example:</b></p> 1832 * <pre><code>{@link String}</code></pre> 1833 * <b>Tree:</b> 1834 * <pre> 1835 * {@code 1836 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1837 * |--JAVADOC_INLINE_TAG_START -> { 1838 * |--LINK_LITERAL -> @link 1839 * |--WS -> 1840 * |--REFERENCE -> REFERENCE 1841 * `--PACKAGE_CLASS -> String 1842 * `--JAVADOC_INLINE_TAG_END -> } 1843 * } 1844 * </pre> 1845 * 1846 * @noinspection HtmlTagCanBeJavadocTag 1847 * @noinspection HtmlTagCanBeJavadocTag 1848 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 1849 * replaced with Javadoc tag 1850 */ 1851 public static final int JAVADOC_INLINE_TAG = JavadocParser.RULE_javadocInlineTag 1852 + RULE_TYPES_OFFSET; 1853 1854 /** 1855 * Parameter of the Javadoc tags listed below. 1856 * <ul> 1857 * <li>{@link #SEE_LITERAL @see}</li> 1858 * <li>{@link #LINK_LITERAL {@link}}</li> 1859 * <li>{@link #LINKPLAIN_LITERAL {@linkplain}}</li> 1860 * <li>{@link #VALUE_LITERAL {@value}}</li> 1861 * </ul> 1862 */ 1863 public static final int REFERENCE = JavadocParser.RULE_reference + RULE_TYPES_OFFSET; 1864 1865 /** 1866 * Parameters part in {@link #REFERENCE}. 1867 * It is used to specify parameters for {@link #MEMBER method}. 1868 * Always contains {@link #LEFT_BRACE} as first child and {@link #RIGHT_BRACE} as last child. 1869 * Each parameter is represented by {@link #ARGUMENT} node. 1870 * Arguments in braces are separated by {@link #COMMA} (and optional {@link #WS}). 1871 * 1872 * <p><b>Example:</b></p> 1873 * <pre>{@code @see #method(Processor, String)}</pre> 1874 * <b>Tree:</b> 1875 * <pre> 1876 * {@code 1877 * JAVADOC_TAG -> JAVADOC_TAG 1878 * |--SEE_LITERAL -> @see 1879 * |--WS -> 1880 * |--REFERENCE -> REFERENCE 1881 * |--HASH -> # 1882 * |--MEMBER -> method 1883 * `--PARAMETERS -> PARAMETERS 1884 * |--LEFT_BRACE -> ( 1885 * |--ARGUMENT -> Processor 1886 * |--COMMA -> , 1887 * |--WS -> 1888 * |--ARGUMENT -> String 1889 * `--RIGHT_BRACE -> ) 1890 * } 1891 * </pre> 1892 */ 1893 public static final int PARAMETERS = JavadocParser.RULE_parameters + RULE_TYPES_OFFSET; 1894 1895 /** 1896 * Description node. It contains: 1897 * <ul> 1898 * <li>{@link #TEXT}</li> 1899 * <li>{@link #WS}</li> 1900 * <li>{@link #NEWLINE}</li> 1901 * <li>{@link #HTML_ELEMENT}</li> 1902 * </ul> 1903 * 1904 * <p>It is argument for many Javadoc tags and inline tags.</p> 1905 * 1906 * <p><b>Example:</b></p> 1907 * <pre>{@code @throws IOException if <b>connection</b> problems occur}</pre> 1908 * <b>Tree:</b> 1909 * <pre> 1910 * {@code 1911 * --JAVADOC_TAG -> JAVADOC_TAG 1912 * |--THROWS_LITERAL -> @throws 1913 * |--WS -> 1914 * |--CLASS_NAME -> IOException 1915 * |--WS -> 1916 * `--DESCRIPTION -> DESCRIPTION 1917 * |--TEXT -> if 1918 * |--HTML_ELEMENT -> HTML_ELEMENT 1919 * | `--HTML_TAG -> HTML_TAG 1920 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1921 * | | |--START -> < 1922 * | | |--HTML_TAG_NAME -> b 1923 * | | `--END -> > 1924 * | |--TEXT -> connection 1925 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1926 * | |--START -> < 1927 * | |--SLASH -> / 1928 * | |--HTML_TAG_NAME -> b 1929 * | `--END -> > 1930 * |--TEXT -> problems occur 1931 * } 1932 * </pre> 1933 */ 1934 public static final int DESCRIPTION = JavadocParser.RULE_description + RULE_TYPES_OFFSET; 1935 1936 // ------------------------------------------------------------------------------------------ // 1937 // -------- HTML TAGS DEPENDING ON RULE TYPES OFFSET ---------------------------------------- // 1938 // ------------------------------------------------------------------------------------------ // 1939 1940 /** 1941 * Parent node for all html tags. 1942 */ 1943 public static final int HTML_ELEMENT = JavadocParser.RULE_htmlElement 1944 + RULE_TYPES_OFFSET; 1945 1946 /** 1947 * Start html tag: <XXXX>. 1948 */ 1949 public static final int HTML_ELEMENT_START = JavadocParser.RULE_htmlElementStart 1950 + RULE_TYPES_OFFSET; 1951 1952 /** 1953 * End html tag: <XXXX>. 1954 */ 1955 public static final int HTML_ELEMENT_END = JavadocParser.RULE_htmlElementEnd 1956 + RULE_TYPES_OFFSET; 1957 1958 /** 1959 * Non-special HTML tag. 1960 */ 1961 public static final int HTML_TAG = JavadocParser.RULE_htmlTag + RULE_TYPES_OFFSET; 1962 1963 /** 1964 * Html tag attribute. Parent node for: {@code HTML_TAG_IDENT, EQUALS, ATTR_VALUE}. 1965 * 1966 * <p><b>Example</b></p> 1967 * <pre>{@code <p class="highlight">Sample text</p>}</pre> 1968 * <b>Tree</b> 1969 * <pre> 1970 * {@code 1971 * HTML_ELEMENT -> HTML_ELEMENT 1972 * `--PARAGRAPH -> PARAGRAPH 1973 * |--P_TAG_START -> P_TAG_START 1974 * | |--START -> < 1975 * | |--P_HTML_TAG_NAME -> p 1976 * | |--WS -> 1977 * | |--ATTRIBUTE -> ATTRIBUTE 1978 * | | |--HTML_TAG_NAME -> class 1979 * | | |--EQUALS -> = 1980 * | | `--ATTR_VALUE -> "highlight" 1981 * | `--END -> > 1982 * |--TEXT -> Sample text 1983 * `--P_TAG_END -> P_TAG_END 1984 * |--START -> < 1985 * |--SLASH -> / 1986 * |--P_HTML_TAG_NAME -> p 1987 * `--END -> > 1988 * } 1989 * </pre> 1990 */ 1991 public static final int ATTRIBUTE = JavadocParser.RULE_attribute 1992 + RULE_TYPES_OFFSET; 1993 1994 /////////////////////// HTML TAGS WITH OPTIONAL END TAG ///////////////////////////////////// 1995 /** 1996 * Paragraph html tag. 1997 * 1998 * <p><b>Example:</b></p> 1999 * <pre>{@code <p>Sample text</p>}</pre> 2000 * <b>Tree:</b> 2001 * <pre> 2002 * {@code 2003 * `--JAVADOC -> JAVADOC 2004 * |--NEWLINE -> \r\n 2005 * |--LEADING_ASTERISK -> * 2006 * |--TEXT -> 2007 * |--HTML_ELEMENT -> HTML_ELEMENT 2008 * | `--PARAGRAPH -> PARAGRAPH 2009 * | |--P_TAG_START -> P_TAG_START 2010 * | | |--START -> < 2011 * | | |--P_HTML_TAG_NAME -> p 2012 * | | `--END -> > 2013 * | |--TEXT -> Sample text 2014 * | `--P_TAG_END -> P_TAG_END 2015 * | |--START -> < 2016 * | |--SLASH -> / 2017 * | |--P_HTML_TAG_NAME -> p 2018 * | `--END -> > 2019 * |--NEWLINE -> \r\n 2020 * |--TEXT -> 2021 * } 2022 * </pre> 2023 */ 2024 public static final int PARAGRAPH = JavadocParser.RULE_paragraph + RULE_TYPES_OFFSET; 2025 /** Start paragraph tag. */ 2026 public static final int P_TAG_START = JavadocParser.RULE_pTagStart + RULE_TYPES_OFFSET; 2027 /** End paragraph tag. */ 2028 public static final int P_TAG_END = JavadocParser.RULE_pTagEnd + RULE_TYPES_OFFSET; 2029 2030 /** 2031 * List items html tag. 2032 * 2033 * <p><b>Example:</b></p> 2034 * <pre>{@code 2035 * <ul> 2036 * <li>Item 1</li> 2037 * </ul> 2038 * }</pre> 2039 * <b>Tree:</b> 2040 * <pre> 2041 * {@code 2042 * --JAVADOC -> JAVADOC 2043 * |--NEWLINE -> \n 2044 * |--LEADING_ASTERISK -> * 2045 * |--TEXT -> 2046 * |--HTML_ELEMENT -> HTML_ELEMENT 2047 * | `--HTML_TAG -> HTML_TAG 2048 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 2049 * | | |--START -> < 2050 * | | |--HTML_TAG_NAME -> ul 2051 * | | `--END -> > 2052 * | |--NEWLINE -> \n 2053 * | |--LEADING_ASTERISK -> * 2054 * | |--TEXT -> 2055 * | |--HTML_ELEMENT -> HTML_ELEMENT 2056 * | | `--LI -> LI 2057 * | | |--LI_TAG_START -> LI_TAG_START 2058 * | | | |--START -> < 2059 * | | | |--LI_HTML_TAG_NAME -> li 2060 * | | | `--END -> > 2061 * | | |--TEXT -> Item 1 2062 * | | `--LI_TAG_END -> LI_TAG_END 2063 * | | |--START -> < 2064 * | | |--SLASH -> / 2065 * | | |--LI_HTML_TAG_NAME -> li 2066 * | | `--END -> > 2067 * | |--NEWLINE -> \n 2068 * | |--LEADING_ASTERISK -> * 2069 * | |--TEXT -> 2070 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 2071 * | |--START -> < 2072 * | |--SLASH -> / 2073 * | |--HTML_TAG_NAME -> ul 2074 * | `--END -> > 2075 * |--NEWLINE -> \n 2076 * |--TEXT -> 2077 * } 2078 * </pre> 2079 */ 2080 public static final int LI = JavadocParser.RULE_li + RULE_TYPES_OFFSET; 2081 /** Start list item tag. */ 2082 public static final int LI_TAG_START = JavadocParser.RULE_liTagStart + RULE_TYPES_OFFSET; 2083 /** End list item tag. */ 2084 public static final int LI_TAG_END = JavadocParser.RULE_liTagEnd + RULE_TYPES_OFFSET; 2085 2086 /** 2087 * Table row html tag. 2088 * 2089 * <p><b>Example:</b></p> 2090 * <pre>{@code <tr></tr>}</pre> 2091 * <b>Tree:</b> 2092 * <pre> 2093 * {@code 2094 * JAVADOC -> JAVADOC 2095 * |--NEWLINE -> \r\n 2096 * |--LEADING_ASTERISK -> * 2097 * |--TEXT -> 2098 * |--HTML_ELEMENT -> HTML_ELEMENT 2099 * | `--TR -> TR 2100 * | |--TR_TAG_START -> TR_TAG_START 2101 * | | |--START -> < 2102 * | | |--TR_HTML_TAG_NAME -> tr 2103 * | | `--END -> > 2104 * | `--TR_TAG_END -> TR_TAG_END 2105 * | |--START -> < 2106 * | |--SLASH -> / 2107 * | |--TR_HTML_TAG_NAME -> tr 2108 * | `--END -> > 2109 * |--NEWLINE -> \r\n 2110 * |--TEXT -> 2111 * } 2112 * </pre> 2113 */ 2114 public static final int TR = JavadocParser.RULE_tr + RULE_TYPES_OFFSET; 2115 /** Start table row tag. */ 2116 public static final int TR_TAG_START = JavadocParser.RULE_trTagStart + RULE_TYPES_OFFSET; 2117 /** End table row tag. */ 2118 public static final int TR_TAG_END = JavadocParser.RULE_trTagEnd + RULE_TYPES_OFFSET; 2119 2120 /** 2121 * Table cell HTML tag. 2122 * 2123 * <p><b>Example:</b></p> 2124 * <pre>{@code <td>Cell Content</td>}</pre> 2125 * <b>Tree:</b> 2126 * <pre> 2127 * {@code 2128 * HTML_ELEMENT -> HTML_ELEMENT 2129 * `--TD -> TD 2130 * |--TD_TAG_START -> TD_TAG_START 2131 * | |--START -> < 2132 * | |--TD_HTML_TAG_NAME -> td 2133 * | `--END -> > 2134 * |--TEXT -> Cell Content 2135 * `--TD_TAG_END -> TD_TAG_END 2136 * |--START -> < 2137 * |--SLASH -> / 2138 * |--TD_HTML_TAG_NAME -> td 2139 * `--END -> > 2140 * } 2141 * </pre> 2142 */ 2143 public static final int TD = JavadocParser.RULE_td + RULE_TYPES_OFFSET; 2144 /** Start table cell tag. */ 2145 public static final int TD_TAG_START = JavadocParser.RULE_tdTagStart + RULE_TYPES_OFFSET; 2146 /** End table cell tag. */ 2147 public static final int TD_TAG_END = JavadocParser.RULE_tdTagEnd + RULE_TYPES_OFFSET; 2148 2149 /** Table header cell html tag: {@code <th></th>}. */ 2150 public static final int TH = JavadocParser.RULE_th + RULE_TYPES_OFFSET; 2151 /** Start table header cell tag. */ 2152 public static final int TH_TAG_START = JavadocParser.RULE_thTagStart + RULE_TYPES_OFFSET; 2153 /** End table header cell tag. */ 2154 public static final int TH_TAG_END = JavadocParser.RULE_thTagEnd + RULE_TYPES_OFFSET; 2155 2156 /** Body html tag. */ 2157 public static final int BODY = JavadocParser.RULE_body + RULE_TYPES_OFFSET; 2158 2159 /** 2160 * Start body tag. 2161 * 2162 * <p><b>Example:</b></p> 2163 * <pre>{@code 2164 * <body> 2165 * This is a test 2166 * </body> 2167 * }</pre> 2168 * <b>Tree:</b> 2169 * <pre> 2170 * {@code 2171 * JAVADOC -> JAVADOC 2172 * |--TEXT -> /** 2173 * |--NEWLINE -> \n 2174 * |--LEADING_ASTERISK -> * 2175 * |--TEXT -> 2176 * |--HTML_ELEMENT -> HTML_ELEMENT 2177 * | `--BODY -> BODY 2178 * | |--BODY_TAG_START -> BODY_TAG_START 2179 * | | |--START -> < 2180 * | | |--BODY_HTML_TAG_NAME -> body 2181 * | | `--END -> > 2182 * | |--NEWLINE -> \n 2183 * | |--LEADING_ASTERISK -> * 2184 * | |--TEXT -> This is inside the body tag. 2185 * | |--NEWLINE -> \n 2186 * | |--LEADING_ASTERISK -> * 2187 * | |--TEXT -> 2188 * | `--BODY_TAG_END -> BODY_TAG_END 2189 * | |--START -> < 2190 * | |--SLASH -> / 2191 * | |--BODY_HTML_TAG_NAME -> body 2192 * | `--END -> > 2193 * |--NEWLINE -> \n 2194 * |--LEADING_ASTERISK -> * 2195 * |--TEXT -> / 2196 * |--NEWLINE -> \n 2197 * |--TEXT -> public class Test { 2198 * |--NEWLINE -> \n 2199 * |--TEXT -> } 2200 * |--NEWLINE -> \n 2201 * } 2202 * </pre> 2203 */ 2204 public static final int BODY_TAG_START = JavadocParser.RULE_bodyTagStart + RULE_TYPES_OFFSET; 2205 2206 /** 2207 * End body tag. 2208 * 2209 * <p><b>Example:</b></p> 2210 * <pre>{@code 2211 * <body> 2212 * This is a test 2213 * </body> 2214 * }</pre> 2215 * <b>Tree:</b> 2216 * <pre> 2217 * {@code 2218 * JAVADOC -> JAVADOC 2219 * |--TEXT -> /** 2220 * |--NEWLINE -> \n 2221 * |--LEADING_ASTERISK -> * 2222 * |--TEXT -> 2223 * |--HTML_ELEMENT -> HTML_ELEMENT 2224 * | `--BODY -> BODY 2225 * | |--BODY_TAG_START -> BODY_TAG_START 2226 * | | |--START -> < 2227 * | | |--BODY_HTML_TAG_NAME -> body 2228 * | | `--END -> > 2229 * | |--NEWLINE -> \n 2230 * | |--LEADING_ASTERISK -> * 2231 * | |--TEXT -> This is inside the body tag. 2232 * | |--NEWLINE -> \n 2233 * | |--LEADING_ASTERISK -> * 2234 * | |--TEXT -> 2235 * | `--BODY_TAG_END -> BODY_TAG_END 2236 * | |--START -> < 2237 * | |--SLASH -> / 2238 * | |--BODY_HTML_TAG_NAME -> body 2239 * | `--END -> > 2240 * |--NEWLINE -> \n 2241 * |--LEADING_ASTERISK -> * 2242 * |--TEXT -> / 2243 * |--NEWLINE -> \n 2244 * |--TEXT -> public class Test { 2245 * |--NEWLINE -> \n 2246 * |--TEXT -> } 2247 * |--NEWLINE -> \n 2248 * } 2249 * </pre> 2250 */ 2251 public static final int BODY_TAG_END = JavadocParser.RULE_bodyTagEnd + RULE_TYPES_OFFSET; 2252 2253 /** 2254 * Colgroup html tag. 2255 * 2256 * <p><b>Example:</b></p> 2257 * <pre>{@code 2258 * <colgroup> 2259 * <col /> 2260 * <col span="2" class="batman" /> 2261 * </colgroup> 2262 * }</pre> 2263 * <b>Tree:</b> 2264 * <pre> 2265 * {@code 2266 * --JAVADOC -> JAVADOC 2267 * |--NEWLINE -> \n 2268 * |--LEADING_ASTERISK -> * 2269 * |--TEXT -> 2270 * |--HTML_ELEMENT -> HTML_ELEMENT 2271 * | `--COLGROUP -> COLGROUP 2272 * | |--COLGROUP_TAG_START -> COLGROUP_TAG_START 2273 * | | |--START -> < 2274 * | | |--COLGROUP_HTML_TAG_NAME -> colgroup 2275 * | | | `--END -> > 2276 * | |--NEWLINE -> \n 2277 * | |--LEADING_ASTERISK -> * 2278 * | |--TEXT -> 2279 * | |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2280 * | | `--COL_TAG -> COL_TAG 2281 * | | |--START -> < 2282 * | | |--COL_HTML_TAG_NAME -> col 2283 * | | |--WS -> 2284 * | | `--SLASH_END -> /> 2285 * | |--NEWLINE -> \n 2286 * | |--LEADING_ASTERISK -> * 2287 * | |--TEXT -> 2288 * | |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2289 * | | `--COL_TAG -> COL_TAG 2290 * | | |--START -> < 2291 * | | |--COL_HTML_TAG_NAME -> col 2292 * | | |--WS -> 2293 * | | |--ATTRIBUTE -> ATTRIBUTE 2294 * | | | |--HTML_TAG_NAME -> span 2295 * | | | |--EQUALS -> = 2296 * | | | `--ATTR_VALUE -> "2" 2297 * | | |--WS -> 2298 * | | |--ATTRIBUTE -> ATTRIBUTE 2299 * | | | |--HTML_TAG_NAME -> class 2300 * | | | |--EQUALS -> = 2301 * | | | `--ATTR_VALUE -> "batman" 2302 * | | |--WS -> 2303 * | | `--SLASH_END -> /> 2304 * | |--NEWLINE -> \n 2305 * | |--LEADING_ASTERISK -> * 2306 * | |--TEXT -> 2307 * | `--COLGROUP_TAG_END -> COLGROUP_TAG_END 2308 * | | |--START -> < 2309 * | | |--SLASH -> / 2310 * | | |--COLGROUP_HTML_TAG_NAME -> colgroup 2311 * | | `--END -> > 2312 * |--NEWLINE -> \n 2313 * |--TEXT -> 2314 * } 2315 * </pre> 2316 */ 2317 public static final int COLGROUP = JavadocParser.RULE_colgroup + RULE_TYPES_OFFSET; 2318 /** Start colgroup tag. */ 2319 public static final int COLGROUP_TAG_START = JavadocParser.RULE_colgroupTagStart 2320 + RULE_TYPES_OFFSET; 2321 /** End colgroup tag. */ 2322 public static final int COLGROUP_TAG_END = JavadocParser.RULE_colgroupTagEnd 2323 + RULE_TYPES_OFFSET; 2324 2325 /** Description of a term html tag: {@code <dd></dd>}. */ 2326 public static final int DD = JavadocParser.RULE_dd + RULE_TYPES_OFFSET; 2327 /** Start description of a term tag. */ 2328 public static final int DD_TAG_START = JavadocParser.RULE_ddTagStart + RULE_TYPES_OFFSET; 2329 /** End description of a term tag. */ 2330 public static final int DD_TAG_END = JavadocParser.RULE_ddTagEnd + RULE_TYPES_OFFSET; 2331 2332 /** Description term html tag: {@code <dt></dt>}. */ 2333 public static final int DT = JavadocParser.RULE_dt + RULE_TYPES_OFFSET; 2334 /** Start description term tag. */ 2335 public static final int DT_TAG_START = JavadocParser.RULE_dtTagStart + RULE_TYPES_OFFSET; 2336 /** End description term tag. */ 2337 public static final int DT_TAG_END = JavadocParser.RULE_dtTagEnd + RULE_TYPES_OFFSET; 2338 2339 /** Head html tag. */ 2340 public static final int HEAD = JavadocParser.RULE_head + RULE_TYPES_OFFSET; 2341 /** Start head tag. */ 2342 public static final int HEAD_TAG_START = JavadocParser.RULE_headTagStart + RULE_TYPES_OFFSET; 2343 /** End head tag. */ 2344 public static final int HEAD_TAG_END = JavadocParser.RULE_headTagEnd + RULE_TYPES_OFFSET; 2345 2346 /** Html html tag. */ 2347 public static final int HTML = JavadocParser.RULE_html + RULE_TYPES_OFFSET; 2348 /** Start html tag. */ 2349 public static final int HTML_TAG_START = JavadocParser.RULE_htmlTagStart + RULE_TYPES_OFFSET; 2350 /** End html tag. */ 2351 public static final int HTML_TAG_END = JavadocParser.RULE_htmlTagEnd + RULE_TYPES_OFFSET; 2352 2353 /** Option html tag. */ 2354 public static final int OPTION = JavadocParser.RULE_option + RULE_TYPES_OFFSET; 2355 /** Start option tag. */ 2356 public static final int OPTION_TAG_START = 2357 JavadocParser.RULE_optionTagStart + RULE_TYPES_OFFSET; 2358 /** End option tag. */ 2359 public static final int OPTION_TAG_END = JavadocParser.RULE_optionTagEnd 2360 + RULE_TYPES_OFFSET; 2361 2362 /** 2363 * Table body html tag. 2364 * 2365 * <p><b>Example:</b></p> 2366 * <pre>{@code <table><tbody></tbody></table>}</pre> 2367 * <b>Tree:</b> 2368 * <pre> 2369 * {@code 2370 * JAVADOC -> JAVADOC 2371 * |--NEWLINE -> \r\n 2372 * |--LEADING_ASTERISK -> * 2373 * |--TEXT -> 2374 * |--HTML_ELEMENT -> HTML_ELEMENT 2375 * | `--HTML_TAG -> HTML_TAG 2376 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 2377 * | | |--START -> < 2378 * | | |--HTML_TAG_NAME -> table 2379 * | | `--END -> > 2380 * | |--HTML_ELEMENT -> HTML_ELEMENT 2381 * | | `--TBODY -> TBODY 2382 * | | |--TBODY_TAG_START -> TBODY_TAG_START 2383 * | | | |--START -> < 2384 * | | | |--TBODY_HTML_TAG_NAME -> tbody 2385 * | | | `--END -> > 2386 * | | `--TBODY_TAG_END -> TBODY_TAG_END 2387 * | | |--START -> < 2388 * | | |--SLASH -> / 2389 * | | |--TBODY_HTML_TAG_NAME -> tbody 2390 * | | `--END -> > 2391 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 2392 * | |--START -> < 2393 * | |--SLASH -> / 2394 * | |--HTML_TAG_NAME -> table 2395 * | `--END -> > 2396 * |--NEWLINE -> \r\n 2397 * } 2398 * </pre> 2399 */ 2400 public static final int TBODY = JavadocParser.RULE_tbody + RULE_TYPES_OFFSET; 2401 /** Start table body tag. */ 2402 public static final int TBODY_TAG_START = JavadocParser.RULE_tbodyTagStart + RULE_TYPES_OFFSET; 2403 /** End table body tag. */ 2404 public static final int TBODY_TAG_END = JavadocParser.RULE_tbodyTagEnd + RULE_TYPES_OFFSET; 2405 2406 /** Table foot html tag. */ 2407 public static final int TFOOT = JavadocParser.RULE_tfoot + RULE_TYPES_OFFSET; 2408 /** Start table foot tag. */ 2409 public static final int TFOOT_TAG_START = JavadocParser.RULE_tfootTagStart + RULE_TYPES_OFFSET; 2410 /** End table foot tag. */ 2411 public static final int TFOOT_TAG_END = JavadocParser.RULE_tfootTagEnd + RULE_TYPES_OFFSET; 2412 2413 /** Table head html tag. */ 2414 public static final int THEAD = JavadocParser.RULE_thead + RULE_TYPES_OFFSET; 2415 /** Start table head tag. */ 2416 public static final int THEAD_TAG_START = JavadocParser.RULE_theadTagStart + RULE_TYPES_OFFSET; 2417 /** End table head tag. */ 2418 public static final int THEAD_TAG_END = JavadocParser.RULE_theadTagEnd + RULE_TYPES_OFFSET; 2419 2420 /** `optgroup` html tag. */ 2421 public static final int OPTGROUP = JavadocParser.RULE_optgroup + RULE_TYPES_OFFSET; 2422 /** `optgroup` tag start. */ 2423 public static final int OPTGROUP_TAG_START = 2424 JavadocParser.RULE_optgroupTagStart + RULE_TYPES_OFFSET; 2425 /** `optgroup` tag end. */ 2426 public static final int OPTGROUP_TAG_END = 2427 JavadocParser.RULE_optgroupTagEnd + RULE_TYPES_OFFSET; 2428 2429 /** `rb` html tag. */ 2430 public static final int RB = JavadocParser.RULE_rb + RULE_TYPES_OFFSET; 2431 /** `rb` tag start. */ 2432 public static final int RB_TAG_START = 2433 JavadocParser.RULE_rbTagStart + RULE_TYPES_OFFSET; 2434 /** `rb` tag end. */ 2435 public static final int RB_TAG_END = 2436 JavadocParser.RULE_rbTagEnd + RULE_TYPES_OFFSET; 2437 2438 /** `rt` html tag. */ 2439 public static final int RT = JavadocParser.RULE_rt + RULE_TYPES_OFFSET; 2440 /** `rt` tag start. */ 2441 public static final int RT_TAG_START = 2442 JavadocParser.RULE_rtTagStart + RULE_TYPES_OFFSET; 2443 /** `rt` tag end. */ 2444 public static final int RT_TAG_END = 2445 JavadocParser.RULE_rtTagEnd + RULE_TYPES_OFFSET; 2446 2447 /** `rtc` html tag. */ 2448 public static final int RTC = JavadocParser.RULE_rtc + RULE_TYPES_OFFSET; 2449 /** `rtc` tag start. */ 2450 public static final int RTC_TAG_START = 2451 JavadocParser.RULE_rtcTagStart + RULE_TYPES_OFFSET; 2452 /** `rtc` tag end. */ 2453 public static final int RTC_TAG_END = 2454 JavadocParser.RULE_rtcTagEnd + RULE_TYPES_OFFSET; 2455 2456 /** `rp` html tag. */ 2457 public static final int RP = JavadocParser.RULE_rp + RULE_TYPES_OFFSET; 2458 /** `rp` tag start. */ 2459 public static final int RP_TAG_START = 2460 JavadocParser.RULE_rpTagStart + RULE_TYPES_OFFSET; 2461 /** `rp` tag end. */ 2462 public static final int RP_TAG_END = 2463 JavadocParser.RULE_rpTagEnd + RULE_TYPES_OFFSET; 2464 2465 /////////////////////// SINGLETON HTML TAGS ////////////////////////////////////////////////// 2466 /** 2467 * Parent node for all singleton html tags. 2468 */ 2469 public static final int SINGLETON_ELEMENT = JavadocParser.RULE_singletonElement 2470 + RULE_TYPES_OFFSET; 2471 2472 /** 2473 * Non-special empty html tag. 2474 */ 2475 public static final int EMPTY_TAG = JavadocParser.RULE_emptyTag 2476 + RULE_TYPES_OFFSET; 2477 2478 /** 2479 * Area html tag. 2480 * 2481 * <p><b>Example:</b></p> 2482 * <pre>{@code < area shape="rect" >}</pre> 2483 * <b>Tree:</b> 2484 * <pre> 2485 * {@code 2486 * JAVADOC -> JAVADOC 2487 * |--NEWLINE -> \n 2488 * |--LEADING_ASTERISK -> * 2489 * |--TEXT -> 2490 * |--HTML_ELEMENT -> HTML_ELEMENT 2491 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2492 * | `--AREA_TAG -> AREA_TAG 2493 * | |--START -> < 2494 * | |--AREA_HTML_TAG_NAME -> area 2495 * | |--WS -> 2496 * | |--ATTRIBUTE -> ATTRIBUTE 2497 * | | |--HTML_TAG_NAME -> shape 2498 * | | |--EQUALS -> = 2499 * | | `--ATTR_VALUE -> "rect" 2500 * | `--END -> > 2501 * |--TEXT -> 2502 * |--NEWLINE -> \n 2503 * |--TEXT -> 2504 * } 2505 * </pre> 2506 */ 2507 public static final int AREA_TAG = JavadocParser.RULE_areaTag + RULE_TYPES_OFFSET; 2508 2509 /** Base html tag. */ 2510 public static final int BASE_TAG = JavadocParser.RULE_baseTag + RULE_TYPES_OFFSET; 2511 2512 /** Basefont html tag. */ 2513 public static final int BASEFONT_TAG = JavadocParser.RULE_basefontTag + RULE_TYPES_OFFSET; 2514 2515 /** Br html tag. */ 2516 public static final int BR_TAG = JavadocParser.RULE_brTag + RULE_TYPES_OFFSET; 2517 2518 /** Col html tag. */ 2519 public static final int COL_TAG = JavadocParser.RULE_colTag + RULE_TYPES_OFFSET; 2520 2521 /** Frame html tag. */ 2522 public static final int FRAME_TAG = JavadocParser.RULE_frameTag + RULE_TYPES_OFFSET; 2523 2524 /** Hr html tag. */ 2525 public static final int HR_TAG = JavadocParser.RULE_hrTag + RULE_TYPES_OFFSET; 2526 2527 /** Img html tag. */ 2528 public static final int IMG_TAG = JavadocParser.RULE_imgTag + RULE_TYPES_OFFSET; 2529 2530 /** 2531 * Input html tag. 2532 * 2533 * <p><b>Example:</b></p> 2534 * <pre>{@code Type here: <input type="text" id="id" name="name"> }</pre> 2535 * <b>Tree:</b> 2536 * <pre> 2537 * {@code 2538 * JAVADOC -> JAVADOC 2539 * |--NEWLINE -> \r\n 2540 * |--LEADING_ASTERISK -> * 2541 * |--TEXT -> Type here: 2542 * |--HTML_ELEMENT -> HTML_ELEMENT 2543 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2544 * | `--INPUT_TAG -> INPUT_TAG 2545 * | |--START -> < 2546 * | |--INPUT_HTML_TAG_NAME -> input 2547 * | |--WS -> 2548 * | |--ATTRIBUTE -> ATTRIBUTE 2549 * | | |--HTML_TAG_NAME -> type 2550 * | | |--EQUALS -> = 2551 * | | `--ATTR_VALUE -> "text" 2552 * | |--WS -> 2553 * | |--ATTRIBUTE -> ATTRIBUTE 2554 * | | |--HTML_TAG_NAME -> id 2555 * | | |--EQUALS -> = 2556 * | | `--ATTR_VALUE -> "id" 2557 * | |--WS -> 2558 * | |--ATTRIBUTE -> ATTRIBUTE 2559 * | | |--HTML_TAG_NAME -> name 2560 * | | |--EQUALS -> = 2561 * | | `--ATTR_VALUE -> "name" 2562 * | `--END -> > 2563 * |--NEWLINE -> \r\n 2564 * |--TEXT -> 2565 * } 2566 * </pre> 2567 */ 2568 public static final int INPUT_TAG = JavadocParser.RULE_inputTag + RULE_TYPES_OFFSET; 2569 2570 /** Isindex html tag. */ 2571 public static final int ISINDEX_TAG = JavadocParser.RULE_isindexTag + RULE_TYPES_OFFSET; 2572 2573 /** Link html tag. */ 2574 public static final int LINK_TAG = JavadocParser.RULE_linkTag + RULE_TYPES_OFFSET; 2575 2576 /** Meta html tag. */ 2577 public static final int META_TAG = JavadocParser.RULE_metaTag + RULE_TYPES_OFFSET; 2578 2579 /** Param html tag. */ 2580 public static final int PARAM_TAG = JavadocParser.RULE_paramTag + RULE_TYPES_OFFSET; 2581 2582 /** 2583 * HTML void element {@code <embed>}. 2584 * 2585 * @see #SINGLETON_ELEMENT 2586 * @see <a href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-embed"> 2587 * W3 docs</a> 2588 */ 2589 public static final int EMBED_TAG = JavadocParser.RULE_embedTag + RULE_TYPES_OFFSET; 2590 2591 /** 2592 * HTML void element {@code <keygen>}. 2593 * 2594 * @see #SINGLETON_ELEMENT 2595 * @see <a href="https://www.w3.org/TR/html51/sec-forms.html#elementdef-keygen"> 2596 * W3 docs</a> 2597 */ 2598 public static final int KEYGEN_TAG = JavadocParser.RULE_keygenTag + RULE_TYPES_OFFSET; 2599 2600 /** 2601 * HTML void element {@code <source>}. 2602 * 2603 * @see #SINGLETON_ELEMENT 2604 * @see <a href= 2605 * "https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-media-source"> 2606 * W3 docs</a> 2607 */ 2608 public static final int SOURCE_TAG = JavadocParser.RULE_sourceTag + RULE_TYPES_OFFSET; 2609 2610 /** 2611 * HTML void element {@code <track>}. 2612 * 2613 * @see #SINGLETON_ELEMENT 2614 * @see <a 2615 * href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-track"> 2616 * W3 docs</a> 2617 */ 2618 public static final int TRACK_TAG = JavadocParser.RULE_trackTag + RULE_TYPES_OFFSET; 2619 2620 /** 2621 * HTML void element {@code <wbr>}. 2622 * 2623 * @see #SINGLETON_ELEMENT 2624 * @see <a href="https://www.w3.org/TR/html51/textlevel-semantics.html#elementdef-wbr"> 2625 * W3 docs</a> 2626 */ 2627 public static final int WBR_TAG = JavadocParser.RULE_wbrTag + RULE_TYPES_OFFSET; 2628 2629 /////////////////////////////////////////////////////////////////////////////////////////////// 2630 2631 /** 2632 * Html comment: <code><!-- --></code>. 2633 * 2634 * @noinspection HtmlTagCanBeJavadocTag 2635 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 2636 * replaced with Javadoc tag 2637 */ 2638 public static final int HTML_COMMENT = JavadocParser.RULE_htmlComment 2639 + RULE_TYPES_OFFSET; 2640 /** 2641 * CHAR and WS sequence. 2642 */ 2643 public static final int TEXT = JavadocParser.RULE_text + RULE_TYPES_OFFSET; 2644 2645 /** Empty private constructor of the current class. */ 2646 private JavadocTokenTypes() { 2647 } 2648 2649}