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 /** 1308 * Table header cell tag name. 1309 * 1310 * <p><b>Example:</b></p> 1311 * <pre>{@code 1312 * <tr> 1313 * <th>Table Head</th> 1314 * </tr> 1315 * }</pre> 1316 * <b>Tree:</b> 1317 * <pre> 1318 * {@code 1319 * HTML_ELEMENT -> HTML_ELEMENT 1320 * `--TR -> TR 1321 * |--TR_TAG_START -> TR_TAG_START 1322 * | |--START -> < 1323 * | |--TR_HTML_TAG_NAME -> tr 1324 * | `--END -> > 1325 * |--NEWLINE -> \r\n 1326 * |--LEADING_ASTERISK -> * 1327 * |--TEXT -> 1328 * |--TH -> TH 1329 * | |--TH_TAG_START -> TH_TAG_START 1330 * | | |--START -> < 1331 * | | |--TH_HTML_TAG_NAME -> th 1332 * | | `--END -> > 1333 * | |--TEXT -> Table Head 1334 * | `--TH_TAG_END -> TH_TAG_END 1335 * | |--START -> < 1336 * | |--SLASH -> / 1337 * | |--TH_HTML_TAG_NAME -> th 1338 * | `--END -> > 1339 * |--NEWLINE -> \r\n 1340 * |--LEADING_ASTERISK -> * 1341 * |--TEXT -> 1342 * `--TR_TAG_END -> TR_TAG_END 1343 * |--START -> < 1344 * |--SLASH -> / 1345 * |--TR_HTML_TAG_NAME -> tr 1346 * `--END -> > 1347 * } 1348 * </pre> 1349 * 1350 * @see 1351 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1352 * comments are written in HTML</a> 1353 * @see #TH_HTML_TAG_NAME 1354 */ 1355 public static final int TH_HTML_TAG_NAME = JavadocParser.TH_HTML_TAG_NAME; 1356 1357 /** Body tag name. */ 1358 public static final int BODY_HTML_TAG_NAME = JavadocParser.BODY_HTML_TAG_NAME; 1359 1360 /** 1361 * Colgroup tag name. 1362 * 1363 * <p><b>Example:</b></p> 1364 * <pre>{@code <colgroup><col span="2"></colgroup>}</pre> 1365 * <b>Tree:</b> 1366 * <pre> 1367 * {@code 1368 * |--HTML_ELEMENT -> HTML_ELEMENT 1369 * | `--COLGROUP -> COLGROUP 1370 * | |--COLGROUP_TAG_START -> COLGROUP_TAG_START 1371 * | | |--START -> < 1372 * | | |--COLGROUP_HTML_TAG_NAME -> colgroup 1373 * | | `--END -> > 1374 * | |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1375 * | | `--COL_TAG -> COL_TAG 1376 * | | |--START -> < 1377 * | | |--COL_HTML_TAG_NAME -> col 1378 * | | |--WS -> 1379 * | | |--ATTRIBUTE -> ATTRIBUTE 1380 * | | | |--HTML_TAG_NAME -> span 1381 * | | | |--EQUALS -> = 1382 * | | | `--ATTR_VALUE -> "2" 1383 * | | `--END -> > 1384 * | `--COLGROUP_TAG_END -> COLGROUP_TAG_END 1385 * | |--START -> < 1386 * | |--SLASH -> / 1387 * | |--COLGROUP_HTML_TAG_NAME -> colgroup 1388 * | `--END -> > 1389 * |--TEXT -> 1390 * `--EOF -> <EOF> 1391 * } 1392 * </pre> 1393 * 1394 * @see #COLGROUP_HTML_TAG_NAME 1395 */ 1396 public static final int COLGROUP_HTML_TAG_NAME = JavadocParser.COLGROUP_HTML_TAG_NAME; 1397 1398 /** 1399 * Description of a term tag name. 1400 * 1401 * <p><b>Example:</b></p> 1402 * <pre>{@code 1403 * <dl> 1404 * <dt>Java</dt> 1405 * <dd>A high-level programming language.</dd> 1406 * </dl> 1407 * }</pre> 1408 * <b>Tree:</b> 1409 * <pre> 1410 * {@code 1411 * HTML_ELEMENT -> HTML_ELEMENT 1412 * `--HTML_TAG -> HTML_TAG 1413 * |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1414 * | |--START -> < 1415 * | |--HTML_TAG_NAME -> dl 1416 * | `--END -> > 1417 * |--NEWLINE -> \r\n 1418 * |--LEADING_ASTERISK -> * 1419 * |--TEXT -> 1420 * |--HTML_ELEMENT -> HTML_ELEMENT 1421 * | `--DT -> DT 1422 * | |--DT_TAG_START -> DT_TAG_START 1423 * | | |--START -> < 1424 * | | |--DT_HTML_TAG_NAME -> dt 1425 * | | `--END -> > 1426 * | |--TEXT -> Java 1427 * | `--DT_TAG_END -> DT_TAG_END 1428 * | |--START -> < 1429 * | |--SLASH -> / 1430 * | |--DT_HTML_TAG_NAME -> dt 1431 * | `--END -> > 1432 * |--NEWLINE -> \r\n 1433 * |--LEADING_ASTERISK -> * 1434 * |--TEXT -> 1435 * |--HTML_ELEMENT -> HTML_ELEMENT 1436 * | `--DD -> DD 1437 * | |--DD_TAG_START -> DD_TAG_START 1438 * | | |--START -> < 1439 * | | |--DD_HTML_TAG_NAME -> dd 1440 * | | `--END -> > 1441 * | |--TEXT -> A high-level programming language. 1442 * | `--DD_TAG_END -> DD_TAG_END 1443 * | |--START -> < 1444 * | |--SLASH -> / 1445 * | |--DD_HTML_TAG_NAME -> dd 1446 * | `--END -> > 1447 * |--NEWLINE -> \r\n 1448 * |--LEADING_ASTERISK -> * 1449 * |--TEXT -> 1450 * `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1451 * |--START -> < 1452 * |--SLASH -> / 1453 * |--HTML_TAG_NAME -> dl 1454 * `--END -> > 1455 * } 1456 * </pre> 1457 * 1458 * @see #DD_HTML_TAG_NAME 1459 */ 1460 public static final int DD_HTML_TAG_NAME = JavadocParser.DD_HTML_TAG_NAME; 1461 1462 /** 1463 * Description term tag name. 1464 * 1465 * <p><b>Example:</b></p> 1466 * <pre>{@code 1467 * <dl> 1468 * <dt>Java</dt> 1469 * </dl> 1470 * }</pre> 1471 * <b>Tree:</b> 1472 * <pre> 1473 * {@code 1474 * HTML_ELEMENT -> HTML_ELEMENT 1475 * `--HTML_TAG -> HTML_TAG 1476 * |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1477 * | |--START -> < 1478 * | |--HTML_TAG_NAME -> dl 1479 * | `--END -> > 1480 * |--NEWLINE -> \r\n 1481 * |--LEADING_ASTERISK -> * 1482 * |--TEXT -> 1483 * |--HTML_ELEMENT -> HTML_ELEMENT 1484 * | `--DT -> DT 1485 * | |--DT_TAG_START -> DT_TAG_START 1486 * | | |--START -> < 1487 * | | |--DT_HTML_TAG_NAME -> dt 1488 * | | `--END -> > 1489 * | |--TEXT -> Java 1490 * | `--DT_TAG_END -> DT_TAG_END 1491 * | |--START -> < 1492 * | |--SLASH -> / 1493 * | |--DT_HTML_TAG_NAME -> dt 1494 * | `--END -> > 1495 * |--NEWLINE -> \r\n 1496 * |--LEADING_ASTERISK -> * 1497 * |--TEXT -> 1498 * `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1499 * |--START -> < 1500 * |--SLASH -> / 1501 * |--HTML_TAG_NAME -> dl 1502 * `--END -> > 1503 * } 1504 * </pre> 1505 * 1506 * @see #DT_HTML_TAG_NAME 1507 */ 1508 public static final int DT_HTML_TAG_NAME = JavadocParser.DT_HTML_TAG_NAME; 1509 1510 /** Head tag name. */ 1511 public static final int HEAD_HTML_TAG_NAME = JavadocParser.HEAD_HTML_TAG_NAME; 1512 1513 /** Html tag name. */ 1514 public static final int HTML_HTML_TAG_NAME = JavadocParser.HTML_HTML_TAG_NAME; 1515 1516 /** Option tag name. */ 1517 public static final int OPTION_HTML_TAG_NAME = JavadocParser.OPTION_HTML_TAG_NAME; 1518 1519 /** Table body tag name. */ 1520 public static final int TBODY_HTML_TAG_NAME = JavadocParser.TBODY_HTML_TAG_NAME; 1521 1522 /** Table foot tag name. */ 1523 public static final int TFOOT_HTML_TAG_NAME = JavadocParser.TFOOT_HTML_TAG_NAME; 1524 1525 /** Table head tag name. */ 1526 public static final int THEAD_HTML_TAG_NAME = JavadocParser.THEAD_HTML_TAG_NAME; 1527 1528 /** `optgroup` tag name. */ 1529 public static final int OPTGROUP_HTML_TAG_NAME = JavadocParser.OPTGROUP_HTML_TAG_NAME; 1530 1531 /** `rb` tag name. */ 1532 public static final int RB_HTML_TAG_NAME = JavadocParser.RB_HTML_TAG_NAME; 1533 1534 /** `rt` tag name. */ 1535 public static final int RT_HTML_TAG_NAME = JavadocParser.RT_HTML_TAG_NAME; 1536 1537 /** `rtc` tag name. */ 1538 public static final int RTC_HTML_TAG_NAME = JavadocParser.RTC_HTML_TAG_NAME; 1539 1540 /** `rp` tag name. */ 1541 public static final int RP_HTML_TAG_NAME = JavadocParser.RP_HTML_TAG_NAME; 1542 /////////////////////////////////////////////////////////////////////////////////////////////// 1543 1544 /////////////////////// SINGLETON HTML TAGS ////////////////////////////////////////////////// 1545 /** 1546 * Area tag name. 1547 * 1548 * <p><b>Example:</b></p> 1549 * <pre>{@code < area shape="rect" >}</pre> 1550 * <b>Tree:</b> 1551 * <pre> 1552 * {@code 1553 * JAVADOC -> JAVADOC 1554 * |--NEWLINE -> \n 1555 * |--LEADING_ASTERISK -> * 1556 * |--TEXT -> 1557 * |--HTML_ELEMENT -> HTML_ELEMENT 1558 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1559 * | `--AREA_TAG -> AREA_TAG 1560 * | |--START -> < 1561 * | |--AREA_HTML_TAG_NAME -> area 1562 * | |--WS -> 1563 * | |--ATTRIBUTE -> ATTRIBUTE 1564 * | | |--HTML_TAG_NAME -> shape 1565 * | | |--EQUALS -> = 1566 * | | `--ATTR_VALUE -> "rect" 1567 * | `--END -> > 1568 * |--TEXT -> 1569 * |--NEWLINE -> \n 1570 * |--TEXT -> 1571 * } 1572 * </pre> 1573 */ 1574 1575 public static final int AREA_HTML_TAG_NAME = JavadocParser.AREA_HTML_TAG_NAME; 1576 1577 /** Base tag name. */ 1578 public static final int BASE_HTML_TAG_NAME = JavadocParser.BASE_HTML_TAG_NAME; 1579 1580 /** Basefont tag name. */ 1581 public static final int BASEFONT_HTML_TAG_NAME = JavadocParser.BASEFONT_HTML_TAG_NAME; 1582 1583 /** 1584 * Br tag name. 1585 * 1586 * <p><b>Example:</b></p> 1587 * <pre>{@code text before break < br > text after break}</pre> 1588 * <b>Tree:</b> 1589 * <pre> 1590 * {@code 1591 * `--JAVADOC -> JAVADOC 1592 * |--NEWLINE -> \r\n 1593 * |--LEADING_ASTERISK -> * 1594 * |--TEXT -> text before break 1595 * |--HTML_ELEMENT -> HTML_ELEMENT 1596 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1597 * | `--BR_TAG -> BR_TAG 1598 * | |--START -> < 1599 * | |--BR_HTML_TAG_NAME -> br 1600 * | `--END -> > 1601 * |--TEXT -> text after break 1602 * |--NEWLINE -> \r\n 1603 * |--TEXT -> 1604 * } 1605 * </pre> 1606 */ 1607 1608 public static final int BR_HTML_TAG_NAME = JavadocParser.BR_HTML_TAG_NAME; 1609 1610 /** Col tag name. */ 1611 public static final int COL_HTML_TAG_NAME = JavadocParser.COL_HTML_TAG_NAME; 1612 1613 /** Frame tag name. */ 1614 public static final int FRAME_HTML_TAG_NAME = JavadocParser.FRAME_HTML_TAG_NAME; 1615 1616 /** 1617 * Hr tag name. 1618 * 1619 * <p><b>Example:</b></p> 1620 * <pre>{@code text before horizontal rule < hr > text after horizontal rule}</pre> 1621 * <b>Tree:</b> 1622 * <pre> 1623 * {@code 1624 * |--TEXT -> text before horizontal rule 1625 * |--HTML_ELEMENT -> HTML_ELEMENT 1626 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1627 * | `--HR_TAG -> HR_TAG 1628 * | |--START -> < 1629 * | |--HR_HTML_TAG_NAME -> hr 1630 * | `--END -> > 1631 * |--TEXT -> text after horizontal rule 1632 * |--NEWLINE -> \r\n 1633 * } 1634 * </pre> 1635 */ 1636 1637 public static final int HR_HTML_TAG_NAME = JavadocParser.HR_HTML_TAG_NAME; 1638 1639 /** Img tag name. */ 1640 public static final int IMG_HTML_TAG_NAME = JavadocParser.IMG_HTML_TAG_NAME; 1641 1642 /** 1643 * Input tag name. 1644 * 1645 * <p><b>Example:</b></p> 1646 * <pre>{@code <input name="Name" type="text" placeholder="Enter your name"/>}</pre> 1647 * <b>Tree:</b> 1648 * <pre> 1649 * {@code 1650 * HTML_ELEMENT -> HTML_ELEMENT 1651 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1652 * `--INPUT_TAG -> INPUT_TAG 1653 * |--START -> < 1654 * |--INPUT_HTML_TAG_NAME -> input 1655 * |--WS -> 1656 * |--ATTRIBUTE -> ATTRIBUTE 1657 * | |--HTML_TAG_NAME -> name 1658 * | |--EQUALS -> = 1659 * | `--ATTR_VALUE -> "Name" 1660 * |--WS -> 1661 * |--ATTRIBUTE -> ATTRIBUTE 1662 * | |--HTML_TAG_NAME -> type 1663 * | |--EQUALS -> = 1664 * | `--ATTR_VALUE -> "text" 1665 * |--WS -> 1666 * |--ATTRIBUTE -> ATTRIBUTE 1667 * | |--HTML_TAG_NAME -> placeholder 1668 * | |--EQUALS -> = 1669 * | `--ATTR_VALUE -> "Enter your name" 1670 * `--SLASH_END -> /> 1671 * } 1672 * </pre> 1673 * 1674 * @see 1675 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1676 * comments are written in HTML</a> 1677 * @see #INPUT_HTML_TAG_NAME 1678 */ 1679 public static final int INPUT_HTML_TAG_NAME = JavadocParser.INPUT_HTML_TAG_NAME; 1680 1681 /** Isindex tag name. */ 1682 public static final int ISINDEX_HTML_TAG_NAME = JavadocParser.ISINDEX_HTML_TAG_NAME; 1683 1684 /** 1685 * Link tag name. 1686 * 1687 * <p><b>Example:</b></p> 1688 * <pre>{@code <link rel="stylesheet" href="Style.css">}</pre> 1689 * <b>Tree:</b> 1690 * <pre> 1691 * {@code 1692 * HTML_ELEMENT -> HTML_ELEMENT 1693 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1694 * `--LINK_TAG -> LINK_TAG 1695 * |--START -> < 1696 * |--LINK_HTML_TAG_NAME -> link 1697 * |--WS -> 1698 * |--ATTRIBUTE -> ATTRIBUTE 1699 * | |--HTML_TAG_NAME -> rel 1700 * | |--EQUALS -> = 1701 * | `--ATTR_VALUE -> "stylesheet" 1702 * |--WS -> 1703 * |--ATTRIBUTE -> ATTRIBUTE 1704 * | |--HTML_TAG_NAME -> href 1705 * | |--EQUALS -> = 1706 * | `--ATTR_VALUE -> "Style.css" 1707 * `--END -> > 1708 * } 1709 * </pre> 1710 * 1711 * @see 1712 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1713 * comments are written in HTML</a> 1714 * @see #LINK_HTML_TAG_NAME 1715 */ 1716 public static final int LINK_HTML_TAG_NAME = JavadocParser.LINK_HTML_TAG_NAME; 1717 1718 /** Meta tag name. */ 1719 public static final int META_HTML_TAG_NAME = JavadocParser.META_HTML_TAG_NAME; 1720 1721 /** Param tag name. */ 1722 public static final int PARAM_HTML_TAG_NAME = JavadocParser.PARAM_HTML_TAG_NAME; 1723 /** "embed" tag name. */ 1724 public static final int EMBED_HTML_TAG_NAME = JavadocParser.EMBED_HTML_TAG_NAME; 1725 /** "keygen" tag name. */ 1726 public static final int KEYGEN_HTML_TAG_NAME = JavadocParser.KEYGEN_HTML_TAG_NAME; 1727 /** "source" tag name. */ 1728 public static final int SOURCE_HTML_TAG_NAME = JavadocParser.SOURCE_HTML_TAG_NAME; 1729 /** "track" tag name. */ 1730 public static final int TRACK_HTML_TAG_NAME = JavadocParser.TRACK_HTML_TAG_NAME; 1731 /** "wbr" tag name. */ 1732 public static final int WBR_HTML_TAG_NAME = JavadocParser.WBR_HTML_TAG_NAME; 1733 /////////////////////////////////////////////////////////////////////////////////////////////// 1734 1735 /** 1736 * HTML comment start symbol '<!--'. 1737 * 1738 * <p><b>Example:</b></p> 1739 * <pre>{@code 1740 * <!-- 1741 * This is an HTML multi-line comment: 1742 * This is another comment 1743 * --> 1744 * }</pre> 1745 * <b>Tree:</b> 1746 * <pre> 1747 * {@code 1748 * HTML_COMMENT -> HTML_COMMENT 1749 * |--HTML_COMMENT_START -> <!-- 1750 * |--NEWLINE -> \n 1751 * |--LEADING_ASTERISK -> * 1752 * |--TEXT -> This is an HTML multi-line comment: 1753 * |--NEWLINE -> \n 1754 * |--LEADING_ASTERISK -> * 1755 * |--TEXT -> This is another comment 1756 * |--NEWLINE -> \n 1757 * |--LEADING_ASTERISK -> * 1758 * |--TEXT -> 1759 * `--HTML_COMMENT_END -> --> 1760 * } 1761 * </pre> 1762 */ 1763 public static final int HTML_COMMENT_START = JavadocParser.HTML_COMMENT_START; 1764 1765 /** 1766 * HTML comment end symbol '-->'. 1767 * 1768 * <p><b>Example:</b></p> 1769 * <pre>{@code 1770 * <!-- 1771 * This is an HTML multi-line comment: 1772 * This is another comment 1773 * --> 1774 * }</pre> 1775 * <b>Tree:</b> 1776 * <pre> 1777 * {@code 1778 * HTML_COMMENT -> HTML_COMMENT 1779 * |--HTML_COMMENT_START -> <!-- 1780 * |--NEWLINE -> \n 1781 * |--LEADING_ASTERISK -> * 1782 * |--TEXT -> This is an HTML multi-line comment: 1783 * |--NEWLINE -> \n 1784 * |--LEADING_ASTERISK -> * 1785 * |--TEXT -> This is another comment 1786 * |--NEWLINE -> \n 1787 * |--LEADING_ASTERISK -> * 1788 * |--TEXT -> 1789 * `--HTML_COMMENT_END -> --> 1790 * } 1791 * </pre> 1792 */ 1793 public static final int HTML_COMMENT_END = JavadocParser.HTML_COMMENT_END; 1794 1795 // ------------------------------------------------------------------------------------------ // 1796 // ----------------- OTHER -------------------------------------------------- // 1797 // ------------------------------------------------------------------------------------------ // 1798 1799 /** Leading asterisk. */ 1800 public static final int LEADING_ASTERISK = JavadocParser.LEADING_ASTERISK; 1801 1802 /** 1803 * Newline symbol - '\n'. 1804 */ 1805 public static final int NEWLINE = JavadocParser.NEWLINE; 1806 1807 /** 1808 * Any other symbol. 1809 */ 1810 public static final int CHAR = JavadocParser.CHAR; 1811 1812 /** 1813 * Whitespace or tab ('\t') symbol. 1814 */ 1815 public static final int WS = JavadocParser.WS; 1816 1817 /** 1818 * End Of File symbol. Copied from 1819 * {@link org.antlr.v4.runtime.Recognizer#EOF} to avoid ANTLR dependency in 1820 * API. 1821 */ 1822 public static final int EOF = -1; 1823 1824 // ------------------------------------------------------------------------------------------ // 1825 // ------ JAVADOC TAGS DEPENDING ON RULE TYPES OFFSET --------------------------------------- // 1826 // ------------------------------------------------------------------------------------------ // 1827 1828 /** 1829 * Rule types offset. 1830 * RULE_TYPES_OFFSET constant is used to split lexer tokens types and parser rules types. 1831 * We need unique numbers for all tokens, 1832 * ANTLR do not need this and that is why these types are mixed by used values. 1833 * All values we can take a look at 1834 * target/generated-sources/antlr/com/puppycrawl/tools/checkstyle/grammar/javadoc/JavadocParser.java 1835 * For example: LEADING_ASTERISK=1 and RULE_htmlElement = 1. 1836 * RULE_TYPES_OFFSET required to shift parser rules, 1837 * to let them not overlap with types that have prefix "RULE_". 1838 */ 1839 private static final int RULE_TYPES_OFFSET = 10000; 1840 1841 /** 1842 * Root node of any Javadoc comment. 1843 * Last child is always {@link #EOF}. 1844 * 1845 * <p><b>Tree for example:</b></p> 1846 * <pre>{@code 1847 * JAVADOC -> JAVADOC 1848 * |--NEWLINE -> \n 1849 * |--LEADING_ASTERISK -> * 1850 * |--WS -> 1851 * |--JAVADOC_TAG -> JAVADOC_TAG 1852 * | |--PARAM_LITERAL -> @param 1853 * | |--WS -> 1854 * | |--PARAMETER_NAME -> T 1855 * | |--WS -> 1856 * | `--DESCRIPTION -> DESCRIPTION 1857 * | |--TEXT -> The bar. 1858 * | |--NEWLINE -> \n 1859 * | `--TEXT -> 1860 * `--EOF -> <EOF> 1861 * }</pre> 1862 */ 1863 public static final int JAVADOC = JavadocParser.RULE_javadoc + RULE_TYPES_OFFSET; 1864 1865 /** 1866 * Javadoc tag. 1867 * 1868 * <p>Type of Javadoc tag is resolved by literal node that is first child of this node.</p> 1869 * 1870 * <p>As literal could be:</p> 1871 * <ul> 1872 * <li>{@link #RETURN_LITERAL}</li> 1873 * <li>{@link #DEPRECATED_LITERAL}</li> 1874 * <li>{@link #SINCE_LITERAL}</li> 1875 * <li>{@link #SERIAL_DATA_LITERAL}</li> 1876 * <li>{@link #SERIAL_FIELD_LITERAL}</li> 1877 * <li>{@link #PARAM_LITERAL}</li> 1878 * <li>{@link #SEE_LITERAL}</li> 1879 * <li>{@link #SERIAL_LITERAL}</li> 1880 * <li>{@link #VERSION_LITERAL}</li> 1881 * <li>{@link #EXCEPTION_LITERAL}</li> 1882 * <li>{@link #THROWS_LITERAL}</li> 1883 * <li>{@link #AUTHOR_LITERAL}</li> 1884 * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc tag.</li> 1885 * </ul> 1886 * 1887 * <p><b>Example</b></p> 1888 * <pre>{@code @param T The bar.}</pre> 1889 * <b>Tree</b> 1890 * <pre>{@code 1891 * JAVADOC_TAG -> JAVADOC_TAG 1892 * |--PARAM_LITERAL -> @param 1893 * |--WS -> 1894 * |--PARAMETER_NAME -> T 1895 * |--WS -> 1896 * `--DESCRIPTION -> DESCRIPTION 1897 * |--TEXT -> The bar. 1898 * |--NEWLINE -> \r\n 1899 * `--TEXT -> 1900 * }</pre> 1901 */ 1902 1903 public static final int JAVADOC_TAG = JavadocParser.RULE_javadocTag + RULE_TYPES_OFFSET; 1904 /** 1905 * Javadoc inline tag. 1906 * 1907 * <p>Type of Javadoc inline tag is resolved by literal node that is second child of this node. 1908 * First child is always {@link #JAVADOC_INLINE_TAG_START} and last node is always 1909 * {@link #JAVADOC_INLINE_TAG_END}.</p> 1910 * 1911 * <p>As literal could be:</p> 1912 * <ul> 1913 * <li>{@link #CODE_LITERAL}</li> 1914 * <li>{@link #DOC_ROOT_LITERAL}</li> 1915 * <li>{@link #LINK_LITERAL}</li> 1916 * <li>{@link #INHERIT_DOC_LITERAL}</li> 1917 * <li>{@link #LINKPLAIN_LITERAL}</li> 1918 * <li>{@link #LITERAL_LITERAL}</li> 1919 * <li>{@link #VALUE_LITERAL}</li> 1920 * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc inline tag.</li> 1921 * </ul> 1922 * 1923 * <p><b>Example:</b></p> 1924 * <pre><code>{@link String}</code></pre> 1925 * <b>Tree:</b> 1926 * <pre> 1927 * {@code 1928 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 1929 * |--JAVADOC_INLINE_TAG_START -> { 1930 * |--LINK_LITERAL -> @link 1931 * |--WS -> 1932 * |--REFERENCE -> REFERENCE 1933 * `--PACKAGE_CLASS -> String 1934 * `--JAVADOC_INLINE_TAG_END -> } 1935 * } 1936 * </pre> 1937 * 1938 * @noinspection HtmlTagCanBeJavadocTag 1939 * @noinspection HtmlTagCanBeJavadocTag 1940 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 1941 * replaced with Javadoc tag 1942 */ 1943 public static final int JAVADOC_INLINE_TAG = JavadocParser.RULE_javadocInlineTag 1944 + RULE_TYPES_OFFSET; 1945 1946 /** 1947 * Parameter of the Javadoc tags listed below. 1948 * <ul> 1949 * <li>{@link #SEE_LITERAL @see}</li> 1950 * <li>{@link #LINK_LITERAL {@link}}</li> 1951 * <li>{@link #LINKPLAIN_LITERAL {@linkplain}}</li> 1952 * <li>{@link #VALUE_LITERAL {@value}}</li> 1953 * </ul> 1954 */ 1955 public static final int REFERENCE = JavadocParser.RULE_reference + RULE_TYPES_OFFSET; 1956 1957 /** 1958 * Parameters part in {@link #REFERENCE}. 1959 * It is used to specify parameters for {@link #MEMBER method}. 1960 * Always contains {@link #LEFT_BRACE} as first child and {@link #RIGHT_BRACE} as last child. 1961 * Each parameter is represented by {@link #ARGUMENT} node. 1962 * Arguments in braces are separated by {@link #COMMA} (and optional {@link #WS}). 1963 * 1964 * <p><b>Example:</b></p> 1965 * <pre>{@code @see #method(Processor, String)}</pre> 1966 * <b>Tree:</b> 1967 * <pre> 1968 * {@code 1969 * JAVADOC_TAG -> JAVADOC_TAG 1970 * |--SEE_LITERAL -> @see 1971 * |--WS -> 1972 * |--REFERENCE -> REFERENCE 1973 * |--HASH -> # 1974 * |--MEMBER -> method 1975 * `--PARAMETERS -> PARAMETERS 1976 * |--LEFT_BRACE -> ( 1977 * |--ARGUMENT -> Processor 1978 * |--COMMA -> , 1979 * |--WS -> 1980 * |--ARGUMENT -> String 1981 * `--RIGHT_BRACE -> ) 1982 * } 1983 * </pre> 1984 */ 1985 public static final int PARAMETERS = JavadocParser.RULE_parameters + RULE_TYPES_OFFSET; 1986 1987 /** 1988 * Description node. It contains: 1989 * <ul> 1990 * <li>{@link #TEXT}</li> 1991 * <li>{@link #WS}</li> 1992 * <li>{@link #NEWLINE}</li> 1993 * <li>{@link #HTML_ELEMENT}</li> 1994 * </ul> 1995 * 1996 * <p>It is argument for many Javadoc tags and inline tags.</p> 1997 * 1998 * <p><b>Example:</b></p> 1999 * <pre>{@code @throws IOException if <b>connection</b> problems occur}</pre> 2000 * <b>Tree:</b> 2001 * <pre> 2002 * {@code 2003 * --JAVADOC_TAG -> JAVADOC_TAG 2004 * |--THROWS_LITERAL -> @throws 2005 * |--WS -> 2006 * |--CLASS_NAME -> IOException 2007 * |--WS -> 2008 * `--DESCRIPTION -> DESCRIPTION 2009 * |--TEXT -> if 2010 * |--HTML_ELEMENT -> HTML_ELEMENT 2011 * | `--HTML_TAG -> HTML_TAG 2012 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 2013 * | | |--START -> < 2014 * | | |--HTML_TAG_NAME -> b 2015 * | | `--END -> > 2016 * | |--TEXT -> connection 2017 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 2018 * | |--START -> < 2019 * | |--SLASH -> / 2020 * | |--HTML_TAG_NAME -> b 2021 * | `--END -> > 2022 * |--TEXT -> problems occur 2023 * } 2024 * </pre> 2025 */ 2026 public static final int DESCRIPTION = JavadocParser.RULE_description + RULE_TYPES_OFFSET; 2027 2028 // ------------------------------------------------------------------------------------------ // 2029 // -------- HTML TAGS DEPENDING ON RULE TYPES OFFSET ---------------------------------------- // 2030 // ------------------------------------------------------------------------------------------ // 2031 2032 /** 2033 * Parent node for all html tags. 2034 */ 2035 public static final int HTML_ELEMENT = JavadocParser.RULE_htmlElement 2036 + RULE_TYPES_OFFSET; 2037 2038 /** 2039 * Start html tag: <XXXX>. 2040 */ 2041 public static final int HTML_ELEMENT_START = JavadocParser.RULE_htmlElementStart 2042 + RULE_TYPES_OFFSET; 2043 2044 /** 2045 * End html tag: <XXXX>. 2046 */ 2047 public static final int HTML_ELEMENT_END = JavadocParser.RULE_htmlElementEnd 2048 + RULE_TYPES_OFFSET; 2049 2050 /** 2051 * Non-special HTML tag. 2052 */ 2053 public static final int HTML_TAG = JavadocParser.RULE_htmlTag + RULE_TYPES_OFFSET; 2054 2055 /** 2056 * Html tag attribute. Parent node for: {@code HTML_TAG_IDENT, EQUALS, ATTR_VALUE}. 2057 * 2058 * <p><b>Example</b></p> 2059 * <pre>{@code <p class="highlight">Sample text</p>}</pre> 2060 * <b>Tree</b> 2061 * <pre> 2062 * {@code 2063 * HTML_ELEMENT -> HTML_ELEMENT 2064 * `--PARAGRAPH -> PARAGRAPH 2065 * |--P_TAG_START -> P_TAG_START 2066 * | |--START -> < 2067 * | |--P_HTML_TAG_NAME -> p 2068 * | |--WS -> 2069 * | |--ATTRIBUTE -> ATTRIBUTE 2070 * | | |--HTML_TAG_NAME -> class 2071 * | | |--EQUALS -> = 2072 * | | `--ATTR_VALUE -> "highlight" 2073 * | `--END -> > 2074 * |--TEXT -> Sample text 2075 * `--P_TAG_END -> P_TAG_END 2076 * |--START -> < 2077 * |--SLASH -> / 2078 * |--P_HTML_TAG_NAME -> p 2079 * `--END -> > 2080 * } 2081 * </pre> 2082 */ 2083 public static final int ATTRIBUTE = JavadocParser.RULE_attribute 2084 + RULE_TYPES_OFFSET; 2085 2086 /////////////////////// HTML TAGS WITH OPTIONAL END TAG ///////////////////////////////////// 2087 /** 2088 * Paragraph html tag. 2089 * 2090 * <p><b>Example:</b></p> 2091 * <pre>{@code <p>Sample text</p>}</pre> 2092 * <b>Tree:</b> 2093 * <pre> 2094 * {@code 2095 * `--JAVADOC -> JAVADOC 2096 * |--NEWLINE -> \r\n 2097 * |--LEADING_ASTERISK -> * 2098 * |--TEXT -> 2099 * |--HTML_ELEMENT -> HTML_ELEMENT 2100 * | `--PARAGRAPH -> PARAGRAPH 2101 * | |--P_TAG_START -> P_TAG_START 2102 * | | |--START -> < 2103 * | | |--P_HTML_TAG_NAME -> p 2104 * | | `--END -> > 2105 * | |--TEXT -> Sample text 2106 * | `--P_TAG_END -> P_TAG_END 2107 * | |--START -> < 2108 * | |--SLASH -> / 2109 * | |--P_HTML_TAG_NAME -> p 2110 * | `--END -> > 2111 * |--NEWLINE -> \r\n 2112 * |--TEXT -> 2113 * } 2114 * </pre> 2115 */ 2116 public static final int PARAGRAPH = JavadocParser.RULE_paragraph + RULE_TYPES_OFFSET; 2117 /** Start paragraph tag. */ 2118 public static final int P_TAG_START = JavadocParser.RULE_pTagStart + RULE_TYPES_OFFSET; 2119 /** End paragraph tag. */ 2120 public static final int P_TAG_END = JavadocParser.RULE_pTagEnd + RULE_TYPES_OFFSET; 2121 2122 /** 2123 * List items html tag. 2124 * 2125 * <p><b>Example:</b></p> 2126 * <pre>{@code 2127 * <ul> 2128 * <li>Item 1</li> 2129 * </ul> 2130 * }</pre> 2131 * <b>Tree:</b> 2132 * <pre> 2133 * {@code 2134 * --JAVADOC -> JAVADOC 2135 * |--NEWLINE -> \n 2136 * |--LEADING_ASTERISK -> * 2137 * |--TEXT -> 2138 * |--HTML_ELEMENT -> HTML_ELEMENT 2139 * | `--HTML_TAG -> HTML_TAG 2140 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 2141 * | | |--START -> < 2142 * | | |--HTML_TAG_NAME -> ul 2143 * | | `--END -> > 2144 * | |--NEWLINE -> \n 2145 * | |--LEADING_ASTERISK -> * 2146 * | |--TEXT -> 2147 * | |--HTML_ELEMENT -> HTML_ELEMENT 2148 * | | `--LI -> LI 2149 * | | |--LI_TAG_START -> LI_TAG_START 2150 * | | | |--START -> < 2151 * | | | |--LI_HTML_TAG_NAME -> li 2152 * | | | `--END -> > 2153 * | | |--TEXT -> Item 1 2154 * | | `--LI_TAG_END -> LI_TAG_END 2155 * | | |--START -> < 2156 * | | |--SLASH -> / 2157 * | | |--LI_HTML_TAG_NAME -> li 2158 * | | `--END -> > 2159 * | |--NEWLINE -> \n 2160 * | |--LEADING_ASTERISK -> * 2161 * | |--TEXT -> 2162 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 2163 * | |--START -> < 2164 * | |--SLASH -> / 2165 * | |--HTML_TAG_NAME -> ul 2166 * | `--END -> > 2167 * |--NEWLINE -> \n 2168 * |--TEXT -> 2169 * } 2170 * </pre> 2171 */ 2172 public static final int LI = JavadocParser.RULE_li + RULE_TYPES_OFFSET; 2173 /** Start list item tag. */ 2174 public static final int LI_TAG_START = JavadocParser.RULE_liTagStart + RULE_TYPES_OFFSET; 2175 /** End list item tag. */ 2176 public static final int LI_TAG_END = JavadocParser.RULE_liTagEnd + RULE_TYPES_OFFSET; 2177 2178 /** 2179 * Table row html tag. 2180 * 2181 * <p><b>Example:</b></p> 2182 * <pre>{@code <tr></tr>}</pre> 2183 * <b>Tree:</b> 2184 * <pre> 2185 * {@code 2186 * JAVADOC -> JAVADOC 2187 * |--NEWLINE -> \r\n 2188 * |--LEADING_ASTERISK -> * 2189 * |--TEXT -> 2190 * |--HTML_ELEMENT -> HTML_ELEMENT 2191 * | `--TR -> TR 2192 * | |--TR_TAG_START -> TR_TAG_START 2193 * | | |--START -> < 2194 * | | |--TR_HTML_TAG_NAME -> tr 2195 * | | `--END -> > 2196 * | `--TR_TAG_END -> TR_TAG_END 2197 * | |--START -> < 2198 * | |--SLASH -> / 2199 * | |--TR_HTML_TAG_NAME -> tr 2200 * | `--END -> > 2201 * |--NEWLINE -> \r\n 2202 * |--TEXT -> 2203 * } 2204 * </pre> 2205 */ 2206 public static final int TR = JavadocParser.RULE_tr + RULE_TYPES_OFFSET; 2207 /** Start table row tag. */ 2208 public static final int TR_TAG_START = JavadocParser.RULE_trTagStart + RULE_TYPES_OFFSET; 2209 /** End table row tag. */ 2210 public static final int TR_TAG_END = JavadocParser.RULE_trTagEnd + RULE_TYPES_OFFSET; 2211 2212 /** 2213 * Table cell HTML tag. 2214 * 2215 * <p><b>Example:</b></p> 2216 * <pre>{@code <td>Cell Content</td>}</pre> 2217 * <b>Tree:</b> 2218 * <pre> 2219 * {@code 2220 * HTML_ELEMENT -> HTML_ELEMENT 2221 * `--TD -> TD 2222 * |--TD_TAG_START -> TD_TAG_START 2223 * | |--START -> < 2224 * | |--TD_HTML_TAG_NAME -> td 2225 * | `--END -> > 2226 * |--TEXT -> Cell Content 2227 * `--TD_TAG_END -> TD_TAG_END 2228 * |--START -> < 2229 * |--SLASH -> / 2230 * |--TD_HTML_TAG_NAME -> td 2231 * `--END -> > 2232 * } 2233 * </pre> 2234 */ 2235 public static final int TD = JavadocParser.RULE_td + RULE_TYPES_OFFSET; 2236 /** Start table cell tag. */ 2237 public static final int TD_TAG_START = JavadocParser.RULE_tdTagStart + RULE_TYPES_OFFSET; 2238 /** End table cell tag. */ 2239 public static final int TD_TAG_END = JavadocParser.RULE_tdTagEnd + RULE_TYPES_OFFSET; 2240 2241 /** Table header cell html tag: {@code <th></th>}. */ 2242 public static final int TH = JavadocParser.RULE_th + RULE_TYPES_OFFSET; 2243 /** Start table header cell tag. */ 2244 public static final int TH_TAG_START = JavadocParser.RULE_thTagStart + RULE_TYPES_OFFSET; 2245 /** End table header cell tag. */ 2246 public static final int TH_TAG_END = JavadocParser.RULE_thTagEnd + RULE_TYPES_OFFSET; 2247 2248 /** Body html tag. */ 2249 public static final int BODY = JavadocParser.RULE_body + RULE_TYPES_OFFSET; 2250 2251 /** 2252 * Start body tag. 2253 * 2254 * <p><b>Example:</b></p> 2255 * <pre>{@code 2256 * <body> 2257 * This is a test 2258 * </body> 2259 * }</pre> 2260 * <b>Tree:</b> 2261 * <pre> 2262 * {@code 2263 * JAVADOC -> JAVADOC 2264 * |--TEXT -> /** 2265 * |--NEWLINE -> \n 2266 * |--LEADING_ASTERISK -> * 2267 * |--TEXT -> 2268 * |--HTML_ELEMENT -> HTML_ELEMENT 2269 * | `--BODY -> BODY 2270 * | |--BODY_TAG_START -> BODY_TAG_START 2271 * | | |--START -> < 2272 * | | |--BODY_HTML_TAG_NAME -> body 2273 * | | `--END -> > 2274 * | |--NEWLINE -> \n 2275 * | |--LEADING_ASTERISK -> * 2276 * | |--TEXT -> This is inside the body tag. 2277 * | |--NEWLINE -> \n 2278 * | |--LEADING_ASTERISK -> * 2279 * | |--TEXT -> 2280 * | `--BODY_TAG_END -> BODY_TAG_END 2281 * | |--START -> < 2282 * | |--SLASH -> / 2283 * | |--BODY_HTML_TAG_NAME -> body 2284 * | `--END -> > 2285 * |--NEWLINE -> \n 2286 * |--LEADING_ASTERISK -> * 2287 * |--TEXT -> / 2288 * |--NEWLINE -> \n 2289 * |--TEXT -> public class Test { 2290 * |--NEWLINE -> \n 2291 * |--TEXT -> } 2292 * |--NEWLINE -> \n 2293 * } 2294 * </pre> 2295 */ 2296 public static final int BODY_TAG_START = JavadocParser.RULE_bodyTagStart + RULE_TYPES_OFFSET; 2297 2298 /** 2299 * End body tag. 2300 * 2301 * <p><b>Example:</b></p> 2302 * <pre>{@code 2303 * <body> 2304 * This is a test 2305 * </body> 2306 * }</pre> 2307 * <b>Tree:</b> 2308 * <pre> 2309 * {@code 2310 * JAVADOC -> JAVADOC 2311 * |--TEXT -> /** 2312 * |--NEWLINE -> \n 2313 * |--LEADING_ASTERISK -> * 2314 * |--TEXT -> 2315 * |--HTML_ELEMENT -> HTML_ELEMENT 2316 * | `--BODY -> BODY 2317 * | |--BODY_TAG_START -> BODY_TAG_START 2318 * | | |--START -> < 2319 * | | |--BODY_HTML_TAG_NAME -> body 2320 * | | `--END -> > 2321 * | |--NEWLINE -> \n 2322 * | |--LEADING_ASTERISK -> * 2323 * | |--TEXT -> This is inside the body tag. 2324 * | |--NEWLINE -> \n 2325 * | |--LEADING_ASTERISK -> * 2326 * | |--TEXT -> 2327 * | `--BODY_TAG_END -> BODY_TAG_END 2328 * | |--START -> < 2329 * | |--SLASH -> / 2330 * | |--BODY_HTML_TAG_NAME -> body 2331 * | `--END -> > 2332 * |--NEWLINE -> \n 2333 * |--LEADING_ASTERISK -> * 2334 * |--TEXT -> / 2335 * |--NEWLINE -> \n 2336 * |--TEXT -> public class Test { 2337 * |--NEWLINE -> \n 2338 * |--TEXT -> } 2339 * |--NEWLINE -> \n 2340 * } 2341 * </pre> 2342 */ 2343 public static final int BODY_TAG_END = JavadocParser.RULE_bodyTagEnd + RULE_TYPES_OFFSET; 2344 2345 /** 2346 * Colgroup html tag. 2347 * 2348 * <p><b>Example:</b></p> 2349 * <pre>{@code 2350 * <colgroup> 2351 * <col /> 2352 * <col span="2" class="batman" /> 2353 * </colgroup> 2354 * }</pre> 2355 * <b>Tree:</b> 2356 * <pre> 2357 * {@code 2358 * --JAVADOC -> JAVADOC 2359 * |--NEWLINE -> \n 2360 * |--LEADING_ASTERISK -> * 2361 * |--TEXT -> 2362 * |--HTML_ELEMENT -> HTML_ELEMENT 2363 * | `--COLGROUP -> COLGROUP 2364 * | |--COLGROUP_TAG_START -> COLGROUP_TAG_START 2365 * | | |--START -> < 2366 * | | |--COLGROUP_HTML_TAG_NAME -> colgroup 2367 * | | | `--END -> > 2368 * | |--NEWLINE -> \n 2369 * | |--LEADING_ASTERISK -> * 2370 * | |--TEXT -> 2371 * | |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2372 * | | `--COL_TAG -> COL_TAG 2373 * | | |--START -> < 2374 * | | |--COL_HTML_TAG_NAME -> col 2375 * | | |--WS -> 2376 * | | `--SLASH_END -> /> 2377 * | |--NEWLINE -> \n 2378 * | |--LEADING_ASTERISK -> * 2379 * | |--TEXT -> 2380 * | |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2381 * | | `--COL_TAG -> COL_TAG 2382 * | | |--START -> < 2383 * | | |--COL_HTML_TAG_NAME -> col 2384 * | | |--WS -> 2385 * | | |--ATTRIBUTE -> ATTRIBUTE 2386 * | | | |--HTML_TAG_NAME -> span 2387 * | | | |--EQUALS -> = 2388 * | | | `--ATTR_VALUE -> "2" 2389 * | | |--WS -> 2390 * | | |--ATTRIBUTE -> ATTRIBUTE 2391 * | | | |--HTML_TAG_NAME -> class 2392 * | | | |--EQUALS -> = 2393 * | | | `--ATTR_VALUE -> "batman" 2394 * | | |--WS -> 2395 * | | `--SLASH_END -> /> 2396 * | |--NEWLINE -> \n 2397 * | |--LEADING_ASTERISK -> * 2398 * | |--TEXT -> 2399 * | `--COLGROUP_TAG_END -> COLGROUP_TAG_END 2400 * | | |--START -> < 2401 * | | |--SLASH -> / 2402 * | | |--COLGROUP_HTML_TAG_NAME -> colgroup 2403 * | | `--END -> > 2404 * |--NEWLINE -> \n 2405 * |--TEXT -> 2406 * } 2407 * </pre> 2408 */ 2409 public static final int COLGROUP = JavadocParser.RULE_colgroup + RULE_TYPES_OFFSET; 2410 /** Start colgroup tag. */ 2411 public static final int COLGROUP_TAG_START = JavadocParser.RULE_colgroupTagStart 2412 + RULE_TYPES_OFFSET; 2413 /** End colgroup tag. */ 2414 public static final int COLGROUP_TAG_END = JavadocParser.RULE_colgroupTagEnd 2415 + RULE_TYPES_OFFSET; 2416 2417 /** 2418 * DD html tag. 2419 * 2420 * <p><b>Example AST:</b></p> 2421 * <pre>{@code <dd>Description content</dd>}</pre> 2422 * <pre> 2423 * {@code 2424 * --HTML_ELEMENT -> HTML_ELEMENT 2425 * `--DD -> DD 2426 * |--DD_TAG_START -> DD_TAG_START 2427 * | |--START -> < 2428 * | |--DD_HTML_TAG_NAME -> dd 2429 * | `--END -> > 2430 * |--TEXT -> "Description content" 2431 * `--DD_TAG_END -> DD_TAG_END 2432 * |--START -> < 2433 * |--SLASH -> / 2434 * |--DD_HTML_TAG_NAME -> dd 2435 * `--END -> > 2436 * } 2437 * </pre> 2438 */ 2439 public static final int DD = JavadocParser.RULE_dd + RULE_TYPES_OFFSET; 2440 /** Start description of a term tag. */ 2441 public static final int DD_TAG_START = JavadocParser.RULE_ddTagStart + RULE_TYPES_OFFSET; 2442 /** End description of a term tag. */ 2443 public static final int DD_TAG_END = JavadocParser.RULE_ddTagEnd + RULE_TYPES_OFFSET; 2444 2445 /** Description term html tag: {@code <dt></dt>}. */ 2446 public static final int DT = JavadocParser.RULE_dt + RULE_TYPES_OFFSET; 2447 /** Start description term tag. */ 2448 public static final int DT_TAG_START = JavadocParser.RULE_dtTagStart + RULE_TYPES_OFFSET; 2449 /** End description term tag. */ 2450 public static final int DT_TAG_END = JavadocParser.RULE_dtTagEnd + RULE_TYPES_OFFSET; 2451 2452 /** Head html tag. */ 2453 public static final int HEAD = JavadocParser.RULE_head + RULE_TYPES_OFFSET; 2454 /** Start head tag. */ 2455 public static final int HEAD_TAG_START = JavadocParser.RULE_headTagStart + RULE_TYPES_OFFSET; 2456 /** End head tag. */ 2457 public static final int HEAD_TAG_END = JavadocParser.RULE_headTagEnd + RULE_TYPES_OFFSET; 2458 2459 /** Html html tag. */ 2460 public static final int HTML = JavadocParser.RULE_html + RULE_TYPES_OFFSET; 2461 /** Start html tag. */ 2462 public static final int HTML_TAG_START = JavadocParser.RULE_htmlTagStart + RULE_TYPES_OFFSET; 2463 /** End html tag. */ 2464 public static final int HTML_TAG_END = JavadocParser.RULE_htmlTagEnd + RULE_TYPES_OFFSET; 2465 2466 /** Option html tag. */ 2467 public static final int OPTION = JavadocParser.RULE_option + RULE_TYPES_OFFSET; 2468 /** Start option tag. */ 2469 public static final int OPTION_TAG_START = 2470 JavadocParser.RULE_optionTagStart + RULE_TYPES_OFFSET; 2471 /** End option tag. */ 2472 public static final int OPTION_TAG_END = JavadocParser.RULE_optionTagEnd 2473 + RULE_TYPES_OFFSET; 2474 2475 /** 2476 * Table body html tag. 2477 * 2478 * <p><b>Example:</b></p> 2479 * <pre>{@code <table><tbody></tbody></table>}</pre> 2480 * <b>Tree:</b> 2481 * <pre> 2482 * {@code 2483 * JAVADOC -> JAVADOC 2484 * |--NEWLINE -> \r\n 2485 * |--LEADING_ASTERISK -> * 2486 * |--TEXT -> 2487 * |--HTML_ELEMENT -> HTML_ELEMENT 2488 * | `--HTML_TAG -> HTML_TAG 2489 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 2490 * | | |--START -> < 2491 * | | |--HTML_TAG_NAME -> table 2492 * | | `--END -> > 2493 * | |--HTML_ELEMENT -> HTML_ELEMENT 2494 * | | `--TBODY -> TBODY 2495 * | | |--TBODY_TAG_START -> TBODY_TAG_START 2496 * | | | |--START -> < 2497 * | | | |--TBODY_HTML_TAG_NAME -> tbody 2498 * | | | `--END -> > 2499 * | | `--TBODY_TAG_END -> TBODY_TAG_END 2500 * | | |--START -> < 2501 * | | |--SLASH -> / 2502 * | | |--TBODY_HTML_TAG_NAME -> tbody 2503 * | | `--END -> > 2504 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 2505 * | |--START -> < 2506 * | |--SLASH -> / 2507 * | |--HTML_TAG_NAME -> table 2508 * | `--END -> > 2509 * |--NEWLINE -> \r\n 2510 * } 2511 * </pre> 2512 */ 2513 public static final int TBODY = JavadocParser.RULE_tbody + RULE_TYPES_OFFSET; 2514 /** Start table body tag. */ 2515 public static final int TBODY_TAG_START = JavadocParser.RULE_tbodyTagStart + RULE_TYPES_OFFSET; 2516 /** End table body tag. */ 2517 public static final int TBODY_TAG_END = JavadocParser.RULE_tbodyTagEnd + RULE_TYPES_OFFSET; 2518 2519 /** Table foot html tag. */ 2520 public static final int TFOOT = JavadocParser.RULE_tfoot + RULE_TYPES_OFFSET; 2521 /** Start table foot tag. */ 2522 public static final int TFOOT_TAG_START = JavadocParser.RULE_tfootTagStart + RULE_TYPES_OFFSET; 2523 /** End table foot tag. */ 2524 public static final int TFOOT_TAG_END = JavadocParser.RULE_tfootTagEnd + RULE_TYPES_OFFSET; 2525 2526 /** Table head html tag. */ 2527 public static final int THEAD = JavadocParser.RULE_thead + RULE_TYPES_OFFSET; 2528 /** Start table head tag. */ 2529 public static final int THEAD_TAG_START = JavadocParser.RULE_theadTagStart + RULE_TYPES_OFFSET; 2530 /** End table head tag. */ 2531 public static final int THEAD_TAG_END = JavadocParser.RULE_theadTagEnd + RULE_TYPES_OFFSET; 2532 2533 /** `optgroup` html tag. */ 2534 public static final int OPTGROUP = JavadocParser.RULE_optgroup + RULE_TYPES_OFFSET; 2535 /** `optgroup` tag start. */ 2536 public static final int OPTGROUP_TAG_START = 2537 JavadocParser.RULE_optgroupTagStart + RULE_TYPES_OFFSET; 2538 /** `optgroup` tag end. */ 2539 public static final int OPTGROUP_TAG_END = 2540 JavadocParser.RULE_optgroupTagEnd + RULE_TYPES_OFFSET; 2541 2542 /** `rb` html tag. */ 2543 public static final int RB = JavadocParser.RULE_rb + RULE_TYPES_OFFSET; 2544 /** `rb` tag start. */ 2545 public static final int RB_TAG_START = 2546 JavadocParser.RULE_rbTagStart + RULE_TYPES_OFFSET; 2547 /** `rb` tag end. */ 2548 public static final int RB_TAG_END = 2549 JavadocParser.RULE_rbTagEnd + RULE_TYPES_OFFSET; 2550 2551 /** `rt` html tag. */ 2552 public static final int RT = JavadocParser.RULE_rt + RULE_TYPES_OFFSET; 2553 /** `rt` tag start. */ 2554 public static final int RT_TAG_START = 2555 JavadocParser.RULE_rtTagStart + RULE_TYPES_OFFSET; 2556 /** `rt` tag end. */ 2557 public static final int RT_TAG_END = 2558 JavadocParser.RULE_rtTagEnd + RULE_TYPES_OFFSET; 2559 2560 /** `rtc` html tag. */ 2561 public static final int RTC = JavadocParser.RULE_rtc + RULE_TYPES_OFFSET; 2562 /** `rtc` tag start. */ 2563 public static final int RTC_TAG_START = 2564 JavadocParser.RULE_rtcTagStart + RULE_TYPES_OFFSET; 2565 /** `rtc` tag end. */ 2566 public static final int RTC_TAG_END = 2567 JavadocParser.RULE_rtcTagEnd + RULE_TYPES_OFFSET; 2568 2569 /** `rp` html tag. */ 2570 public static final int RP = JavadocParser.RULE_rp + RULE_TYPES_OFFSET; 2571 /** `rp` tag start. */ 2572 public static final int RP_TAG_START = 2573 JavadocParser.RULE_rpTagStart + RULE_TYPES_OFFSET; 2574 /** `rp` tag end. */ 2575 public static final int RP_TAG_END = 2576 JavadocParser.RULE_rpTagEnd + RULE_TYPES_OFFSET; 2577 2578 /////////////////////// SINGLETON HTML TAGS ////////////////////////////////////////////////// 2579 /** 2580 * Parent node for all singleton html tags. 2581 */ 2582 public static final int SINGLETON_ELEMENT = JavadocParser.RULE_singletonElement 2583 + RULE_TYPES_OFFSET; 2584 2585 /** 2586 * Non-special empty html tag. 2587 */ 2588 public static final int EMPTY_TAG = JavadocParser.RULE_emptyTag 2589 + RULE_TYPES_OFFSET; 2590 2591 /** 2592 * Area html tag. 2593 * 2594 * <p><b>Example:</b></p> 2595 * <pre>{@code < area shape="rect" >}</pre> 2596 * <b>Tree:</b> 2597 * <pre> 2598 * {@code 2599 * JAVADOC -> JAVADOC 2600 * |--NEWLINE -> \n 2601 * |--LEADING_ASTERISK -> * 2602 * |--TEXT -> 2603 * |--HTML_ELEMENT -> HTML_ELEMENT 2604 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2605 * | `--AREA_TAG -> AREA_TAG 2606 * | |--START -> < 2607 * | |--AREA_HTML_TAG_NAME -> area 2608 * | |--WS -> 2609 * | |--ATTRIBUTE -> ATTRIBUTE 2610 * | | |--HTML_TAG_NAME -> shape 2611 * | | |--EQUALS -> = 2612 * | | `--ATTR_VALUE -> "rect" 2613 * | `--END -> > 2614 * |--TEXT -> 2615 * |--NEWLINE -> \n 2616 * |--TEXT -> 2617 * } 2618 * </pre> 2619 */ 2620 public static final int AREA_TAG = JavadocParser.RULE_areaTag + RULE_TYPES_OFFSET; 2621 2622 /** Base html tag. */ 2623 public static final int BASE_TAG = JavadocParser.RULE_baseTag + RULE_TYPES_OFFSET; 2624 2625 /** Basefont html tag. */ 2626 public static final int BASEFONT_TAG = JavadocParser.RULE_basefontTag + RULE_TYPES_OFFSET; 2627 2628 /** Br html tag. */ 2629 public static final int BR_TAG = JavadocParser.RULE_brTag + RULE_TYPES_OFFSET; 2630 2631 /** Col html tag. */ 2632 public static final int COL_TAG = JavadocParser.RULE_colTag + RULE_TYPES_OFFSET; 2633 2634 /** Frame html tag. */ 2635 public static final int FRAME_TAG = JavadocParser.RULE_frameTag + RULE_TYPES_OFFSET; 2636 2637 /** 2638 * Hr html tag. 2639 * 2640 * <p><b>Example:</b></p> 2641 * <pre>{@code text above line<hr> test after line}</pre> 2642 * <b>Tree:</b> 2643 * <pre> 2644 * {@code 2645 * |--LEADING_ASTERISK -> * 2646 * |--TEXT -> text above line 2647 * |--HTML_ELEMENT -> HTML_ELEMENT 2648 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2649 * | `--HR_TAG -> HR_TAG 2650 * | |--START -> < 2651 * | |--HR_HTML_TAG_NAME -> hr 2652 * | `--END -> > 2653 * |--TEXT -> test after line 2654 * |--NEWLINE -> \r\n 2655 * |--TEXT -> 2656 * } 2657 * </pre> 2658 */ 2659 public static final int HR_TAG = JavadocParser.RULE_hrTag + RULE_TYPES_OFFSET; 2660 2661 /** 2662 * Img html tag. 2663 * 2664 * <p><b>Example:</b></p> 2665 * <pre>{@code <img src="./image.png" alt="image description" width="200" height="100"> }</pre> 2666 * <b>Tree:</b> 2667 * <pre> 2668 * {@code 2669 * `--JAVADOC -> JAVADOC 2670 * |--NEWLINE -> \r\n 2671 * |--LEADING_ASTERISK -> * 2672 * |--TEXT -> 2673 * |--HTML_ELEMENT -> HTML_ELEMENT 2674 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2675 * | `--IMG_TAG -> IMG_TAG 2676 * | |--START -> < 2677 * | |--IMG_HTML_TAG_NAME -> img 2678 * | |--WS -> 2679 * | |--ATTRIBUTE -> ATTRIBUTE 2680 * | | |--HTML_TAG_NAME -> src 2681 * | | |--EQUALS -> = 2682 * | | `--ATTR_VALUE -> "./image.png" 2683 * | |--WS -> 2684 * | |--ATTRIBUTE -> ATTRIBUTE 2685 * | | |--HTML_TAG_NAME -> alt 2686 * | | |--EQUALS -> = 2687 * | | `--ATTR_VALUE -> "image description" 2688 * | |--WS -> 2689 * | |--ATTRIBUTE -> ATTRIBUTE 2690 * | | |--HTML_TAG_NAME -> width 2691 * | | |--EQUALS -> = 2692 * | | `--ATTR_VALUE -> "200" 2693 * | |--WS -> 2694 * | |--ATTRIBUTE -> ATTRIBUTE 2695 * | | |--HTML_TAG_NAME -> height 2696 * | | |--EQUALS -> = 2697 * | | `--ATTR_VALUE -> "100" 2698 * | `--END -> > 2699 * |--NEWLINE -> \r\n 2700 * |--TEXT -> 2701 * } 2702 * </pre> 2703 */ 2704 public static final int IMG_TAG = JavadocParser.RULE_imgTag + RULE_TYPES_OFFSET; 2705 2706 /** 2707 * Input html tag. 2708 * 2709 * <p><b>Example:</b></p> 2710 * <pre>{@code Type here: <input type="text" id="id" name="name"> }</pre> 2711 * <b>Tree:</b> 2712 * <pre> 2713 * {@code 2714 * JAVADOC -> JAVADOC 2715 * |--NEWLINE -> \r\n 2716 * |--LEADING_ASTERISK -> * 2717 * |--TEXT -> Type here: 2718 * |--HTML_ELEMENT -> HTML_ELEMENT 2719 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2720 * | `--INPUT_TAG -> INPUT_TAG 2721 * | |--START -> < 2722 * | |--INPUT_HTML_TAG_NAME -> input 2723 * | |--WS -> 2724 * | |--ATTRIBUTE -> ATTRIBUTE 2725 * | | |--HTML_TAG_NAME -> type 2726 * | | |--EQUALS -> = 2727 * | | `--ATTR_VALUE -> "text" 2728 * | |--WS -> 2729 * | |--ATTRIBUTE -> ATTRIBUTE 2730 * | | |--HTML_TAG_NAME -> id 2731 * | | |--EQUALS -> = 2732 * | | `--ATTR_VALUE -> "id" 2733 * | |--WS -> 2734 * | |--ATTRIBUTE -> ATTRIBUTE 2735 * | | |--HTML_TAG_NAME -> name 2736 * | | |--EQUALS -> = 2737 * | | `--ATTR_VALUE -> "name" 2738 * | `--END -> > 2739 * |--NEWLINE -> \r\n 2740 * |--TEXT -> 2741 * } 2742 * </pre> 2743 */ 2744 public static final int INPUT_TAG = JavadocParser.RULE_inputTag + RULE_TYPES_OFFSET; 2745 2746 /** Isindex html tag. */ 2747 public static final int ISINDEX_TAG = JavadocParser.RULE_isindexTag + RULE_TYPES_OFFSET; 2748 2749 /** Link html tag. */ 2750 public static final int LINK_TAG = JavadocParser.RULE_linkTag + RULE_TYPES_OFFSET; 2751 2752 /** 2753 * Meta html tag. 2754 * 2755 * <p><b>Example:</b></p> 2756 * <pre>{@code <meta charset="UTF-8"> }</pre> 2757 * <b>Tree:</b> 2758 * <pre> 2759 * {@code 2760 * `--JAVADOC -> JAVADOC 2761 * |--NEWLINE -> \r\n 2762 * |--LEADING_ASTERISK -> * 2763 * |--TEXT -> 2764 * |--HTML_ELEMENT -> HTML_ELEMENT 2765 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2766 * | `--META_TAG -> META_TAG 2767 * | |--START -> < 2768 * | |--META_HTML_TAG_NAME -> meta 2769 * | |--WS -> 2770 * | |--ATTRIBUTE -> ATTRIBUTE 2771 * | | |--HTML_TAG_NAME -> charset 2772 * | | |--EQUALS -> = 2773 * | | `--ATTR_VALUE -> "UTF-8" 2774 * | `--END -> > 2775 * |--NEWLINE -> \r\n 2776 * |--TEXT -> 2777 * } 2778 * </pre> 2779 */ 2780 public static final int META_TAG = JavadocParser.RULE_metaTag + RULE_TYPES_OFFSET; 2781 2782 /** Param html tag. */ 2783 public static final int PARAM_TAG = JavadocParser.RULE_paramTag + RULE_TYPES_OFFSET; 2784 2785 /** 2786 * HTML void element {@code <embed>}. 2787 * 2788 * @see #SINGLETON_ELEMENT 2789 * @see <a href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-embed"> 2790 * W3 docs</a> 2791 */ 2792 public static final int EMBED_TAG = JavadocParser.RULE_embedTag + RULE_TYPES_OFFSET; 2793 2794 /** 2795 * HTML void element {@code <keygen>}. 2796 * 2797 * @see #SINGLETON_ELEMENT 2798 * @see <a href="https://www.w3.org/TR/html51/sec-forms.html#elementdef-keygen"> 2799 * W3 docs</a> 2800 */ 2801 public static final int KEYGEN_TAG = JavadocParser.RULE_keygenTag + RULE_TYPES_OFFSET; 2802 2803 /** 2804 * HTML void element {@code <source>}. 2805 * 2806 * @see #SINGLETON_ELEMENT 2807 * @see <a href= 2808 * "https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-media-source"> 2809 * W3 docs</a> 2810 */ 2811 public static final int SOURCE_TAG = JavadocParser.RULE_sourceTag + RULE_TYPES_OFFSET; 2812 2813 /** 2814 * HTML void element {@code <track>}. 2815 * 2816 * @see #SINGLETON_ELEMENT 2817 * @see <a 2818 * href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-track"> 2819 * W3 docs</a> 2820 */ 2821 public static final int TRACK_TAG = JavadocParser.RULE_trackTag + RULE_TYPES_OFFSET; 2822 2823 /** 2824 * HTML void element {@code <wbr>}. 2825 * 2826 * @see #SINGLETON_ELEMENT 2827 * @see <a href="https://www.w3.org/TR/html51/textlevel-semantics.html#elementdef-wbr"> 2828 * W3 docs</a> 2829 */ 2830 public static final int WBR_TAG = JavadocParser.RULE_wbrTag + RULE_TYPES_OFFSET; 2831 2832 /////////////////////////////////////////////////////////////////////////////////////////////// 2833 2834 /** 2835 * Html comment: <code><!-- --></code>. 2836 * 2837 * @noinspection HtmlTagCanBeJavadocTag 2838 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 2839 * replaced with Javadoc tag 2840 */ 2841 public static final int HTML_COMMENT = JavadocParser.RULE_htmlComment 2842 + RULE_TYPES_OFFSET; 2843 /** 2844 * CHAR and WS sequence. 2845 */ 2846 public static final int TEXT = JavadocParser.RULE_text + RULE_TYPES_OFFSET; 2847 2848 /** Empty private constructor of the current class. */ 2849 private JavadocTokenTypes() { 2850 } 2851 2852}