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 Comparable<E>}</pre> 376 * <b>Tree:</b> 377 * <pre>{@code 378 * 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 * }</pre> 385 */ 386 public static final int JAVADOC_INLINE_TAG_START = JavadocParser.JAVADOC_INLINE_TAG_START; 387 388 /** 389 * Last child of {@link #JAVADOC_INLINE_TAG} that represents right curly brace '}'. 390 * 391 * <p><b>Example:</b></p> 392 * <pre>{@code Comparable<E>}</pre> 393 * <b>Tree:</b> 394 * <pre>{@code 395 * JAVADOC_INLINE_TAG --> JAVADOC_INLINE_TAG 396 * |--JAVADOC_INLINE_TAG_START --> { 397 * |--CODE_LITERAL --> @code 398 * |--WS --> 399 * |--TEXT --> Comparable<E> 400 * `--JAVADOC_INLINE_TAG_END --> } 401 * }</pre> 402 */ 403 public static final int JAVADOC_INLINE_TAG_END = JavadocParser.JAVADOC_INLINE_TAG_END; 404 405 /** 406 * '@code' literal in {@code} Javadoc inline tag. 407 * 408 * <p>Such Javadoc inline tag can have such child nodes:</p> 409 * <ul> 410 * <li>{@link #NEWLINE}</li> 411 * <li>{@link #WS}</li> 412 * <li>{@link #TEXT}</li> 413 * </ul> 414 * 415 * <p><b>Example:</b></p> 416 * <pre>{@code Comparable<E>}</pre> 417 * <b>Tree:</b> 418 * <pre>{@code 419 * JAVADOC_TAG -> JAVADOC_TAG 420 * |--CUSTOM_NAME -> @code 421 * |--WS -> 422 * `--DESCRIPTION -> DESCRIPTION 423 * |--TEXT -> Comparable<E> 424 * }</pre> 425 * 426 * @see 427 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDFHHBB"> 428 * Oracle Docs</a> 429 * @see #JAVADOC_INLINE_TAG 430 */ 431 public static final int CODE_LITERAL = JavadocParser.CODE_LITERAL; 432 433 /** 434 * '@docRoot' literal in {@docRoot} Javadoc inline tag. 435 * 436 * <p>Such Javadoc inline tag does not have any arguments and can have such child nodes:</p> 437 * <ul> 438 * <li>{@link #NEWLINE}</li> 439 * <li>{@link #WS}</li> 440 * </ul> 441 * 442 * <p><b>Example:</b></p> 443 * <pre>{@code @docRoot}</pre> 444 * <b>Tree:</b> 445 * <pre> 446 * {@code 447 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 448 * |--JAVADOC_INLINE_TAG_START -> { 449 * |--DOC_ROOT_LITERAL -> @docRoot 450 * `--JAVADOC_INLINE_TAG_END -> } 451 * }</pre> 452 * 453 * <pre>{@code Example :{@docRoot 454 * } in a Javadoc comment. 455 * }</pre> 456 * <b>Tree:</b> 457 * <pre> 458 * {@code 459 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 460 * |--JAVADOC_INLINE_TAG_START -> { 461 * |--DOC_ROOT_LITERAL -> @docRoot 462 * |--NEWLINE -> \r\n 463 * |--LEADING_ASTERISK -> * 464 * |--WS -> 465 * `--JAVADOC_INLINE_TAG_END -> } 466 * }</pre> 467 * 468 * @see 469 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDBACBF"> 470 * Oracle Docs</a> 471 * @see #JAVADOC_INLINE_TAG 472 */ 473 public static final int DOC_ROOT_LITERAL = JavadocParser.DOC_ROOT_LITERAL; 474 475 /** 476 * '@link' literal in {@link} Javadoc inline tag. 477 * 478 * <p>Such Javadoc inline tag can have one argument - {@link #REFERENCE}</p> 479 * 480 * <p><b>Example:</b></p> 481 * 482 * <pre><code>{@link org.apache.utils.Lists.Comparator#compare(Object)}</code></pre> 483 * 484 * <p><b>Tree:</b></p> 485 * 486 * <pre> 487 * {@code 488 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 489 * |--JAVADOC_INLINE_TAG_START -> { 490 * |--LINK_LITERAL -> @link 491 * |--WS -> 492 * |--REFERENCE -> REFERENCE 493 * | |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator 494 * | |--HASH -> # 495 * | |--MEMBER -> compare 496 * | `--PARAMETERS -> PARAMETERS 497 * | |--LEFT_BRACE -> ( 498 * | |--ARGUMENT -> Object 499 * | `--RIGHT_BRACE -> ) 500 * `--JAVADOC_INLINE_TAG_END -> } 501 * }</pre> 502 * 503 * @see 504 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDIECH"> 505 * Oracle Docs</a> 506 * @see #JAVADOC_INLINE_TAG 507 * @noinspection HtmlTagCanBeJavadocTag 508 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 509 * replaced with Javadoc tag 510 */ 511 public static final int LINK_LITERAL = JavadocParser.LINK_LITERAL; 512 513 /** 514 * '@inheritDoc' literal in {@inheritDoc} Javadoc inline tag. 515 * 516 * <p>Such Javadoc inline tag does not have any arguments and can have such child nodes:</p> 517 * <ul> 518 * <li>{@link #NEWLINE}</li> 519 * <li>{@link #WS}</li> 520 * </ul> 521 * 522 * <p><b>Example:</b></p> 523 * <pre>{@code {@inheritDoc} }</pre> 524 * <b>Tree:</b> 525 * <pre>{@code 526 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 527 * |--JAVADOC_INLINE_TAG_START -> { 528 * |--INHERIT_DOC_LITERAL -> @inheritDoc 529 * |--JAVADOC_INLINE_TAG_END -> } 530 * }</pre> 531 * 532 * @see 533 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDGJCHC"> 534 * Oracle Docs</a> 535 * @see #JAVADOC_INLINE_TAG 536 */ 537 public static final int INHERIT_DOC_LITERAL = JavadocParser.INHERIT_DOC_LITERAL; 538 539 /** 540 * '@linkplain' literal in {@linkplain} Javadoc inline tag. 541 * 542 * <p>Such Javadoc inline tag can have one argument - {@link #REFERENCE}</p> 543 * 544 * <p><b>Example:</b></p> 545 * <pre><code>{@linkplain org.apache.utils.Lists.Comparator#compare(Object) compare}</code> 546 * </pre> 547 * <b>Tree:</b> 548 * <pre>{@code 549 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 550 * |--JAVADOC_INLINE_TAG_START -> { 551 * |--LINKPLAIN_LITERAL -> @linkplain 552 * |--WS -> 553 * |--REFERENCE -> org.apache.utils.Lists.Comparator#compare(Object) 554 * |--PACKAGE_CLASS -> org.apache.utils 555 * |--DOT -> . 556 * |--CLASS -> Lists 557 * |--DOT -> . 558 * |--CLASS -> Comparator 559 * |--HASH -> # 560 * |--MEMBER -> compare 561 * |--PARAMETERS -> (Object) 562 * |--LEFT_BRACE -> ( 563 * |--ARGUMENT -> Object 564 * |--RIGHT_BRACE -> ) 565 * |--DESCRIPTION -> compare 566 * |--TEXT -> compare 567 * |--JAVADOC_INLINE_TAG_END -> } 568 * }</pre> 569 * 570 * @see 571 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDGBICD"> 572 * Oracle Docs</a> 573 * @see #JAVADOC_INLINE_TAG 574 * @noinspection HtmlTagCanBeJavadocTag 575 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 576 * replaced with Javadoc tag 577 */ 578 public static final int LINKPLAIN_LITERAL = JavadocParser.LINKPLAIN_LITERAL; 579 580 /** 581 * '@literal' literal in {@literal} Javadoc inline tag. 582 * 583 * <p>Such Javadoc inline tag can have such child nodes:</p> 584 * <ul> 585 * <li>{@link #NEWLINE}</li> 586 * <li>{@link #WS}</li> 587 * <li>{@link #TEXT}</li> 588 * </ul> 589 * 590 * <p><b>Example:</b></p> 591 * <pre>{@code {@literal #compare(Object)} }</pre> 592 * <b>Tree:</b> 593 * <pre> 594 * {@code 595 * |--JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 596 * |--JAVADOC_INLINE_TAG_START -> { 597 * |--LITERAL_LITERAL -> @literal 598 * |--WS -> 599 * |--TEXT -> #compare(Object) 600 * `--JAVADOC_INLINE_TAG_END -> } 601 * }</pre> 602 * 603 * @see 604 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCFJDG"> 605 * Oracle Docs</a> 606 * @see #JAVADOC_INLINE_TAG 607 */ 608 public static final int LITERAL_LITERAL = JavadocParser.LITERAL_LITERAL; 609 610 /** 611 * '@value' literal in {@value} Javadoc inline tag. 612 * 613 * <p>Such Javadoc inline tag has one argument {@link #REFERENCE} 614 * and can have such child nodes:</p> 615 * <ul> 616 * <li>{@link #NEWLINE}</li> 617 * <li>{@link #WS}</li> 618 * </ul> 619 * 620 * <p><b>Example:</b></p> 621 * <pre>{@code {@value Integer#MAX_VALUE} }</pre> 622 * <b>Tree:</b> 623 * <pre>{@code 624 * JAVADOC_INLINE_TAG --> JAVADOC_INLINE_TAG 625 * |--JAVADOC_INLINE_TAG_START --> { 626 * |--VALUE_LITERAL --> @value 627 * |--WS --> 628 * |--REFERENCE --> REFERENCE 629 * | |--PACKAGE_CLASS --> Integer 630 * | |--HASH --> # 631 * | `--MEMBER --> MAX_VALUE 632 * `--JAVADOC_INLINE_TAG_END --> } 633 * }</pre> 634 * 635 * @see 636 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDCDHH"> 637 * Oracle Docs</a> 638 * @see #JAVADOC_INLINE_TAG 639 */ 640 public static final int VALUE_LITERAL = JavadocParser.VALUE_LITERAL; 641 642 /** 643 * PACKAGE_CLASS represents the package or class which has been referenced in the `@see`, 644 * `@link`, `@linkplain` or `@value` javadoc tags. In the javadoc tree it shall be a child 645 * of {@link #REFERENCE}. 646 * <br> 647 * <strong>IMPORTANT:</strong> Constructs like 648 * {@code package.Class.NestedClassAtDepth1.NestedClassAtDepth2#member} are recognized by 649 * the javadoc tool from oracle, and no assumptions like, package names wouldn't consist of 650 * uppercase characters or class names begin with an uppercase character, are made. 651 * Also, <i>the reference</i> in a javadoc tag can consist just a package name or a 652 * simple class name or even a full class name. Thus, PACKAGE_CLASS can represent a 653 * package name or a simple class name or a full class name i.e. checkstyle doesn't 654 * resolve references at present. 655 * 656 * <p><b>Example:</b></p> 657 * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre> 658 * <b>Tree:</b> 659 * <pre> 660 * {@code 661 * JAVADOC_TAG -> JAVADOC_TAG 662 * |--SEE_LITERAL -> @see 663 * |--WS -> 664 * |--REFERENCE -> REFERENCE 665 * | |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator 666 * | |--HASH -> # 667 * | |--MEMBER -> compare 668 * | `--PARAMETERS -> PARAMETERS 669 * | |--LEFT_BRACE -> ( 670 * | |--ARGUMENT -> Object 671 * | `--RIGHT_BRACE -> ) 672 * |--NEWLINE -> \r\n 673 * `--WS -> 674 * } 675 * </pre> 676 */ 677 public static final int PACKAGE_CLASS = JavadocParser.PACKAGE_CLASS; 678 679 /** 680 * Hash character in {@link #REFERENCE}. 681 * Hash character is used before specifying a class member. 682 * 683 * <p><b>Example:</b></p> 684 * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre> 685 * <b>Tree:</b> 686 * <pre> 687 * {@code 688 * JAVADOC_TAG -> JAVADOC_TAG 689 * |--SEE_LITERAL -> @see 690 * |--WS -> 691 * |--REFERENCE -> REFERENCE 692 * |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator 693 * |--HASH -> # 694 * |--MEMBER -> compare 695 * `--PARAMETERS -> PARAMETERS 696 * |--LEFT_BRACE -> ( 697 * |--ARGUMENT -> Object 698 * `--RIGHT_BRACE -> ) 699 * } 700 * </pre> 701 */ 702 public static final int HASH = JavadocParser.HASH; 703 704 /** 705 * A class member in {@link #REFERENCE}. 706 * Class member is specified after {@link #HASH} symbol. 707 * 708 * <p><b>Example:</b></p> 709 * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre> 710 * <b>Tree:</b> 711 * <pre> 712 * {@code 713 * JAVADOC_TAG -> JAVADOC_TAG 714 * |--SEE_LITERAL -> @see 715 * |--WS -> 716 * |--REFERENCE -> REFERENCE 717 * |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator 718 * |--HASH -> # 719 * |--MEMBER -> compare 720 * `--PARAMETERS -> PARAMETERS 721 * |--LEFT_BRACE -> ( 722 * |--ARGUMENT -> Object 723 * `--RIGHT_BRACE -> ) 724 * } 725 * </pre> 726 */ 727 public static final int MEMBER = JavadocParser.MEMBER; 728 729 /** 730 * Left brace in {@link #PARAMETERS} part of {@link #REFERENCE}. 731 * 732 * <p><b>Example:</b></p> 733 * <pre>{@code @see #method(Processor, String)}</pre> 734 * <b>Tree:</b> 735 * <pre> 736 * {@code JAVADOC_TAG -> JAVADOC_TAG 737 * |--SEE_LITERAL -> @see 738 * |--WS -> 739 * |--REFERENCE -> REFERENCE 740 * | |--HASH -> # 741 * | |--MEMBER -> method 742 * | `--PARAMETERS -> PARAMETERS 743 * | |--LEFT_BRACE -> ( 744 * | |--ARGUMENT -> Processor 745 * | |--COMMA -> , 746 * | |--WS -> 747 * | |--ARGUMENT -> String 748 * | `--RIGHT_BRACE -> ) 749 * } 750 * </pre> 751 */ 752 public static final int LEFT_BRACE = JavadocParser.LEFT_BRACE; 753 754 /** 755 * Right brace in {@link #PARAMETERS} part of {@link #REFERENCE}. 756 * 757 * <p><b>Example:</b></p> 758 * <pre>{@code @see #method(Processor, String)}</pre> 759 * <b>Tree:</b> 760 * <pre> 761 * {@code JAVADOC_TAG -> JAVADOC_TAG 762 * |--SEE_LITERAL -> @see 763 * |--WS -> 764 * |--REFERENCE -> REFERENCE 765 * | |--HASH -> # 766 * | |--MEMBER -> method 767 * | `--PARAMETERS -> PARAMETERS 768 * | |--LEFT_BRACE -> ( 769 * | |--ARGUMENT -> Processor 770 * | |--COMMA -> , 771 * | |--WS -> 772 * | |--ARGUMENT -> String 773 * | `--RIGHT_BRACE -> ) 774 * } 775 * </pre> 776 */ 777 public static final int RIGHT_BRACE = JavadocParser.RIGHT_BRACE; 778 779 /** 780 * Argument definition in {@link #PARAMETERS} part of {@link #REFERENCE}. 781 * 782 * <p><b>Example:</b></p> 783 * <pre>{@code @see #method(Processor, String)}</pre> 784 * <b>Tree:</b> 785 * <pre> 786 * {@code JAVADOC_TAG -> JAVADOC_TAG 787 * |--SEE_LITERAL -> @see 788 * |--WS -> 789 * |--REFERENCE -> REFERENCE 790 * | |--HASH -> # 791 * | |--MEMBER -> method 792 * | `--PARAMETERS -> PARAMETERS 793 * | |--LEFT_BRACE -> ( 794 * | |--ARGUMENT -> Processor 795 * | |--COMMA -> , 796 * | |--WS -> 797 * | |--ARGUMENT -> String 798 * | `--RIGHT_BRACE -> ) 799 * `--NEWLINE -> \n 800 * } 801 * </pre> 802 */ 803 public static final int ARGUMENT = JavadocParser.ARGUMENT; 804 805 /** 806 * Comma separator between parameters in {@link #PARAMETERS} part of {@link #REFERENCE}. 807 * 808 * <p><b>Example:</b></p> 809 * <pre>{@code @see #method(Processor, String)}</pre> 810 * <b>Tree:</b> 811 * <pre> 812 * {@code 813 * JAVADOC_TAG -> JAVADOC_TAG 814 * |--SEE_LITERAL -> @see 815 * |--WS -> 816 * |--REFERENCE -> REFERENCE 817 * | |--HASH -> # 818 * | |--MEMBER -> method 819 * | `--PARAMETERS -> PARAMETERS 820 * | |--LEFT_BRACE -> ( 821 * | |--ARGUMENT -> Processor 822 * | |--COMMA -> , 823 * | |--WS -> 824 * | |--ARGUMENT -> String 825 * | `--RIGHT_BRACE -> ) 826 * |--NEWLINE -> \r\n 827 * `--WS -> 828 * } 829 * </pre> 830 * 831 * @see #PARAMETERS 832 * @see #REFERENCE 833 * @see #ARGUMENT 834 */ 835 public static final int COMMA = JavadocParser.COMMA; 836 837 /** 838 * Quoted text. 839 * One of possible {@code @see} tag arguments. 840 * 841 * <p><b>Example:</b></p> 842 * <pre>{@code @see "Spring Framework"}</pre> 843 * <b>Tree:</b> 844 * <pre> 845 * {@code 846 * JAVADOC_TAG -> JAVADOC_TAG 847 * |--SEE_LITERAL -> @see 848 * |--WS -> 849 * |--STRING -> "Spring Framework" 850 * |--NEWLINE -> \r\n 851 * `--WS -> 852 * } 853 * </pre> 854 * 855 * @see #SEE_LITERAL 856 */ 857 public static final int STRING = JavadocParser.STRING; 858 859 /** 860 * Exception class name. First argument in {@link #THROWS_LITERAL @throws} and 861 * {@link #EXCEPTION_LITERAL @exception} Javadoc tags. 862 * 863 * <p><b>Example:</b></p> 864 * <pre>{@code @throws IOException connection problems}</pre> 865 * <b>Tree:</b> 866 * <pre> 867 * {@code 868 * JAVADOC_TAG -> JAVADOC_TAG 869 * |--THROWS_LITERAL -> @throws 870 * |--WS -> 871 * |--CLASS_NAME -> IOException 872 * |--WS -> 873 * `--DESCRIPTION -> DESCRIPTION 874 * |--TEXT -> connection problems 875 * |--NEWLINE -> \r\n 876 * `--TEXT -> 877 * } 878 * </pre> 879 * 880 * @see #EXCEPTION_LITERAL 881 * @see #THROWS_LITERAL 882 */ 883 public static final int CLASS_NAME = JavadocParser.CLASS_NAME; 884 885 /** 886 * First argument in {@link #PARAM_LITERAL @param} Javadoc tag. 887 * 888 * <p><b>Example:</b></p> 889 * <pre>{@code @param T The bar.}</pre> 890 * <b>Tree:</b> 891 * <pre> 892 * {@code 893 * --JAVADOC_TAG -> JAVADOC_TAG 894 * |--PARAM_LITERAL -> @param 895 * |--WS -> 896 * |--PARAMETER_NAME -> T 897 * |--WS -> 898 * `--DESCRIPTION -> DESCRIPTION 899 * |--TEXT -> The bar. 900 * |--NEWLINE -> \r\n 901 * `--TEXT -> 902 * } 903 * </pre> 904 * 905 * @see 906 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHJECF"> 907 * Oracle Docs</a> 908 * @see #PARAM_LITERAL 909 */ 910 public static final int PARAMETER_NAME = JavadocParser.PARAMETER_NAME; 911 912 /** 913 * 'exclude' literal. 914 * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments. 915 * 916 * <p><b>Example:</b></p> 917 * <pre>{@code @serial exclude}</pre> 918 * <b>Tree:</b> 919 * <pre> 920 * {@code 921 * JAVADOC_TAG -> JAVADOC_TAG 922 * |--SERIAL_LITERAL -> @serial 923 * |--WS -> 924 * `--DESCRIPTION -> DESCRIPTION 925 * |--TEXT -> serialized company name 926 * |--NEWLINE -> \r\n 927 * `--TEXT -> 928 * } 929 * </pre> 930 * 931 * @see 932 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF"> 933 * Oracle Docs</a> 934 * @see #SERIAL_LITERAL 935 */ 936 public static final int LITERAL_EXCLUDE = JavadocParser.LITERAL_EXCLUDE; 937 938 /** 939 * 'include' literal. 940 * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments. 941 * 942 * <p><b>Example:</b></p> 943 * <pre>{@code @serial include}</pre> 944 * <b>Tree:</b> 945 * <pre> 946 * {@code 947 * JAVADOC_TAG -> JAVADOC_TAG 948 * |--SERIAL_LITERAL -> @serial 949 * |--WS -> 950 * |--LITERAL_INCLUDE -> include 951 * |--NEWLINE -> \r\n 952 * `--WS -> 953 * } 954 * </pre> 955 * 956 * @see 957 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF"> 958 * Oracle Docs</a> 959 * @see #SERIAL_LITERAL 960 */ 961 public static final int LITERAL_INCLUDE = JavadocParser.LITERAL_INCLUDE; 962 963 /** 964 * Field name. First argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag. 965 * 966 * <p><b>Example:</b></p> 967 * <pre>{@code @serialField counter Integer objects counter}</pre> 968 * <b>Tree:</b> 969 * <pre> 970 * {@code 971 * --JAVADOC_TAG -> JAVADOC_TAG 972 * |--SERIAL_FIELD_LITERAL -> @serialField 973 * |--WS -> 974 * |--LITERAL_INCLUDE -> include 975 * |--NEWLINE -> \r\n 976 * `--WS -> 977 * `--DESCRIPTION -> DESCRIPTION 978 * |--TEXT -> objects counter 979 * |--NEWLINE -> \r\n 980 * `--TEXT -> 981 * }</pre> 982 * 983 * @see 984 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF"> 985 * Oracle Docs</a> 986 * @see #SERIAL_FIELD_LITERAL 987 */ 988 public static final int FIELD_NAME = JavadocParser.FIELD_NAME; 989 990 /** 991 * Field type. Second argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag. 992 * 993 * <p><b>Example:</b></p> 994 * <pre>{@code @serialField counter Integer objects counter}</pre> 995 * <b>Tree:</b> 996 * <pre> 997 * {@code 998 * --JAVADOC_TAG -> JAVADOC_TAG 999 * |--SERIAL_FIELD_LITERAL -> @serialField 1000 * |--WS -> 1001 * |--FIELD_NAME -> counter 1002 * |--WS -> 1003 * |--FIELD_TYPE -> Integer 1004 * |--WS -> 1005 * `--DESCRIPTION -> DESCRIPTION 1006 * |--TEXT -> objects counter 1007 * |--NEWLINE -> \r\n 1008 * `--TEXT -> 1009 * } 1010 * </pre> 1011 * 1012 * @see 1013 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF"> 1014 * Oracle Docs</a> 1015 * @see #SERIAL_FIELD_LITERAL 1016 */ 1017 public static final int FIELD_TYPE = JavadocParser.FIELD_TYPE; 1018 1019 // ------------------------------------------------------------------------------------------ // 1020 // ----------------- HTML TAGS ---------------------------------------------- // 1021 // ------------------------------------------------------------------------------------------ // 1022 1023 /** 1024 * Identifier inside HTML tag: tag name or attribute name. 1025 */ 1026 public static final int HTML_TAG_NAME = JavadocParser.HTML_TAG_NAME; 1027 1028 // HTML tag components 1029 1030 /** 1031 * Start html tag component: {@code '<'}. 1032 */ 1033 public static final int START = JavadocParser.START; 1034 1035 /** 1036 * Slash html tag component: {@code '/'}. 1037 */ 1038 public static final int SLASH = JavadocParser.SLASH; 1039 1040 /** 1041 * End html tag component: {@code '>'}. 1042 */ 1043 public static final int END = JavadocParser.END; 1044 1045 /** 1046 * Slash close html tag component: {@code '/>'}. 1047 */ 1048 public static final int SLASH_END = JavadocParser.SLASH_END; 1049 1050 /** 1051 * Equals html tag component: {@code '='}. 1052 */ 1053 public static final int EQUALS = JavadocParser.EQUALS; 1054 1055 /** 1056 * Attribute value HTML tag component. 1057 * 1058 * <p><b>Example:</b></p> 1059 * 1060 * <pre> 1061 * <tag_name attr_name="attr_value">Content</tag_name> 1062 * </pre> 1063 * 1064 * <p><b>Tree:</b></p> 1065 * <pre>{@code 1066 * JAVADOC -> JAVADOC 1067 * |--NEWLINE -> \r\n 1068 * |--LEADING_ASTERISK -> * 1069 * |--TEXT -> 1070 * |--HTML_ELEMENT -> HTML_ELEMENT 1071 * | `--HTML_TAG -> HTML_TAG 1072 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1073 * | | |--START -> < 1074 * | | |--HTML_TAG_NAME -> tag_name 1075 * | | |--WS -> 1076 * | | |--ATTRIBUTE -> ATTRIBUTE 1077 * | | | |--HTML_TAG_NAME -> attr_name 1078 * | | | |--EQUALS -> = 1079 * | | | `--ATTR_VALUE -> "attr_value" 1080 * | | `--END -> > 1081 * | |--TEXT -> Content 1082 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1083 * | |--START -> < 1084 * | |--SLASH -> / 1085 * | |--HTML_TAG_NAME -> tag_name 1086 * | `--END -> > 1087 * }</pre> 1088 */ 1089 public static final int ATTR_VALUE = JavadocParser.ATTR_VALUE; 1090 1091 /////////////////////// HTML TAGS WITH OPTIONAL END TAG ///////////////////////////////////// 1092 1093 /** 1094 * Paragraph tag name. 1095 * 1096 * <p><b>Example:</b></p> 1097 * <pre>{@code <p>Paragraph Tag.</p>}</pre> 1098 * <b>Tree:</b> 1099 * <pre> 1100 * {@code 1101 * `--HTML_ELEMENT -> HTML_ELEMENT 1102 * `--PARAGRAPH -> PARAGRAPH 1103 * |--P_TAG_START -> P_TAG_START 1104 * | |--START -> < 1105 * | |--P_HTML_TAG_NAME -> p 1106 * | `--END -> > 1107 * |--TEXT -> Paragraph Tag. 1108 * `--P_TAG_END -> P_TAG_END 1109 * |--START -> < 1110 * |--SLASH -> / 1111 * |--P_HTML_TAG_NAME -> p 1112 * `--END -> > 1113 * } 1114 * </pre> 1115 * 1116 * @see 1117 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1118 * Comments are written in HTML</a> 1119 * @see #P_HTML_TAG_NAME 1120 */ 1121 public static final int P_HTML_TAG_NAME = JavadocParser.P_HTML_TAG_NAME; 1122 1123 /** 1124 * List item tag name. 1125 * 1126 * <p><b>Example:</b></p> 1127 * <pre>{@code 1128 * <ol> 1129 * <li>banana</li> 1130 * </ol> 1131 * }</pre> 1132 * <b>Tree:</b> 1133 * <pre> 1134 * {@code 1135 * HTML_ELEMENT -> HTML_ELEMENT 1136 * `--HTML_TAG -> HTML_TAG 1137 * |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1138 * | |--START -> < 1139 * | |--HTML_TAG_NAME -> ol 1140 * | `--END -> > 1141 * |--NEWLINE -> \r\n 1142 * |--LEADING_ASTERISK -> * 1143 * |--TEXT -> 1144 * |--HTML_ELEMENT -> HTML_ELEMENT 1145 * | `--LI -> LI 1146 * | |--LI_TAG_START -> LI_TAG_START 1147 * | | |--START -> < 1148 * | | |--LI_HTML_TAG_NAME -> li 1149 * | | `--END -> > 1150 * | |--TEXT -> banana 1151 * | `--LI_TAG_END -> LI_TAG_END 1152 * | |--START -> < 1153 * | |--SLASH -> / 1154 * | |--LI_HTML_TAG_NAME -> li 1155 * | `--END -> > 1156 * |--NEWLINE -> \r\n 1157 * |--LEADING_ASTERISK -> * 1158 * |--TEXT -> 1159 * `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1160 * |--START -> < 1161 * |--SLASH -> / 1162 * |--HTML_TAG_NAME -> ol 1163 * `--END -> > 1164 * } 1165 * </pre> 1166 * 1167 * @see 1168 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1169 * comments are written in HTML</a> 1170 * @see #LI_HTML_TAG_NAME 1171 */ 1172 public static final int LI_HTML_TAG_NAME = JavadocParser.LI_HTML_TAG_NAME; 1173 1174 /** 1175 * Table row tag name. 1176 * 1177 * <p><b>Example:</b></p> 1178 * <pre>{@code 1179 * <table> 1180 * <tr>Table Row</tr> 1181 * </table> 1182 * }</pre> 1183 * <b>Tree:</b> 1184 * <pre> 1185 * {@code 1186 * HTML_ELEMENT -> HTML_ELEMENT 1187 * `--HTML_TAG -> HTML_TAG 1188 * |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1189 * | |--START -> < 1190 * | |--HTML_TAG_NAME -> table 1191 * | `--END -> > 1192 * |--NEWLINE -> \r\n 1193 * |--LEADING_ASTERISK -> * 1194 * |--TEXT -> 1195 * |--HTML_ELEMENT -> HTML_ELEMENT 1196 * | `--TR -> TR 1197 * | |--TR_TAG_START -> TR_TAG_START 1198 * | | |--START -> < 1199 * | | |--TR_HTML_TAG_NAME -> tr 1200 * | | `--END -> > 1201 * | |--TEXT -> Table Row 1202 * | `--TR_TAG_END -> TR_TAG_END 1203 * | |--START -> < 1204 * | |--SLASH -> / 1205 * | |--TR_HTML_TAG_NAME -> tr 1206 * | `--END -> > 1207 * |--NEWLINE -> \r\n 1208 * |--LEADING_ASTERISK -> * 1209 * |--TEXT -> 1210 * `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1211 * |--START -> < 1212 * |--SLASH -> / 1213 * |--HTML_TAG_NAME -> table 1214 * `--END -> > 1215 * } 1216 * </pre> 1217 * 1218 * @see 1219 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1220 * comments are written in HTML</a> 1221 * @see #TR_HTML_TAG_NAME 1222 */ 1223 public static final int TR_HTML_TAG_NAME = JavadocParser.TR_HTML_TAG_NAME; 1224 1225 /** 1226 * Table cell tag name. 1227 * 1228 * <p><b>Example:</b></p> 1229 * <pre>{@code 1230 * <tr> 1231 * <td>Cell 1</td> 1232 * </tr> 1233 * }</pre> 1234 * <b>Tree:</b> 1235 * <pre> 1236 * {@code 1237 * HTML_ELEMENT -> HTML_ELEMENT 1238 * `--TR -> TR 1239 * |--TR_TAG_START -> TR_TAG_START 1240 * | |--START -> < 1241 * | |--TR_HTML_TAG_NAME -> tr 1242 * | `--END -> > 1243 * |--NEWLINE -> \r\n 1244 * |--LEADING_ASTERISK -> * 1245 * |--TEXT -> 1246 * |--TD -> TD 1247 * | |--TD_TAG_START -> TD_TAG_START 1248 * | | |--START -> < 1249 * | | |--TD_HTML_TAG_NAME -> td 1250 * | | `--END -> > 1251 * | |--TEXT -> Cell 1 1252 * | `--TD_TAG_END -> TD_TAG_END 1253 * | |--START -> < 1254 * | |--SLASH -> / 1255 * | |--TD_HTML_TAG_NAME -> td 1256 * | `--END -> > 1257 * |--NEWLINE -> \r\n 1258 * |--LEADING_ASTERISK -> * 1259 * |--TEXT -> 1260 * `--TR_TAG_END -> TR_TAG_END 1261 * |--START -> < 1262 * |--SLASH -> / 1263 * |--TR_HTML_TAG_NAME -> tr 1264 * `--END -> > 1265 * } 1266 * </pre> 1267 * 1268 * @see 1269 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1270 * comments are written in HTML</a> 1271 * @see #TD_HTML_TAG_NAME 1272 */ 1273 public static final int TD_HTML_TAG_NAME = JavadocParser.TD_HTML_TAG_NAME; 1274 1275 /** 1276 * Table header cell tag name. 1277 * 1278 * <p><b>Example:</b></p> 1279 * <pre>{@code 1280 * <tr> 1281 * <th>Table Head</th> 1282 * </tr> 1283 * }</pre> 1284 * <b>Tree:</b> 1285 * <pre> 1286 * {@code 1287 * HTML_ELEMENT -> HTML_ELEMENT 1288 * `--TR -> TR 1289 * |--TR_TAG_START -> TR_TAG_START 1290 * | |--START -> < 1291 * | |--TR_HTML_TAG_NAME -> tr 1292 * | `--END -> > 1293 * |--NEWLINE -> \r\n 1294 * |--LEADING_ASTERISK -> * 1295 * |--TEXT -> 1296 * |--TH -> TH 1297 * | |--TH_TAG_START -> TH_TAG_START 1298 * | | |--START -> < 1299 * | | |--TH_HTML_TAG_NAME -> th 1300 * | | `--END -> > 1301 * | |--TEXT -> Table Head 1302 * | `--TH_TAG_END -> TH_TAG_END 1303 * | |--START -> < 1304 * | |--SLASH -> / 1305 * | |--TH_HTML_TAG_NAME -> th 1306 * | `--END -> > 1307 * |--NEWLINE -> \r\n 1308 * |--LEADING_ASTERISK -> * 1309 * |--TEXT -> 1310 * `--TR_TAG_END -> TR_TAG_END 1311 * |--START -> < 1312 * |--SLASH -> / 1313 * |--TR_HTML_TAG_NAME -> tr 1314 * `--END -> > 1315 * } 1316 * </pre> 1317 * 1318 * @see 1319 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1320 * comments are written in HTML</a> 1321 * @see #TH_HTML_TAG_NAME 1322 */ 1323 public static final int TH_HTML_TAG_NAME = JavadocParser.TH_HTML_TAG_NAME; 1324 1325 /** 1326 * Body tag name. 1327 * 1328 * <p><b>Example:</b></p> 1329 * <pre> 1330 * <body> 1331 * <p>Body Content</p> 1332 * </body> 1333 * </pre> 1334 * <b>Tree:</b> 1335 * <pre> 1336 * {@code 1337 * HTML_ELEMENT -> HTML_ELEMENT 1338 * `--BODY -> BODY 1339 * |--BODY_TAG_START -> BODY_TAG_START 1340 * | |--START -> < 1341 * | |--BODY_HTML_TAG_NAME -> body 1342 * | `--END -> > 1343 * |--NEWLINE -> \r\n 1344 * |--LEADING_ASTERISK -> * 1345 * |--TEXT -> 1346 * |--PARAGRAPH -> PARAGRAPH 1347 * | |--P_TAG_START -> P_TAG_START 1348 * | | |--START -> < 1349 * | | |--P_HTML_TAG_NAME -> p 1350 * | | `--END -> > 1351 * | |--TEXT -> Body Content 1352 * | `--P_TAG_END -> P_TAG_END 1353 * | |--START -> < 1354 * | |--SLASH -> / 1355 * | |--P_HTML_TAG_NAME -> p 1356 * | `--END -> > 1357 * |--NEWLINE -> \r\n 1358 * |--LEADING_ASTERISK -> * 1359 * |--TEXT -> 1360 * `--BODY_TAG_END -> BODY_TAG_END 1361 * |--START -> < 1362 * |--SLASH -> / 1363 * |--BODY_HTML_TAG_NAME -> body 1364 * `--END -> > 1365 * } 1366 * </pre> 1367 * 1368 * @see 1369 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1370 * comments are written in HTML</a> 1371 * @see #BODY_HTML_TAG_NAME 1372 */ 1373 public static final int BODY_HTML_TAG_NAME = JavadocParser.BODY_HTML_TAG_NAME; 1374 1375 /** 1376 * Colgroup tag name. 1377 * 1378 * <p><b>Example:</b></p> 1379 * <pre>{@code <colgroup><col span="2"></colgroup>}</pre> 1380 * <b>Tree:</b> 1381 * <pre> 1382 * {@code 1383 * |--HTML_ELEMENT -> HTML_ELEMENT 1384 * | `--COLGROUP -> COLGROUP 1385 * | |--COLGROUP_TAG_START -> COLGROUP_TAG_START 1386 * | | |--START -> < 1387 * | | |--COLGROUP_HTML_TAG_NAME -> colgroup 1388 * | | `--END -> > 1389 * | |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1390 * | | `--COL_TAG -> COL_TAG 1391 * | | |--START -> < 1392 * | | |--COL_HTML_TAG_NAME -> col 1393 * | | |--WS -> 1394 * | | |--ATTRIBUTE -> ATTRIBUTE 1395 * | | | |--HTML_TAG_NAME -> span 1396 * | | | |--EQUALS -> = 1397 * | | | `--ATTR_VALUE -> "2" 1398 * | | `--END -> > 1399 * | `--COLGROUP_TAG_END -> COLGROUP_TAG_END 1400 * | |--START -> < 1401 * | |--SLASH -> / 1402 * | |--COLGROUP_HTML_TAG_NAME -> colgroup 1403 * | `--END -> > 1404 * |--TEXT -> 1405 * `--EOF -> <EOF> 1406 * } 1407 * </pre> 1408 * 1409 * @see #COLGROUP_HTML_TAG_NAME 1410 */ 1411 public static final int COLGROUP_HTML_TAG_NAME = JavadocParser.COLGROUP_HTML_TAG_NAME; 1412 1413 /** 1414 * Description of a term tag name. 1415 * 1416 * <p><b>Example:</b></p> 1417 * <pre>{@code 1418 * <dl> 1419 * <dt>Java</dt> 1420 * <dd>A high-level programming language.</dd> 1421 * </dl> 1422 * }</pre> 1423 * <b>Tree:</b> 1424 * <pre> 1425 * {@code 1426 * HTML_ELEMENT -> HTML_ELEMENT 1427 * `--HTML_TAG -> HTML_TAG 1428 * |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1429 * | |--START -> < 1430 * | |--HTML_TAG_NAME -> dl 1431 * | `--END -> > 1432 * |--NEWLINE -> \r\n 1433 * |--LEADING_ASTERISK -> * 1434 * |--TEXT -> 1435 * |--HTML_ELEMENT -> HTML_ELEMENT 1436 * | `--DT -> DT 1437 * | |--DT_TAG_START -> DT_TAG_START 1438 * | | |--START -> < 1439 * | | |--DT_HTML_TAG_NAME -> dt 1440 * | | `--END -> > 1441 * | |--TEXT -> Java 1442 * | `--DT_TAG_END -> DT_TAG_END 1443 * | |--START -> < 1444 * | |--SLASH -> / 1445 * | |--DT_HTML_TAG_NAME -> dt 1446 * | `--END -> > 1447 * |--NEWLINE -> \r\n 1448 * |--LEADING_ASTERISK -> * 1449 * |--TEXT -> 1450 * |--HTML_ELEMENT -> HTML_ELEMENT 1451 * | `--DD -> DD 1452 * | |--DD_TAG_START -> DD_TAG_START 1453 * | | |--START -> < 1454 * | | |--DD_HTML_TAG_NAME -> dd 1455 * | | `--END -> > 1456 * | |--TEXT -> A high-level programming language. 1457 * | `--DD_TAG_END -> DD_TAG_END 1458 * | |--START -> < 1459 * | |--SLASH -> / 1460 * | |--DD_HTML_TAG_NAME -> dd 1461 * | `--END -> > 1462 * |--NEWLINE -> \r\n 1463 * |--LEADING_ASTERISK -> * 1464 * |--TEXT -> 1465 * `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1466 * |--START -> < 1467 * |--SLASH -> / 1468 * |--HTML_TAG_NAME -> dl 1469 * `--END -> > 1470 * } 1471 * </pre> 1472 * 1473 * @see #DD_HTML_TAG_NAME 1474 */ 1475 public static final int DD_HTML_TAG_NAME = JavadocParser.DD_HTML_TAG_NAME; 1476 1477 /** 1478 * Description term tag name. 1479 * 1480 * <p><b>Example:</b></p> 1481 * <pre>{@code 1482 * <dl> 1483 * <dt>Java</dt> 1484 * </dl> 1485 * }</pre> 1486 * <b>Tree:</b> 1487 * <pre> 1488 * {@code 1489 * HTML_ELEMENT -> HTML_ELEMENT 1490 * `--HTML_TAG -> HTML_TAG 1491 * |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1492 * | |--START -> < 1493 * | |--HTML_TAG_NAME -> dl 1494 * | `--END -> > 1495 * |--NEWLINE -> \r\n 1496 * |--LEADING_ASTERISK -> * 1497 * |--TEXT -> 1498 * |--HTML_ELEMENT -> HTML_ELEMENT 1499 * | `--DT -> DT 1500 * | |--DT_TAG_START -> DT_TAG_START 1501 * | | |--START -> < 1502 * | | |--DT_HTML_TAG_NAME -> dt 1503 * | | `--END -> > 1504 * | |--TEXT -> Java 1505 * | `--DT_TAG_END -> DT_TAG_END 1506 * | |--START -> < 1507 * | |--SLASH -> / 1508 * | |--DT_HTML_TAG_NAME -> dt 1509 * | `--END -> > 1510 * |--NEWLINE -> \r\n 1511 * |--LEADING_ASTERISK -> * 1512 * |--TEXT -> 1513 * `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1514 * |--START -> < 1515 * |--SLASH -> / 1516 * |--HTML_TAG_NAME -> dl 1517 * `--END -> > 1518 * } 1519 * </pre> 1520 * 1521 * @see #DT_HTML_TAG_NAME 1522 */ 1523 public static final int DT_HTML_TAG_NAME = JavadocParser.DT_HTML_TAG_NAME; 1524 1525 /** 1526 * Head tag name. 1527 * 1528 * <p><b>Example:</b></p> 1529 * <pre> 1530 * <head> 1531 * <title>Page Title</title> 1532 * <meta charset="UTF-8"> 1533 * </head> 1534 * </pre> 1535 * <b>Tree:</b> 1536 * <pre>{@code 1537 * HEAD -> HEAD 1538 * |--HEAD_TAG_START -> HEAD_TAG_START 1539 * | |--START -> < 1540 * | |--HEAD_HTML_TAG_NAME -> head 1541 * | `--END -> > 1542 * |--NEWLINE -> \r\n 1543 * |--LEADING_ASTERISK -> * 1544 * |--TEXT -> 1545 * |--HTML_TAG -> HTML_TAG 1546 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1547 * | | |--START -> < 1548 * | | |--HTML_TAG_NAME -> title 1549 * | | `--END -> > 1550 * | |--TEXT -> Page Title 1551 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1552 * | |--START -> < 1553 * | |--SLASH -> / 1554 * | |--HTML_TAG_NAME -> title 1555 * | `--END -> > 1556 * |--NEWLINE -> \r\n 1557 * |--LEADING_ASTERISK -> * 1558 * |--TEXT -> 1559 * |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1560 * | `--META_TAG -> META_TAG 1561 * | |--START -> < 1562 * | |--META_HTML_TAG_NAME -> meta 1563 * | |--WS -> 1564 * | |--ATTRIBUTE -> ATTRIBUTE 1565 * | | |--HTML_TAG_NAME -> charset 1566 * | | |--EQUALS -> = 1567 * | | `--ATTR_VALUE -> "UTF-8" 1568 * | `--END -> > 1569 * |--NEWLINE -> \r\n 1570 * |--LEADING_ASTERISK -> * 1571 * |--TEXT -> 1572 * `--HEAD_TAG_END -> HEAD_TAG_END 1573 * |--START -> < 1574 * |--SLASH -> / 1575 * |--HEAD_HTML_TAG_NAME -> head 1576 * `--END -> > 1577 * } 1578 * </pre> 1579 * 1580 * @see #HEAD_HTML_TAG_NAME 1581 */ 1582 public static final int HEAD_HTML_TAG_NAME = JavadocParser.HEAD_HTML_TAG_NAME; 1583 1584 /** Html tag name. */ 1585 public static final int HTML_HTML_TAG_NAME = JavadocParser.HTML_HTML_TAG_NAME; 1586 1587 /** 1588 * Option tag name. 1589 * 1590 * <p><b>Example:</b></p> 1591 * <pre><option value="yes">Yes</option></pre> 1592 * <b>Tree:</b> 1593 * <pre> 1594 * {@code 1595 * JAVADOC -> JAVADOC 1596 * |--NEWLINE -> \r\n 1597 * |--LEADING_ASTERISK -> * 1598 * |--HTML_ELEMENT -> HTML_ELEMENT 1599 * | `--OPTION -> OPTION 1600 * | |--OPTION_TAG_START -> OPTION_TAG_START 1601 * | | |--START -> < 1602 * | | |--OPTION_HTML_TAG_NAME -> option 1603 * | | |--WS -> 1604 * | | |--ATTRIBUTE -> ATTRIBUTE 1605 * | | | |--HTML_TAG_NAME -> value 1606 * | | | |--EQUALS -> = 1607 * | | | `--ATTR_VALUE -> "yes" 1608 * | | `--END -> > 1609 * | |--TEXT -> Yes 1610 * | `--OPTION_TAG_END -> OPTION_TAG_END 1611 * | |--START -> < 1612 * | |--SLASH -> / 1613 * | |--OPTION_HTML_TAG_NAME -> option 1614 * | `--END -> > 1615 * |--NEWLINE -> \r\n 1616 * |--TEXT -> 1617 * |--EOF -> <EOF> 1618 * } 1619 * </pre> 1620 */ 1621 public static final int OPTION_HTML_TAG_NAME = JavadocParser.OPTION_HTML_TAG_NAME; 1622 1623 /** 1624 * Table body tag name. 1625 * 1626 * <p><b>Example:</b></p> 1627 * <pre> 1628 * <tbody> 1629 * <tr> 1630 * <td>Row1</td> 1631 * </tr> 1632 * </tbody> 1633 * </pre> 1634 * <b>Tree:</b> 1635 * <pre> 1636 * {@code 1637 * JAVADOC -> JAVADOC 1638 * |--NEWLINE -> \n 1639 * |--LEADING_ASTERISK -> * 1640 * |--TEXT -> 1641 * |--HTML_ELEMENT -> HTML_ELEMENT 1642 * | `--TBODY -> TBODY 1643 * | |--TBODY_TAG_START -> TBODY_TAG_START 1644 * | | |--START -> < 1645 * | | |--TBODY_HTML_TAG_NAME -> tbody 1646 * | | `--END -> > 1647 * | |--NEWLINE -> \n 1648 * | |--LEADING_ASTERISK -> * 1649 * | |--TEXT -> 1650 * | |--TR -> TR 1651 * | | |--TR_TAG_START -> TR_TAG_START 1652 * | | | |--START -> < 1653 * | | | |--TR_HTML_TAG_NAME -> tr 1654 * | | | `--END -> > 1655 * | | |--NEWLINE -> \n 1656 * | | |--LEADING_ASTERISK -> * 1657 * | | |--TEXT -> 1658 * | | |--TD -> TD 1659 * | | | |--TD_TAG_START -> TD_TAG_START 1660 * | | | | |--START -> < 1661 * | | | | |--TD_HTML_TAG_NAME -> td 1662 * | | | | `--END -> > 1663 * | | | |--TEXT -> Row1 1664 * | | | `--TD_TAG_END -> TD_TAG_END 1665 * | | | |--START -> < 1666 * | | | |--SLASH -> / 1667 * | | | |--TD_HTML_TAG_NAME -> td 1668 * | | | `--END -> > 1669 * | | |--NEWLINE -> \n 1670 * | | |--LEADING_ASTERISK -> * 1671 * | | |--TEXT -> 1672 * | | `--TR_TAG_END -> TR_TAG_END 1673 * | | |--START -> < 1674 * | | |--SLASH -> / 1675 * | | |--TR_HTML_TAG_NAME -> tr 1676 * | | `--END -> > 1677 * | |--NEWLINE -> \n 1678 * | |--LEADING_ASTERISK -> * 1679 * | |--TEXT -> 1680 * | `--TBODY_TAG_END -> TBODY_TAG_END 1681 * | |--START -> < 1682 * | |--SLASH -> / 1683 * | |--TBODY_HTML_TAG_NAME -> tbody 1684 * | `--END -> > 1685 * |--NEWLINE -> \n 1686 * |--TEXT -> 1687 * `--EOF -> <EOF> 1688 * } 1689 * </pre> 1690 */ 1691 public static final int TBODY_HTML_TAG_NAME = JavadocParser.TBODY_HTML_TAG_NAME; 1692 1693 /** Table foot tag name. */ 1694 public static final int TFOOT_HTML_TAG_NAME = JavadocParser.TFOOT_HTML_TAG_NAME; 1695 1696 /** 1697 * Table head tag name. 1698 * 1699 * <p><b>Example:</b></p> 1700 * <pre> 1701 * <thead> 1702 * <tr> 1703 * <th>Header</th> 1704 * </tr> 1705 * </thead> 1706 * </pre> 1707 * <b>Tree:</b> 1708 * <pre> 1709 * {@code 1710 * JAVADOC -> JAVADOC 1711 * |--NEWLINE -> \n 1712 * |--LEADING_ASTERISK -> * 1713 * |--TEXT -> 1714 * |--HTML_ELEMENT -> HTML_ELEMENT 1715 * | `--THEAD -> THEAD 1716 * | |--THEAD_TAG_START -> THEAD_TAG_START 1717 * | | |--START -> < 1718 * | | |--THEAD_HTML_TAG_NAME -> thead 1719 * | | `--END -> > 1720 * | |--TR -> TR 1721 * | | |--TR_TAG_START -> TR_TAG_START 1722 * | | | |--START -> < 1723 * | | | |--TR_HTML_TAG_NAME -> tr 1724 * | | | `--END -> > 1725 * | | |--TH -> TH 1726 * | | | |--TH_TAG_START -> TH_TAG_START 1727 * | | | | |--START -> < 1728 * | | | | |--TH_HTML_TAG_NAME -> th 1729 * | | | | `--END -> > 1730 * | | | |--TEXT -> Header 1731 * | | | `--TH_TAG_END -> TH_TAG_END 1732 * | | | |--START -> < 1733 * | | | |--SLASH -> / 1734 * | | | |--TH_HTML_TAG_NAME -> th 1735 * | | | `--END -> > 1736 * | | `--TR_TAG_END -> TR_TAG_END 1737 * | | |--START -> < 1738 * | | |--SLASH -> / 1739 * | | |--TR_HTML_TAG_NAME -> tr 1740 * | | `--END -> > 1741 * | `--THEAD_TAG_END -> THEAD_TAG_END 1742 * | |--START -> < 1743 * | |--SLASH -> / 1744 * | |--THEAD_HTML_TAG_NAME -> thead 1745 * | `--END -> > 1746 * |--NEWLINE -> \n 1747 * |--TEXT -> 1748 * `--EOF -> <EOF> 1749 * } 1750 * </pre> 1751 */ 1752 public static final int THEAD_HTML_TAG_NAME = JavadocParser.THEAD_HTML_TAG_NAME; 1753 1754 /** `optgroup` tag name. */ 1755 public static final int OPTGROUP_HTML_TAG_NAME = JavadocParser.OPTGROUP_HTML_TAG_NAME; 1756 1757 /** `rb` tag name. */ 1758 public static final int RB_HTML_TAG_NAME = JavadocParser.RB_HTML_TAG_NAME; 1759 1760 /** `rt` tag name. */ 1761 public static final int RT_HTML_TAG_NAME = JavadocParser.RT_HTML_TAG_NAME; 1762 1763 /** `rtc` tag name. */ 1764 public static final int RTC_HTML_TAG_NAME = JavadocParser.RTC_HTML_TAG_NAME; 1765 1766 /** 1767 * RP tag name. 1768 * 1769 * <p><b>Example:</b></p> 1770 * <pre> 1771 * <rp>Fallback</rp> 1772 * </pre> 1773 * 1774 * <b>Tree:</b> 1775 * <pre> 1776 * {@code 1777 * HTML_ELEMENT -> HTML_ELEMENT 1778 * `--RP -> RP 1779 * |--RP_TAG_START -> RP_TAG_START 1780 * | |--START -> < 1781 * | |--RP_HTML_TAG_NAME -> rp 1782 * | `--END -> > 1783 * |--TEXT -> Fallback 1784 * `--RP_TAG_END -> RP_TAG_END 1785 * |--START -> < 1786 * |--SLASH -> / 1787 * |--RP_HTML_TAG_NAME -> rp 1788 * `--END -> > 1789 * } 1790 * </pre> 1791 */ 1792 public static final int RP_HTML_TAG_NAME = JavadocParser.RP_HTML_TAG_NAME; 1793 1794 /////////////////////////////////////////////////////////////////////////////////////////////// 1795 1796 /////////////////////// SINGLETON HTML TAGS ////////////////////////////////////////////////// 1797 /** 1798 * Area tag name. 1799 * 1800 * <p><b>Example:</b></p> 1801 * <pre>{@code < area shape="rect" >}</pre> 1802 * <b>Tree:</b> 1803 * <pre> 1804 * {@code 1805 * JAVADOC -> JAVADOC 1806 * |--NEWLINE -> \n 1807 * |--LEADING_ASTERISK -> * 1808 * |--TEXT -> 1809 * |--HTML_ELEMENT -> HTML_ELEMENT 1810 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1811 * | `--AREA_TAG -> AREA_TAG 1812 * | |--START -> < 1813 * | |--AREA_HTML_TAG_NAME -> area 1814 * | |--WS -> 1815 * | |--ATTRIBUTE -> ATTRIBUTE 1816 * | | |--HTML_TAG_NAME -> shape 1817 * | | |--EQUALS -> = 1818 * | | `--ATTR_VALUE -> "rect" 1819 * | `--END -> > 1820 * |--TEXT -> 1821 * |--NEWLINE -> \n 1822 * |--TEXT -> 1823 * } 1824 * </pre> 1825 */ 1826 1827 public static final int AREA_HTML_TAG_NAME = JavadocParser.AREA_HTML_TAG_NAME; 1828 1829 /** Base tag name. */ 1830 public static final int BASE_HTML_TAG_NAME = JavadocParser.BASE_HTML_TAG_NAME; 1831 1832 /** Basefont tag name. */ 1833 public static final int BASEFONT_HTML_TAG_NAME = JavadocParser.BASEFONT_HTML_TAG_NAME; 1834 1835 /** 1836 * Br tag name. 1837 * 1838 * <p><b>Example:</b></p> 1839 * <pre>{@code text before break < br > text after break}</pre> 1840 * <b>Tree:</b> 1841 * <pre> 1842 * {@code 1843 * `--JAVADOC -> JAVADOC 1844 * |--NEWLINE -> \r\n 1845 * |--LEADING_ASTERISK -> * 1846 * |--TEXT -> text before break 1847 * |--HTML_ELEMENT -> HTML_ELEMENT 1848 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1849 * | `--BR_TAG -> BR_TAG 1850 * | |--START -> < 1851 * | |--BR_HTML_TAG_NAME -> br 1852 * | `--END -> > 1853 * |--TEXT -> text after break 1854 * |--NEWLINE -> \r\n 1855 * |--TEXT -> 1856 * } 1857 * </pre> 1858 */ 1859 1860 public static final int BR_HTML_TAG_NAME = JavadocParser.BR_HTML_TAG_NAME; 1861 1862 /** Col tag name. */ 1863 public static final int COL_HTML_TAG_NAME = JavadocParser.COL_HTML_TAG_NAME; 1864 1865 /** 1866 * Frame tag name. 1867 * 1868 * <p><b>Example:</b></p> 1869 * <pre>{@code <frame src="frame_a.html">}</pre> 1870 * 1871 * <p><b>Tree:</b></p> 1872 * <pre> 1873 * {@code 1874 * |--HTML_ELEMENT -> HTML_ELEMENT 1875 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1876 * | `--FRAME_TAG -> FRAME_TAG 1877 * | |--START -> < 1878 * | |--FRAME_HTML_TAG_NAME -> frame 1879 * | |--WS -> 1880 * | |--ATTRIBUTE -> ATTRIBUTE 1881 * | | |--HTML_TAG_NAME -> src 1882 * | | |--EQUALS -> = 1883 * | | `--ATTR_VALUE -> "frame_a.html" 1884 * | `--END -> > 1885 * } 1886 * </pre> 1887 */ 1888 public static final int FRAME_HTML_TAG_NAME = JavadocParser.FRAME_HTML_TAG_NAME; 1889 1890 /** 1891 * Hr tag name. 1892 * 1893 * <p><b>Example:</b></p> 1894 * <pre>{@code text before horizontal rule < hr > text after horizontal rule}</pre> 1895 * <b>Tree:</b> 1896 * <pre> 1897 * {@code 1898 * |--TEXT -> text before horizontal rule 1899 * |--HTML_ELEMENT -> HTML_ELEMENT 1900 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1901 * | `--HR_TAG -> HR_TAG 1902 * | |--START -> < 1903 * | |--HR_HTML_TAG_NAME -> hr 1904 * | `--END -> > 1905 * |--TEXT -> text after horizontal rule 1906 * |--NEWLINE -> \r\n 1907 * } 1908 * </pre> 1909 */ 1910 1911 public static final int HR_HTML_TAG_NAME = JavadocParser.HR_HTML_TAG_NAME; 1912 1913 /** Img tag name. */ 1914 public static final int IMG_HTML_TAG_NAME = JavadocParser.IMG_HTML_TAG_NAME; 1915 1916 /** 1917 * Input tag name. 1918 * 1919 * <p><b>Example:</b></p> 1920 * <pre>{@code <input name="Name" type="text" placeholder="Enter your name"/>}</pre> 1921 * <b>Tree:</b> 1922 * <pre> 1923 * {@code 1924 * HTML_ELEMENT -> HTML_ELEMENT 1925 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1926 * `--INPUT_TAG -> INPUT_TAG 1927 * |--START -> < 1928 * |--INPUT_HTML_TAG_NAME -> input 1929 * |--WS -> 1930 * |--ATTRIBUTE -> ATTRIBUTE 1931 * | |--HTML_TAG_NAME -> name 1932 * | |--EQUALS -> = 1933 * | `--ATTR_VALUE -> "Name" 1934 * |--WS -> 1935 * |--ATTRIBUTE -> ATTRIBUTE 1936 * | |--HTML_TAG_NAME -> type 1937 * | |--EQUALS -> = 1938 * | `--ATTR_VALUE -> "text" 1939 * |--WS -> 1940 * |--ATTRIBUTE -> ATTRIBUTE 1941 * | |--HTML_TAG_NAME -> placeholder 1942 * | |--EQUALS -> = 1943 * | `--ATTR_VALUE -> "Enter your name" 1944 * `--SLASH_END -> /> 1945 * } 1946 * </pre> 1947 * 1948 * @see 1949 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1950 * comments are written in HTML</a> 1951 * @see #INPUT_HTML_TAG_NAME 1952 */ 1953 public static final int INPUT_HTML_TAG_NAME = JavadocParser.INPUT_HTML_TAG_NAME; 1954 1955 /** Isindex tag name. */ 1956 public static final int ISINDEX_HTML_TAG_NAME = JavadocParser.ISINDEX_HTML_TAG_NAME; 1957 1958 /** 1959 * Link tag name. 1960 * 1961 * <p><b>Example:</b></p> 1962 * <pre>{@code <link rel="stylesheet" href="Style.css">}</pre> 1963 * <b>Tree:</b> 1964 * <pre> 1965 * {@code 1966 * HTML_ELEMENT -> HTML_ELEMENT 1967 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1968 * `--LINK_TAG -> LINK_TAG 1969 * |--START -> < 1970 * |--LINK_HTML_TAG_NAME -> link 1971 * |--WS -> 1972 * |--ATTRIBUTE -> ATTRIBUTE 1973 * | |--HTML_TAG_NAME -> rel 1974 * | |--EQUALS -> = 1975 * | `--ATTR_VALUE -> "stylesheet" 1976 * |--WS -> 1977 * |--ATTRIBUTE -> ATTRIBUTE 1978 * | |--HTML_TAG_NAME -> href 1979 * | |--EQUALS -> = 1980 * | `--ATTR_VALUE -> "Style.css" 1981 * `--END -> > 1982 * } 1983 * </pre> 1984 * 1985 * @see 1986 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1987 * comments are written in HTML</a> 1988 * @see #LINK_HTML_TAG_NAME 1989 */ 1990 public static final int LINK_HTML_TAG_NAME = JavadocParser.LINK_HTML_TAG_NAME; 1991 1992 /** 1993 * Meta tag name. 1994 * 1995 * <p><b>Example:</b></p> 1996 * <pre>{@code <meta charset="UTF-8">}</pre> 1997 * <b>Tree:</b> 1998 * <pre> 1999 * {@code 2000 * HTML_ELEMENT -> HTML_ELEMENT 2001 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2002 * `--META_TAG -> META_TAG 2003 * |--START -> < 2004 * |--META_HTML_TAG_NAME -> meta 2005 * |--WS -> 2006 * |--ATTRIBUTE -> ATTRIBUTE 2007 * | |--HTML_TAG_NAME -> charset 2008 * | |--EQUALS -> = 2009 * | `--ATTR_VALUE -> "UTF-8" 2010 * `--END -> > 2011 * } 2012 * </pre> 2013 */ 2014 public static final int META_HTML_TAG_NAME = JavadocParser.META_HTML_TAG_NAME; 2015 2016 /** Param tag name. */ 2017 public static final int PARAM_HTML_TAG_NAME = JavadocParser.PARAM_HTML_TAG_NAME; 2018 /** "embed" tag name. */ 2019 public static final int EMBED_HTML_TAG_NAME = JavadocParser.EMBED_HTML_TAG_NAME; 2020 /** "keygen" tag name. */ 2021 public static final int KEYGEN_HTML_TAG_NAME = JavadocParser.KEYGEN_HTML_TAG_NAME; 2022 /** "source" tag name. */ 2023 public static final int SOURCE_HTML_TAG_NAME = JavadocParser.SOURCE_HTML_TAG_NAME; 2024 /** "track" tag name. */ 2025 public static final int TRACK_HTML_TAG_NAME = JavadocParser.TRACK_HTML_TAG_NAME; 2026 /** "wbr" tag name. */ 2027 public static final int WBR_HTML_TAG_NAME = JavadocParser.WBR_HTML_TAG_NAME; 2028 /////////////////////////////////////////////////////////////////////////////////////////////// 2029 2030 /** 2031 * HTML comment start symbol '<!--'. 2032 * 2033 * <p><b>Example:</b></p> 2034 * <pre> 2035 * <!-- 2036 * This is an HTML multi-line comment: 2037 * This is another comment 2038 * --> 2039 * </pre> 2040 * <b>Tree:</b> 2041 * <pre> 2042 * {@code 2043 * HTML_COMMENT -> HTML_COMMENT 2044 * |--HTML_COMMENT_START -> <!-- 2045 * |--NEWLINE -> \n 2046 * |--LEADING_ASTERISK -> * 2047 * |--TEXT -> This is an HTML multi-line comment: 2048 * |--NEWLINE -> \n 2049 * |--LEADING_ASTERISK -> * 2050 * |--TEXT -> This is another comment 2051 * |--NEWLINE -> \n 2052 * |--LEADING_ASTERISK -> * 2053 * |--TEXT -> 2054 * `--HTML_COMMENT_END -> --> 2055 * } 2056 * </pre> 2057 */ 2058 public static final int HTML_COMMENT_START = JavadocParser.HTML_COMMENT_START; 2059 2060 /** 2061 * HTML comment end symbol {@code '-->'} . 2062 * 2063 * <p><b>Example:</b></p> 2064 * <pre>{@code 2065 * <!-- 2066 * This is an HTML multi-line comment: 2067 * This is another comment 2068 * --> 2069 * }</pre> 2070 * <b>Tree:</b> 2071 * <pre> 2072 * {@code 2073 * HTML_COMMENT -> HTML_COMMENT 2074 * |--HTML_COMMENT_START -> <!-- 2075 * |--NEWLINE -> \n 2076 * |--LEADING_ASTERISK -> * 2077 * |--TEXT -> This is an HTML multi-line comment: 2078 * |--NEWLINE -> \n 2079 * |--LEADING_ASTERISK -> * 2080 * |--TEXT -> This is another comment 2081 * |--NEWLINE -> \n 2082 * |--LEADING_ASTERISK -> * 2083 * |--TEXT -> 2084 * `--HTML_COMMENT_END -> --> 2085 * } 2086 * </pre> 2087 */ 2088 public static final int HTML_COMMENT_END = JavadocParser.HTML_COMMENT_END; 2089 2090 // ------------------------------------------------------------------------------------------ // 2091 // ----------------- OTHER -------------------------------------------------- // 2092 // ------------------------------------------------------------------------------------------ // 2093 2094 /** Leading asterisk. */ 2095 public static final int LEADING_ASTERISK = JavadocParser.LEADING_ASTERISK; 2096 2097 /** 2098 * Newline symbol - '\n'. 2099 */ 2100 public static final int NEWLINE = JavadocParser.NEWLINE; 2101 2102 /** 2103 * Any other symbol. 2104 */ 2105 public static final int CHAR = JavadocParser.CHAR; 2106 2107 /** 2108 * Whitespace or tab ('\t') symbol. 2109 */ 2110 public static final int WS = JavadocParser.WS; 2111 2112 /** 2113 * End Of File symbol. Copied from 2114 * {@link org.antlr.v4.runtime.Recognizer#EOF} to avoid ANTLR dependency in 2115 * API. 2116 */ 2117 public static final int EOF = -1; 2118 2119 // ------------------------------------------------------------------------------------------ // 2120 // ------ JAVADOC TAGS DEPENDING ON RULE TYPES OFFSET --------------------------------------- // 2121 // ------------------------------------------------------------------------------------------ // 2122 2123 /** 2124 * Rule types offset. 2125 * RULE_TYPES_OFFSET constant is used to split lexer tokens types and parser rules types. 2126 * We need unique numbers for all tokens, 2127 * ANTLR do not need this and that is why these types are mixed by used values. 2128 * All values we can take a look at 2129 * target/generated-sources/antlr/com/puppycrawl/tools/checkstyle/grammar/javadoc/JavadocParser.java 2130 * For example: LEADING_ASTERISK=1 and RULE_htmlElement = 1. 2131 * RULE_TYPES_OFFSET required to shift parser rules, 2132 * to let them not overlap with types that have prefix "RULE_". 2133 */ 2134 private static final int RULE_TYPES_OFFSET = 10000; 2135 2136 /** 2137 * Root node of any Javadoc comment. 2138 * Last child is always {@link #EOF}. 2139 * 2140 * <p><b>Tree for example:</b></p> 2141 * <pre>{@code 2142 * JAVADOC -> JAVADOC 2143 * |--NEWLINE -> \n 2144 * |--LEADING_ASTERISK -> * 2145 * |--WS -> 2146 * |--JAVADOC_TAG -> JAVADOC_TAG 2147 * | |--PARAM_LITERAL -> @param 2148 * | |--WS -> 2149 * | |--PARAMETER_NAME -> T 2150 * | |--WS -> 2151 * | `--DESCRIPTION -> DESCRIPTION 2152 * | |--TEXT -> The bar. 2153 * | |--NEWLINE -> \n 2154 * | `--TEXT -> 2155 * `--EOF -> <EOF> 2156 * }</pre> 2157 */ 2158 public static final int JAVADOC = JavadocParser.RULE_javadoc + RULE_TYPES_OFFSET; 2159 2160 /** 2161 * Javadoc tag. 2162 * 2163 * <p>Type of Javadoc tag is resolved by literal node that is first child of this node.</p> 2164 * 2165 * <p>As literal could be:</p> 2166 * <ul> 2167 * <li>{@link #RETURN_LITERAL}</li> 2168 * <li>{@link #DEPRECATED_LITERAL}</li> 2169 * <li>{@link #SINCE_LITERAL}</li> 2170 * <li>{@link #SERIAL_DATA_LITERAL}</li> 2171 * <li>{@link #SERIAL_FIELD_LITERAL}</li> 2172 * <li>{@link #PARAM_LITERAL}</li> 2173 * <li>{@link #SEE_LITERAL}</li> 2174 * <li>{@link #SERIAL_LITERAL}</li> 2175 * <li>{@link #VERSION_LITERAL}</li> 2176 * <li>{@link #EXCEPTION_LITERAL}</li> 2177 * <li>{@link #THROWS_LITERAL}</li> 2178 * <li>{@link #AUTHOR_LITERAL}</li> 2179 * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc tag.</li> 2180 * </ul> 2181 * 2182 * <p><b>Example</b></p> 2183 * <pre>{@code @param T The bar.}</pre> 2184 * <b>Tree</b> 2185 * <pre>{@code 2186 * JAVADOC_TAG -> JAVADOC_TAG 2187 * |--PARAM_LITERAL -> @param 2188 * |--WS -> 2189 * |--PARAMETER_NAME -> T 2190 * |--WS -> 2191 * `--DESCRIPTION -> DESCRIPTION 2192 * |--TEXT -> The bar. 2193 * |--NEWLINE -> \r\n 2194 * `--TEXT -> 2195 * }</pre> 2196 */ 2197 2198 public static final int JAVADOC_TAG = JavadocParser.RULE_javadocTag + RULE_TYPES_OFFSET; 2199 /** 2200 * Javadoc inline tag. 2201 * 2202 * <p>Type of Javadoc inline tag is resolved by literal node that is second child of this node. 2203 * First child is always {@link #JAVADOC_INLINE_TAG_START} and last node is always 2204 * {@link #JAVADOC_INLINE_TAG_END}.</p> 2205 * 2206 * <p>As literal could be:</p> 2207 * <ul> 2208 * <li>{@link #CODE_LITERAL}</li> 2209 * <li>{@link #DOC_ROOT_LITERAL}</li> 2210 * <li>{@link #LINK_LITERAL}</li> 2211 * <li>{@link #INHERIT_DOC_LITERAL}</li> 2212 * <li>{@link #LINKPLAIN_LITERAL}</li> 2213 * <li>{@link #LITERAL_LITERAL}</li> 2214 * <li>{@link #VALUE_LITERAL}</li> 2215 * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc inline tag.</li> 2216 * </ul> 2217 * 2218 * <p><b>Example:</b></p> 2219 * <pre>{@literal {@link String} }</pre> 2220 * <b>Tree:</b> 2221 * <pre> 2222 * {@code 2223 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 2224 * |--JAVADOC_INLINE_TAG_START -> { 2225 * |--LINK_LITERAL -> @link 2226 * |--WS -> 2227 * |--REFERENCE -> REFERENCE 2228 * `--PACKAGE_CLASS -> String 2229 * `--JAVADOC_INLINE_TAG_END -> } 2230 * } 2231 * </pre> 2232 */ 2233 public static final int JAVADOC_INLINE_TAG = JavadocParser.RULE_javadocInlineTag 2234 + RULE_TYPES_OFFSET; 2235 2236 /** 2237 * Parameter of the Javadoc tags listed below. 2238 * <ul> 2239 * <li>{@link #SEE_LITERAL @see}</li> 2240 * <li>{@link #LINK_LITERAL {@link}}</li> 2241 * <li>{@link #LINKPLAIN_LITERAL {@linkplain}}</li> 2242 * <li>{@link #VALUE_LITERAL {@value}}</li> 2243 * </ul> 2244 */ 2245 public static final int REFERENCE = JavadocParser.RULE_reference + RULE_TYPES_OFFSET; 2246 2247 /** 2248 * Parameters part in {@link #REFERENCE}. 2249 * It is used to specify parameters for {@link #MEMBER method}. 2250 * Always contains {@link #LEFT_BRACE} as first child and {@link #RIGHT_BRACE} as last child. 2251 * Each parameter is represented by {@link #ARGUMENT} node. 2252 * Arguments in braces are separated by {@link #COMMA} (and optional {@link #WS}). 2253 * 2254 * <p><b>Example:</b></p> 2255 * <pre>{@code @see #method(Processor, String)}</pre> 2256 * <b>Tree:</b> 2257 * <pre> 2258 * {@code 2259 * JAVADOC_TAG -> JAVADOC_TAG 2260 * |--SEE_LITERAL -> @see 2261 * |--WS -> 2262 * |--REFERENCE -> REFERENCE 2263 * |--HASH -> # 2264 * |--MEMBER -> method 2265 * `--PARAMETERS -> PARAMETERS 2266 * |--LEFT_BRACE -> ( 2267 * |--ARGUMENT -> Processor 2268 * |--COMMA -> , 2269 * |--WS -> 2270 * |--ARGUMENT -> String 2271 * `--RIGHT_BRACE -> ) 2272 * } 2273 * </pre> 2274 */ 2275 public static final int PARAMETERS = JavadocParser.RULE_parameters + RULE_TYPES_OFFSET; 2276 2277 /** 2278 * Description node. It contains: 2279 * <ul> 2280 * <li>{@link #TEXT}</li> 2281 * <li>{@link #WS}</li> 2282 * <li>{@link #NEWLINE}</li> 2283 * <li>{@link #HTML_ELEMENT}</li> 2284 * </ul> 2285 * 2286 * <p>It is argument for many Javadoc tags and inline tags.</p> 2287 * 2288 * <p><b>Example:</b></p> 2289 * <pre>{@code @throws IOException if <b>connection</b> problems occur}</pre> 2290 * <b>Tree:</b> 2291 * <pre> 2292 * {@code 2293 * --JAVADOC_TAG -> JAVADOC_TAG 2294 * |--THROWS_LITERAL -> @throws 2295 * |--WS -> 2296 * |--CLASS_NAME -> IOException 2297 * |--WS -> 2298 * `--DESCRIPTION -> DESCRIPTION 2299 * |--TEXT -> if 2300 * |--HTML_ELEMENT -> HTML_ELEMENT 2301 * | `--HTML_TAG -> HTML_TAG 2302 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 2303 * | | |--START -> < 2304 * | | |--HTML_TAG_NAME -> b 2305 * | | `--END -> > 2306 * | |--TEXT -> connection 2307 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 2308 * | |--START -> < 2309 * | |--SLASH -> / 2310 * | |--HTML_TAG_NAME -> b 2311 * | `--END -> > 2312 * |--TEXT -> problems occur 2313 * } 2314 * </pre> 2315 */ 2316 public static final int DESCRIPTION = JavadocParser.RULE_description + RULE_TYPES_OFFSET; 2317 2318 // ------------------------------------------------------------------------------------------ // 2319 // -------- HTML TAGS DEPENDING ON RULE TYPES OFFSET ---------------------------------------- // 2320 // ------------------------------------------------------------------------------------------ // 2321 2322 /** 2323 * Parent node for all html tags. 2324 */ 2325 public static final int HTML_ELEMENT = JavadocParser.RULE_htmlElement 2326 + RULE_TYPES_OFFSET; 2327 2328 /** 2329 * Start html tag: {@code <XXXX>}. 2330 */ 2331 public static final int HTML_ELEMENT_START = JavadocParser.RULE_htmlElementStart 2332 + RULE_TYPES_OFFSET; 2333 2334 /** 2335 * End html tag: {@code <XXXX>}. 2336 */ 2337 public static final int HTML_ELEMENT_END = JavadocParser.RULE_htmlElementEnd 2338 + RULE_TYPES_OFFSET; 2339 2340 /** 2341 * Non-special HTML tag. 2342 */ 2343 public static final int HTML_TAG = JavadocParser.RULE_htmlTag + RULE_TYPES_OFFSET; 2344 2345 /** 2346 * Html tag attribute. Parent node for: {@code HTML_TAG_IDENT, EQUALS, ATTR_VALUE}. 2347 * 2348 * <p><b>Example</b></p> 2349 * <pre>{@code <p class="highlight">Sample text</p>}</pre> 2350 * <b>Tree</b> 2351 * <pre> 2352 * {@code 2353 * HTML_ELEMENT -> HTML_ELEMENT 2354 * `--PARAGRAPH -> PARAGRAPH 2355 * |--P_TAG_START -> P_TAG_START 2356 * | |--START -> < 2357 * | |--P_HTML_TAG_NAME -> p 2358 * | |--WS -> 2359 * | |--ATTRIBUTE -> ATTRIBUTE 2360 * | | |--HTML_TAG_NAME -> class 2361 * | | |--EQUALS -> = 2362 * | | `--ATTR_VALUE -> "highlight" 2363 * | `--END -> > 2364 * |--TEXT -> Sample text 2365 * `--P_TAG_END -> P_TAG_END 2366 * |--START -> < 2367 * |--SLASH -> / 2368 * |--P_HTML_TAG_NAME -> p 2369 * `--END -> > 2370 * } 2371 * </pre> 2372 */ 2373 public static final int ATTRIBUTE = JavadocParser.RULE_attribute 2374 + RULE_TYPES_OFFSET; 2375 2376 /////////////////////// HTML TAGS WITH OPTIONAL END TAG ///////////////////////////////////// 2377 /** 2378 * Paragraph html tag. 2379 * 2380 * <p><b>Example:</b></p> 2381 * <pre>{@code <p>Sample text</p>}</pre> 2382 * <b>Tree:</b> 2383 * <pre> 2384 * {@code 2385 * `--JAVADOC -> JAVADOC 2386 * |--NEWLINE -> \r\n 2387 * |--LEADING_ASTERISK -> * 2388 * |--TEXT -> 2389 * |--HTML_ELEMENT -> HTML_ELEMENT 2390 * | `--PARAGRAPH -> PARAGRAPH 2391 * | |--P_TAG_START -> P_TAG_START 2392 * | | |--START -> < 2393 * | | |--P_HTML_TAG_NAME -> p 2394 * | | `--END -> > 2395 * | |--TEXT -> Sample text 2396 * | `--P_TAG_END -> P_TAG_END 2397 * | |--START -> < 2398 * | |--SLASH -> / 2399 * | |--P_HTML_TAG_NAME -> p 2400 * | `--END -> > 2401 * |--NEWLINE -> \r\n 2402 * |--TEXT -> 2403 * } 2404 * </pre> 2405 */ 2406 public static final int PARAGRAPH = JavadocParser.RULE_paragraph + RULE_TYPES_OFFSET; 2407 /** Start paragraph tag. */ 2408 public static final int P_TAG_START = JavadocParser.RULE_pTagStart + RULE_TYPES_OFFSET; 2409 /** End paragraph tag. */ 2410 public static final int P_TAG_END = JavadocParser.RULE_pTagEnd + RULE_TYPES_OFFSET; 2411 2412 /** 2413 * List items html tag. 2414 * 2415 * <p><b>Example:</b></p> 2416 * <pre>{@code 2417 * <ul> 2418 * <li>Item 1</li> 2419 * </ul> 2420 * }</pre> 2421 * <b>Tree:</b> 2422 * <pre> 2423 * {@code 2424 * --JAVADOC -> JAVADOC 2425 * |--NEWLINE -> \n 2426 * |--LEADING_ASTERISK -> * 2427 * |--TEXT -> 2428 * |--HTML_ELEMENT -> HTML_ELEMENT 2429 * | `--HTML_TAG -> HTML_TAG 2430 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 2431 * | | |--START -> < 2432 * | | |--HTML_TAG_NAME -> ul 2433 * | | `--END -> > 2434 * | |--NEWLINE -> \n 2435 * | |--LEADING_ASTERISK -> * 2436 * | |--TEXT -> 2437 * | |--HTML_ELEMENT -> HTML_ELEMENT 2438 * | | `--LI -> LI 2439 * | | |--LI_TAG_START -> LI_TAG_START 2440 * | | | |--START -> < 2441 * | | | |--LI_HTML_TAG_NAME -> li 2442 * | | | `--END -> > 2443 * | | |--TEXT -> Item 1 2444 * | | `--LI_TAG_END -> LI_TAG_END 2445 * | | |--START -> < 2446 * | | |--SLASH -> / 2447 * | | |--LI_HTML_TAG_NAME -> li 2448 * | | `--END -> > 2449 * | |--NEWLINE -> \n 2450 * | |--LEADING_ASTERISK -> * 2451 * | |--TEXT -> 2452 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 2453 * | |--START -> < 2454 * | |--SLASH -> / 2455 * | |--HTML_TAG_NAME -> ul 2456 * | `--END -> > 2457 * |--NEWLINE -> \n 2458 * |--TEXT -> 2459 * } 2460 * </pre> 2461 */ 2462 public static final int LI = JavadocParser.RULE_li + RULE_TYPES_OFFSET; 2463 /** Start list item tag. */ 2464 public static final int LI_TAG_START = JavadocParser.RULE_liTagStart + RULE_TYPES_OFFSET; 2465 /** End list item tag. */ 2466 public static final int LI_TAG_END = JavadocParser.RULE_liTagEnd + RULE_TYPES_OFFSET; 2467 2468 /** 2469 * Table row html tag. 2470 * 2471 * <p><b>Example:</b></p> 2472 * <pre>{@code <tr></tr>}</pre> 2473 * <b>Tree:</b> 2474 * <pre> 2475 * {@code 2476 * JAVADOC -> JAVADOC 2477 * |--NEWLINE -> \r\n 2478 * |--LEADING_ASTERISK -> * 2479 * |--TEXT -> 2480 * |--HTML_ELEMENT -> HTML_ELEMENT 2481 * | `--TR -> TR 2482 * | |--TR_TAG_START -> TR_TAG_START 2483 * | | |--START -> < 2484 * | | |--TR_HTML_TAG_NAME -> tr 2485 * | | `--END -> > 2486 * | `--TR_TAG_END -> TR_TAG_END 2487 * | |--START -> < 2488 * | |--SLASH -> / 2489 * | |--TR_HTML_TAG_NAME -> tr 2490 * | `--END -> > 2491 * |--NEWLINE -> \r\n 2492 * |--TEXT -> 2493 * } 2494 * </pre> 2495 */ 2496 public static final int TR = JavadocParser.RULE_tr + RULE_TYPES_OFFSET; 2497 /** Start table row tag. */ 2498 public static final int TR_TAG_START = JavadocParser.RULE_trTagStart + RULE_TYPES_OFFSET; 2499 /** End table row tag. */ 2500 public static final int TR_TAG_END = JavadocParser.RULE_trTagEnd + RULE_TYPES_OFFSET; 2501 2502 /** 2503 * Table cell HTML tag. 2504 * 2505 * <p><b>Example:</b></p> 2506 * <pre>{@code <td>Cell Content</td>}</pre> 2507 * <b>Tree:</b> 2508 * <pre> 2509 * {@code 2510 * HTML_ELEMENT -> HTML_ELEMENT 2511 * `--TD -> TD 2512 * |--TD_TAG_START -> TD_TAG_START 2513 * | |--START -> < 2514 * | |--TD_HTML_TAG_NAME -> td 2515 * | `--END -> > 2516 * |--TEXT -> Cell Content 2517 * `--TD_TAG_END -> TD_TAG_END 2518 * |--START -> < 2519 * |--SLASH -> / 2520 * |--TD_HTML_TAG_NAME -> td 2521 * `--END -> > 2522 * } 2523 * </pre> 2524 */ 2525 public static final int TD = JavadocParser.RULE_td + RULE_TYPES_OFFSET; 2526 /** Start table cell tag. */ 2527 public static final int TD_TAG_START = JavadocParser.RULE_tdTagStart + RULE_TYPES_OFFSET; 2528 /** End table cell tag. */ 2529 public static final int TD_TAG_END = JavadocParser.RULE_tdTagEnd + RULE_TYPES_OFFSET; 2530 2531 /** Table header cell html tag: {@code <th></th>}. */ 2532 public static final int TH = JavadocParser.RULE_th + RULE_TYPES_OFFSET; 2533 /** Start table header cell tag. */ 2534 public static final int TH_TAG_START = JavadocParser.RULE_thTagStart + RULE_TYPES_OFFSET; 2535 /** End table header cell tag. */ 2536 public static final int TH_TAG_END = JavadocParser.RULE_thTagEnd + RULE_TYPES_OFFSET; 2537 2538 /** Body html tag. */ 2539 public static final int BODY = JavadocParser.RULE_body + RULE_TYPES_OFFSET; 2540 2541 /** 2542 * Start body tag. 2543 * 2544 * <p><b>Example:</b></p> 2545 * <pre> 2546 * <body> 2547 * This is a test 2548 * </body> 2549 * </pre> 2550 * <b>Tree:</b> 2551 * <pre> 2552 * {@code 2553 * JAVADOC -> JAVADOC 2554 * |--TEXT -> /** 2555 * |--NEWLINE -> \n 2556 * |--LEADING_ASTERISK -> * 2557 * |--TEXT -> 2558 * |--HTML_ELEMENT -> HTML_ELEMENT 2559 * | `--BODY -> BODY 2560 * | |--BODY_TAG_START -> BODY_TAG_START 2561 * | | |--START -> < 2562 * | | |--BODY_HTML_TAG_NAME -> body 2563 * | | `--END -> > 2564 * | |--NEWLINE -> \n 2565 * | |--LEADING_ASTERISK -> * 2566 * | |--TEXT -> This is inside the body tag. 2567 * | |--NEWLINE -> \n 2568 * | |--LEADING_ASTERISK -> * 2569 * | |--TEXT -> 2570 * | `--BODY_TAG_END -> BODY_TAG_END 2571 * | |--START -> < 2572 * | |--SLASH -> / 2573 * | |--BODY_HTML_TAG_NAME -> body 2574 * | `--END -> > 2575 * |--NEWLINE -> \n 2576 * |--LEADING_ASTERISK -> * 2577 * |--TEXT -> / 2578 * |--NEWLINE -> \n 2579 * |--TEXT -> public class Test { 2580 * |--NEWLINE -> \n 2581 * |--TEXT -> } 2582 * |--NEWLINE -> \n 2583 * } 2584 * </pre> 2585 */ 2586 public static final int BODY_TAG_START = JavadocParser.RULE_bodyTagStart + RULE_TYPES_OFFSET; 2587 2588 /** 2589 * End body tag. 2590 * 2591 * <p><b>Example:</b></p> 2592 * <pre> 2593 * <body> 2594 * This is a test 2595 * </body> 2596 * </pre> 2597 * <b>Tree:</b> 2598 * <pre> 2599 * {@code 2600 * JAVADOC -> JAVADOC 2601 * |--TEXT -> /** 2602 * |--NEWLINE -> \n 2603 * |--LEADING_ASTERISK -> * 2604 * |--TEXT -> 2605 * |--HTML_ELEMENT -> HTML_ELEMENT 2606 * | `--BODY -> BODY 2607 * | |--BODY_TAG_START -> BODY_TAG_START 2608 * | | |--START -> < 2609 * | | |--BODY_HTML_TAG_NAME -> body 2610 * | | `--END -> > 2611 * | |--NEWLINE -> \n 2612 * | |--LEADING_ASTERISK -> * 2613 * | |--TEXT -> This is inside the body tag. 2614 * | |--NEWLINE -> \n 2615 * | |--LEADING_ASTERISK -> * 2616 * | |--TEXT -> 2617 * | `--BODY_TAG_END -> BODY_TAG_END 2618 * | |--START -> < 2619 * | |--SLASH -> / 2620 * | |--BODY_HTML_TAG_NAME -> body 2621 * | `--END -> > 2622 * |--NEWLINE -> \n 2623 * |--LEADING_ASTERISK -> * 2624 * |--TEXT -> / 2625 * |--NEWLINE -> \n 2626 * |--TEXT -> public class Test { 2627 * |--NEWLINE -> \n 2628 * |--TEXT -> } 2629 * |--NEWLINE -> \n 2630 * } 2631 * </pre> 2632 */ 2633 public static final int BODY_TAG_END = JavadocParser.RULE_bodyTagEnd + RULE_TYPES_OFFSET; 2634 2635 /** 2636 * Colgroup html tag. 2637 * 2638 * <p><b>Example:</b></p> 2639 * <pre>{@code 2640 * <colgroup> 2641 * <col /> 2642 * <col span="2" class="batman" /> 2643 * </colgroup> 2644 * }</pre> 2645 * <b>Tree:</b> 2646 * <pre> 2647 * {@code 2648 * --JAVADOC -> JAVADOC 2649 * |--NEWLINE -> \n 2650 * |--LEADING_ASTERISK -> * 2651 * |--TEXT -> 2652 * |--HTML_ELEMENT -> HTML_ELEMENT 2653 * | `--COLGROUP -> COLGROUP 2654 * | |--COLGROUP_TAG_START -> COLGROUP_TAG_START 2655 * | | |--START -> < 2656 * | | |--COLGROUP_HTML_TAG_NAME -> colgroup 2657 * | | | `--END -> > 2658 * | |--NEWLINE -> \n 2659 * | |--LEADING_ASTERISK -> * 2660 * | |--TEXT -> 2661 * | |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2662 * | | `--COL_TAG -> COL_TAG 2663 * | | |--START -> < 2664 * | | |--COL_HTML_TAG_NAME -> col 2665 * | | |--WS -> 2666 * | | `--SLASH_END -> /> 2667 * | |--NEWLINE -> \n 2668 * | |--LEADING_ASTERISK -> * 2669 * | |--TEXT -> 2670 * | |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2671 * | | `--COL_TAG -> COL_TAG 2672 * | | |--START -> < 2673 * | | |--COL_HTML_TAG_NAME -> col 2674 * | | |--WS -> 2675 * | | |--ATTRIBUTE -> ATTRIBUTE 2676 * | | | |--HTML_TAG_NAME -> span 2677 * | | | |--EQUALS -> = 2678 * | | | `--ATTR_VALUE -> "2" 2679 * | | |--WS -> 2680 * | | |--ATTRIBUTE -> ATTRIBUTE 2681 * | | | |--HTML_TAG_NAME -> class 2682 * | | | |--EQUALS -> = 2683 * | | | `--ATTR_VALUE -> "batman" 2684 * | | |--WS -> 2685 * | | `--SLASH_END -> /> 2686 * | |--NEWLINE -> \n 2687 * | |--LEADING_ASTERISK -> * 2688 * | |--TEXT -> 2689 * | `--COLGROUP_TAG_END -> COLGROUP_TAG_END 2690 * | | |--START -> < 2691 * | | |--SLASH -> / 2692 * | | |--COLGROUP_HTML_TAG_NAME -> colgroup 2693 * | | `--END -> > 2694 * |--NEWLINE -> \n 2695 * |--TEXT -> 2696 * } 2697 * </pre> 2698 */ 2699 public static final int COLGROUP = JavadocParser.RULE_colgroup + RULE_TYPES_OFFSET; 2700 /** Start colgroup tag. */ 2701 public static final int COLGROUP_TAG_START = JavadocParser.RULE_colgroupTagStart 2702 + RULE_TYPES_OFFSET; 2703 /** End colgroup tag. */ 2704 public static final int COLGROUP_TAG_END = JavadocParser.RULE_colgroupTagEnd 2705 + RULE_TYPES_OFFSET; 2706 2707 /** 2708 * DD html tag. 2709 * 2710 * <p><b>Example AST:</b></p> 2711 * <pre>{@code <dd>Description content</dd>}</pre> 2712 * <pre> 2713 * {@code 2714 * --HTML_ELEMENT -> HTML_ELEMENT 2715 * `--DD -> DD 2716 * |--DD_TAG_START -> DD_TAG_START 2717 * | |--START -> < 2718 * | |--DD_HTML_TAG_NAME -> dd 2719 * | `--END -> > 2720 * |--TEXT -> "Description content" 2721 * `--DD_TAG_END -> DD_TAG_END 2722 * |--START -> < 2723 * |--SLASH -> / 2724 * |--DD_HTML_TAG_NAME -> dd 2725 * `--END -> > 2726 * } 2727 * </pre> 2728 */ 2729 public static final int DD = JavadocParser.RULE_dd + RULE_TYPES_OFFSET; 2730 /** Start description of a term tag. */ 2731 public static final int DD_TAG_START = JavadocParser.RULE_ddTagStart + RULE_TYPES_OFFSET; 2732 /** End description of a term tag. */ 2733 public static final int DD_TAG_END = JavadocParser.RULE_ddTagEnd + RULE_TYPES_OFFSET; 2734 2735 /** 2736 * DT html tag. 2737 * 2738 * <p><b>Example AST:</b></p> 2739 * <pre>{@code <dd>Description Term</dd>}</pre> 2740 * <pre> 2741 * {@code 2742 * --HTML_ELEMENT -> HTML_ELEMENT 2743 * `--DT -> DT 2744 * |--DT_TAG_START -> DT_TAG_START 2745 * | |--START -> < 2746 * | |--DT_HTML_TAG_NAME -> dt 2747 * | `--END -> > 2748 * |--TEXT -> "Description term" 2749 * `--DT_TAG_END -> DT_TAG_END 2750 * |--START -> < 2751 * |--SLASH -> / 2752 * |--DT_HTML_TAG_NAME -> dt 2753 * `--END -> > 2754 * } 2755 * </pre> 2756 */ 2757 public static final int DT = JavadocParser.RULE_dt + RULE_TYPES_OFFSET; 2758 /** Start description term tag. */ 2759 public static final int DT_TAG_START = JavadocParser.RULE_dtTagStart + RULE_TYPES_OFFSET; 2760 /** End description term tag. */ 2761 public static final int DT_TAG_END = JavadocParser.RULE_dtTagEnd + RULE_TYPES_OFFSET; 2762 2763 /** Head html tag. */ 2764 public static final int HEAD = JavadocParser.RULE_head + RULE_TYPES_OFFSET; 2765 /** Start head tag. */ 2766 public static final int HEAD_TAG_START = JavadocParser.RULE_headTagStart + RULE_TYPES_OFFSET; 2767 /** End head tag. */ 2768 public static final int HEAD_TAG_END = JavadocParser.RULE_headTagEnd + RULE_TYPES_OFFSET; 2769 2770 /** Html html tag. */ 2771 public static final int HTML = JavadocParser.RULE_html + RULE_TYPES_OFFSET; 2772 /** Start html tag. */ 2773 public static final int HTML_TAG_START = JavadocParser.RULE_htmlTagStart + RULE_TYPES_OFFSET; 2774 /** End html tag. */ 2775 public static final int HTML_TAG_END = JavadocParser.RULE_htmlTagEnd + RULE_TYPES_OFFSET; 2776 2777 /** Option html tag. */ 2778 public static final int OPTION = JavadocParser.RULE_option + RULE_TYPES_OFFSET; 2779 /** Start option tag. */ 2780 public static final int OPTION_TAG_START = 2781 JavadocParser.RULE_optionTagStart + RULE_TYPES_OFFSET; 2782 /** End option tag. */ 2783 public static final int OPTION_TAG_END = JavadocParser.RULE_optionTagEnd 2784 + RULE_TYPES_OFFSET; 2785 2786 /** 2787 * Table body html tag. 2788 * 2789 * <p><b>Example:</b></p> 2790 * <pre>{@code <table><tbody></tbody></table>}</pre> 2791 * <b>Tree:</b> 2792 * <pre> 2793 * {@code 2794 * JAVADOC -> JAVADOC 2795 * |--NEWLINE -> \r\n 2796 * |--LEADING_ASTERISK -> * 2797 * |--TEXT -> 2798 * |--HTML_ELEMENT -> HTML_ELEMENT 2799 * | `--HTML_TAG -> HTML_TAG 2800 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 2801 * | | |--START -> < 2802 * | | |--HTML_TAG_NAME -> table 2803 * | | `--END -> > 2804 * | |--HTML_ELEMENT -> HTML_ELEMENT 2805 * | | `--TBODY -> TBODY 2806 * | | |--TBODY_TAG_START -> TBODY_TAG_START 2807 * | | | |--START -> < 2808 * | | | |--TBODY_HTML_TAG_NAME -> tbody 2809 * | | | `--END -> > 2810 * | | `--TBODY_TAG_END -> TBODY_TAG_END 2811 * | | |--START -> < 2812 * | | |--SLASH -> / 2813 * | | |--TBODY_HTML_TAG_NAME -> tbody 2814 * | | `--END -> > 2815 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 2816 * | |--START -> < 2817 * | |--SLASH -> / 2818 * | |--HTML_TAG_NAME -> table 2819 * | `--END -> > 2820 * |--NEWLINE -> \r\n 2821 * } 2822 * </pre> 2823 */ 2824 public static final int TBODY = JavadocParser.RULE_tbody + RULE_TYPES_OFFSET; 2825 /** Start table body tag. */ 2826 public static final int TBODY_TAG_START = JavadocParser.RULE_tbodyTagStart + RULE_TYPES_OFFSET; 2827 /** End table body tag. */ 2828 public static final int TBODY_TAG_END = JavadocParser.RULE_tbodyTagEnd + RULE_TYPES_OFFSET; 2829 2830 /** Table foot html tag. */ 2831 public static final int TFOOT = JavadocParser.RULE_tfoot + RULE_TYPES_OFFSET; 2832 /** Start table foot tag. */ 2833 public static final int TFOOT_TAG_START = JavadocParser.RULE_tfootTagStart + RULE_TYPES_OFFSET; 2834 /** End table foot tag. */ 2835 public static final int TFOOT_TAG_END = JavadocParser.RULE_tfootTagEnd + RULE_TYPES_OFFSET; 2836 2837 /** Table head html tag. */ 2838 public static final int THEAD = JavadocParser.RULE_thead + RULE_TYPES_OFFSET; 2839 /** Start table head tag. */ 2840 public static final int THEAD_TAG_START = JavadocParser.RULE_theadTagStart + RULE_TYPES_OFFSET; 2841 /** End table head tag. */ 2842 public static final int THEAD_TAG_END = JavadocParser.RULE_theadTagEnd + RULE_TYPES_OFFSET; 2843 2844 /** `optgroup` html tag. */ 2845 public static final int OPTGROUP = JavadocParser.RULE_optgroup + RULE_TYPES_OFFSET; 2846 /** `optgroup` tag start. */ 2847 public static final int OPTGROUP_TAG_START = 2848 JavadocParser.RULE_optgroupTagStart + RULE_TYPES_OFFSET; 2849 /** `optgroup` tag end. */ 2850 public static final int OPTGROUP_TAG_END = 2851 JavadocParser.RULE_optgroupTagEnd + RULE_TYPES_OFFSET; 2852 2853 /** `rb` html tag. */ 2854 public static final int RB = JavadocParser.RULE_rb + RULE_TYPES_OFFSET; 2855 /** `rb` tag start. */ 2856 public static final int RB_TAG_START = 2857 JavadocParser.RULE_rbTagStart + RULE_TYPES_OFFSET; 2858 /** `rb` tag end. */ 2859 public static final int RB_TAG_END = 2860 JavadocParser.RULE_rbTagEnd + RULE_TYPES_OFFSET; 2861 2862 /** `rt` html tag. */ 2863 public static final int RT = JavadocParser.RULE_rt + RULE_TYPES_OFFSET; 2864 /** `rt` tag start. */ 2865 public static final int RT_TAG_START = 2866 JavadocParser.RULE_rtTagStart + RULE_TYPES_OFFSET; 2867 /** `rt` tag end. */ 2868 public static final int RT_TAG_END = 2869 JavadocParser.RULE_rtTagEnd + RULE_TYPES_OFFSET; 2870 2871 /** `rtc` html tag. */ 2872 public static final int RTC = JavadocParser.RULE_rtc + RULE_TYPES_OFFSET; 2873 /** `rtc` tag start. */ 2874 public static final int RTC_TAG_START = 2875 JavadocParser.RULE_rtcTagStart + RULE_TYPES_OFFSET; 2876 /** `rtc` tag end. */ 2877 public static final int RTC_TAG_END = 2878 JavadocParser.RULE_rtcTagEnd + RULE_TYPES_OFFSET; 2879 2880 /** `rp` html tag. */ 2881 public static final int RP = JavadocParser.RULE_rp + RULE_TYPES_OFFSET; 2882 /** `rp` tag start. */ 2883 public static final int RP_TAG_START = 2884 JavadocParser.RULE_rpTagStart + RULE_TYPES_OFFSET; 2885 /** `rp` tag end. */ 2886 public static final int RP_TAG_END = 2887 JavadocParser.RULE_rpTagEnd + RULE_TYPES_OFFSET; 2888 2889 /////////////////////// SINGLETON HTML TAGS ////////////////////////////////////////////////// 2890 /** 2891 * Parent node for all singleton html tags. 2892 */ 2893 public static final int SINGLETON_ELEMENT = JavadocParser.RULE_singletonElement 2894 + RULE_TYPES_OFFSET; 2895 2896 /** 2897 * Represents an empty (self-closing) HTML tag in Javadoc comments, 2898 * such as {@code <justsometag />}. 2899 * 2900 * <p><b>Example:</b></p> 2901 * <pre>{@code <justsometag />}</pre> 2902 * 2903 * <p><b>AST Tree:</b></p> 2904 * <pre>{@code 2905 * --HTML_ELEMENT -> HTML_ELEMENT 2906 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2907 * `--EMPTY_TAG -> EMPTY_TAG 2908 * |--START -> < 2909 * |--HTML_TAG_NAME -> justsometag 2910 * |--WS 2911 * `--SLASH_END -> > 2912 * }</pre> 2913 */ 2914 public static final int EMPTY_TAG = 2915 JavadocParser.RULE_emptyTag + RULE_TYPES_OFFSET; 2916 2917 /** 2918 * Area html tag. 2919 * 2920 * <p><b>Example:</b></p> 2921 * <pre>{@code < area shape="rect" >}</pre> 2922 * <b>Tree:</b> 2923 * <pre> 2924 * {@code 2925 * JAVADOC -> JAVADOC 2926 * |--NEWLINE -> \n 2927 * |--LEADING_ASTERISK -> * 2928 * |--TEXT -> 2929 * |--HTML_ELEMENT -> HTML_ELEMENT 2930 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2931 * | `--AREA_TAG -> AREA_TAG 2932 * | |--START -> < 2933 * | |--AREA_HTML_TAG_NAME -> area 2934 * | |--WS -> 2935 * | |--ATTRIBUTE -> ATTRIBUTE 2936 * | | |--HTML_TAG_NAME -> shape 2937 * | | |--EQUALS -> = 2938 * | | `--ATTR_VALUE -> "rect" 2939 * | `--END -> > 2940 * |--TEXT -> 2941 * |--NEWLINE -> \n 2942 * |--TEXT -> 2943 * } 2944 * </pre> 2945 */ 2946 public static final int AREA_TAG = JavadocParser.RULE_areaTag + RULE_TYPES_OFFSET; 2947 2948 /** Base html tag. */ 2949 public static final int BASE_TAG = JavadocParser.RULE_baseTag + RULE_TYPES_OFFSET; 2950 2951 /** Basefont html tag. */ 2952 public static final int BASEFONT_TAG = JavadocParser.RULE_basefontTag + RULE_TYPES_OFFSET; 2953 2954 /** 2955 * Br html tag. 2956 * 2957 * <p><b>Example:</b></p> 2958 * <pre>{@code <br> line breaks<br/>}</pre> 2959 * <b>Tree:</b> 2960 * <pre> 2961 * {@code 2962 * JAVADOC -> JAVADOC 2963 * |--NEWLINE -> \r\n 2964 * |--LEADING_ASTERISK -> * 2965 * |--TEXT -> 2966 * |--HTML_ELEMENT -> HTML_ELEMENT 2967 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2968 * | `--BR_TAG -> BR_TAG 2969 * | |--START -> < 2970 * | |--BR_HTML_TAG_NAME -> br 2971 * | `--END -> > 2972 * |--TEXT -> line breaks 2973 * |--HTML_ELEMENT -> HTML_ELEMENT 2974 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2975 * | `--BR_TAG -> BR_TAG 2976 * | |--START -> < 2977 * | |--BR_HTML_TAG_NAME -> br 2978 * | `--SLASH_END -> /> 2979 * } 2980 * </pre> 2981 */ 2982 public static final int BR_TAG = JavadocParser.RULE_brTag + RULE_TYPES_OFFSET; 2983 2984 /** Col html tag. */ 2985 public static final int COL_TAG = JavadocParser.RULE_colTag + RULE_TYPES_OFFSET; 2986 2987 /** 2988 * Frame html tag. 2989 * 2990 * <p><b>Example:</b></p> 2991 * <pre> 2992 * <frameset cols="50%,50%"> 2993 * <frame src="page1.html"> 2994 * </frameset> 2995 * </pre> 2996 * <b>Tree:</b> 2997 * <pre> 2998 * {@code 2999 * HTML_ELEMENT -> HTML_ELEMENT 3000 * `--HTML_TAG -> HTML_TAG 3001 * |--HTML_ELEMENT_START -> HTML_ELEMENT_START 3002 * | |--START -> < 3003 * | |--HTML_TAG_NAME -> frameset 3004 * | |--WS -> 3005 * | |--ATTRIBUTE -> ATTRIBUTE 3006 * | | |--HTML_TAG_NAME -> cols 3007 * | | |--EQUALS -> = 3008 * | | `--ATTR_VALUE -> "50%,50%" 3009 * | `--END -> > 3010 * |--NEWLINE -> \r\n 3011 * |--LEADING_ASTERISK -> * 3012 * |--TEXT -> 3013 * |--HTML_ELEMENT -> HTML_ELEMENT 3014 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3015 * | `--FRAME_TAG -> FRAME_TAG 3016 * | |--START -> < 3017 * | |--FRAME_HTML_TAG_NAME -> frame 3018 * | |--WS -> 3019 * | |--ATTRIBUTE -> ATTRIBUTE 3020 * | | |--HTML_TAG_NAME -> src 3021 * | | |--EQUALS -> = 3022 * | | `--ATTR_VALUE -> "page1.html" 3023 * | `--END -> > 3024 * |--NEWLINE -> \r\n 3025 * |--LEADING_ASTERISK -> * 3026 * |--TEXT -> 3027 * `--HTML_ELEMENT_END -> HTML_ELEMENT_END 3028 * |--START -> < 3029 * |--SLASH -> / 3030 * |--HTML_TAG_NAME -> frameset 3031 * `--END -> > 3032 * } 3033 * </pre> 3034 */ 3035 public static final int FRAME_TAG = JavadocParser.RULE_frameTag + RULE_TYPES_OFFSET; 3036 3037 /** 3038 * Hr html tag. 3039 * 3040 * <p><b>Example:</b></p> 3041 * <pre>{@code text above line<hr> test after line}</pre> 3042 * <b>Tree:</b> 3043 * <pre> 3044 * {@code 3045 * |--LEADING_ASTERISK -> * 3046 * |--TEXT -> text above line 3047 * |--HTML_ELEMENT -> HTML_ELEMENT 3048 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3049 * | `--HR_TAG -> HR_TAG 3050 * | |--START -> < 3051 * | |--HR_HTML_TAG_NAME -> hr 3052 * | `--END -> > 3053 * |--TEXT -> test after line 3054 * |--NEWLINE -> \r\n 3055 * |--TEXT -> 3056 * } 3057 * </pre> 3058 */ 3059 public static final int HR_TAG = JavadocParser.RULE_hrTag + RULE_TYPES_OFFSET; 3060 3061 /** 3062 * Img html tag. 3063 * 3064 * <p><b>Example:</b></p> 3065 * <pre>{@code <img src="./image.png" alt="image description" width="200" height="100"> }</pre> 3066 * <b>Tree:</b> 3067 * <pre> 3068 * {@code 3069 * `--JAVADOC -> JAVADOC 3070 * |--NEWLINE -> \r\n 3071 * |--LEADING_ASTERISK -> * 3072 * |--TEXT -> 3073 * |--HTML_ELEMENT -> HTML_ELEMENT 3074 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3075 * | `--IMG_TAG -> IMG_TAG 3076 * | |--START -> < 3077 * | |--IMG_HTML_TAG_NAME -> img 3078 * | |--WS -> 3079 * | |--ATTRIBUTE -> ATTRIBUTE 3080 * | | |--HTML_TAG_NAME -> src 3081 * | | |--EQUALS -> = 3082 * | | `--ATTR_VALUE -> "./image.png" 3083 * | |--WS -> 3084 * | |--ATTRIBUTE -> ATTRIBUTE 3085 * | | |--HTML_TAG_NAME -> alt 3086 * | | |--EQUALS -> = 3087 * | | `--ATTR_VALUE -> "image description" 3088 * | |--WS -> 3089 * | |--ATTRIBUTE -> ATTRIBUTE 3090 * | | |--HTML_TAG_NAME -> width 3091 * | | |--EQUALS -> = 3092 * | | `--ATTR_VALUE -> "200" 3093 * | |--WS -> 3094 * | |--ATTRIBUTE -> ATTRIBUTE 3095 * | | |--HTML_TAG_NAME -> height 3096 * | | |--EQUALS -> = 3097 * | | `--ATTR_VALUE -> "100" 3098 * | `--END -> > 3099 * |--NEWLINE -> \r\n 3100 * |--TEXT -> 3101 * } 3102 * </pre> 3103 */ 3104 public static final int IMG_TAG = JavadocParser.RULE_imgTag + RULE_TYPES_OFFSET; 3105 3106 /** 3107 * Input html tag. 3108 * 3109 * <p><b>Example:</b></p> 3110 * <pre>{@code Type here: <input type="text" id="id" name="name"> }</pre> 3111 * <b>Tree:</b> 3112 * <pre> 3113 * {@code 3114 * JAVADOC -> JAVADOC 3115 * |--NEWLINE -> \r\n 3116 * |--LEADING_ASTERISK -> * 3117 * |--TEXT -> Type here: 3118 * |--HTML_ELEMENT -> HTML_ELEMENT 3119 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3120 * | `--INPUT_TAG -> INPUT_TAG 3121 * | |--START -> < 3122 * | |--INPUT_HTML_TAG_NAME -> input 3123 * | |--WS -> 3124 * | |--ATTRIBUTE -> ATTRIBUTE 3125 * | | |--HTML_TAG_NAME -> type 3126 * | | |--EQUALS -> = 3127 * | | `--ATTR_VALUE -> "text" 3128 * | |--WS -> 3129 * | |--ATTRIBUTE -> ATTRIBUTE 3130 * | | |--HTML_TAG_NAME -> id 3131 * | | |--EQUALS -> = 3132 * | | `--ATTR_VALUE -> "id" 3133 * | |--WS -> 3134 * | |--ATTRIBUTE -> ATTRIBUTE 3135 * | | |--HTML_TAG_NAME -> name 3136 * | | |--EQUALS -> = 3137 * | | `--ATTR_VALUE -> "name" 3138 * | `--END -> > 3139 * |--NEWLINE -> \r\n 3140 * |--TEXT -> 3141 * } 3142 * </pre> 3143 */ 3144 public static final int INPUT_TAG = JavadocParser.RULE_inputTag + RULE_TYPES_OFFSET; 3145 3146 /** 3147 * Isindex tag name. 3148 * 3149 * <p><b>Example:</b></p> 3150 * <pre> 3151 * <head> 3152 * <isindex prompt="search"> 3153 * </head> 3154 * </pre> 3155 * <b>Tree:</b> 3156 * <pre> 3157 * {@code 3158 * |--HTML_ELEMENT -> HTML_ELEMENT 3159 * | `--HEAD -> HEAD 3160 * | |--HEAD_TAG_START -> HEAD_TAG_START 3161 * | | |--START -> < 3162 * | | |--HEAD_HTML_TAG_NAME -> head 3163 * | | `--END -> > 3164 * | |--NEWLINE -> \r\n 3165 * | |--LEADING_ASTERISK -> * 3166 * | |--TEXT -> 3167 * | |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3168 * | | `--ISINDEX_TAG -> ISINDEX_TAG 3169 * | | |--START -> < 3170 * | | |--ISINDEX_HTML_TAG_NAME -> isindex 3171 * | | |--WS -> 3172 * | | |--ATTRIBUTE -> ATTRIBUTE 3173 * | | | |--HTML_TAG_NAME -> prompt 3174 * | | | |--EQUALS -> = 3175 * | | | `--ATTR_VALUE -> "search" 3176 * | | `--END -> > 3177 * | |--NEWLINE -> \r\n 3178 * | |--LEADING_ASTERISK -> * 3179 * | |--TEXT -> 3180 * | `--HEAD_TAG_END -> HEAD_TAG_END 3181 * | |--START -> < 3182 * | |--SLASH -> / 3183 * | |--HEAD_HTML_TAG_NAME -> head 3184 * | `--END -> > 3185 * |--NEWLINE -> \r\n 3186 * |--TEXT -> 3187 * } 3188 * </pre> 3189 */ 3190 public static final int ISINDEX_TAG = JavadocParser.RULE_isindexTag + RULE_TYPES_OFFSET; 3191 3192 /** 3193 * Link html tag. 3194 * 3195 * <p><b>Example:</b></p> 3196 * <pre>{@code <link rel="stylesheet" href="styles.css">}</pre> 3197 * 3198 * <b>Tree:</b> 3199 * <pre> 3200 * {@code 3201 * HTML_ELEMENT -> HTML_ELEMENT 3202 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3203 * `--LINK_TAG -> LINK_TAG 3204 * |--START -> < 3205 * |--LINK_HTML_TAG_NAME -> link 3206 * |--ATTRIBUTE -> ATTRIBUTE 3207 * | |--HTML_TAG_NAME -> rel 3208 * | |--EQUALS -> = 3209 * | `--ATTR_VALUE -> "stylesheet" 3210 * |--ATTRIBUTE -> ATTRIBUTE 3211 * | |--HTML_TAG_NAME -> href 3212 * | |--EQUALS -> = 3213 * | `--ATTR_VALUE -> "styles.css" 3214 * `--END -> > 3215 * } 3216 * </pre> 3217 */ 3218 public static final int LINK_TAG = JavadocParser.RULE_linkTag + RULE_TYPES_OFFSET; 3219 3220 /** 3221 * Meta html tag. 3222 * 3223 * <p><b>Example:</b></p> 3224 * <pre>{@code <meta charset="UTF-8"> }</pre> 3225 * <b>Tree:</b> 3226 * <pre> 3227 * {@code 3228 * `--JAVADOC -> JAVADOC 3229 * |--NEWLINE -> \r\n 3230 * |--LEADING_ASTERISK -> * 3231 * |--TEXT -> 3232 * |--HTML_ELEMENT -> HTML_ELEMENT 3233 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3234 * | `--META_TAG -> META_TAG 3235 * | |--START -> < 3236 * | |--META_HTML_TAG_NAME -> meta 3237 * | |--WS -> 3238 * | |--ATTRIBUTE -> ATTRIBUTE 3239 * | | |--HTML_TAG_NAME -> charset 3240 * | | |--EQUALS -> = 3241 * | | `--ATTR_VALUE -> "UTF-8" 3242 * | `--END -> > 3243 * |--NEWLINE -> \r\n 3244 * |--TEXT -> 3245 * } 3246 * </pre> 3247 */ 3248 public static final int META_TAG = JavadocParser.RULE_metaTag + RULE_TYPES_OFFSET; 3249 3250 /** Param html tag. */ 3251 public static final int PARAM_TAG = JavadocParser.RULE_paramTag + RULE_TYPES_OFFSET; 3252 3253 /** 3254 * HTML void element. 3255 * 3256 * <p><b>Example:</b></p> 3257 * <pre>{@code 3258 * <embed src="URL" type="MIME_type"> 3259 * }</pre> 3260 * <b>Tree:</b> 3261 * <pre> 3262 * {@code 3263 * |--HTML_ELEMENT -> HTML_ELEMENT 3264 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3265 * | `--EMBED_TAG -> EMBED_TAG 3266 * | |--START -> < 3267 * | |--EMBED_HTML_TAG_NAME -> embed 3268 * | |--WS -> 3269 * | |--ATTRIBUTE -> ATTRIBUTE 3270 * | | |--HTML_TAG_NAME -> src 3271 * | | |--EQUALS -> = 3272 * | | `--ATTR_VALUE -> "URL" 3273 * | |--WS -> 3274 * | |--ATTRIBUTE -> ATTRIBUTE 3275 * | | |--HTML_TAG_NAME -> type 3276 * | | |--EQUALS -> = 3277 * | | `--ATTR_VALUE -> "MIME_type" 3278 * | `--END -> > 3279 * |--NEWLINE -> \r\n 3280 * |--TEXT -> 3281 * } 3282 * </pre> 3283 * 3284 * @see #EMBED_TAG 3285 * @see <a href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-embed"> 3286 * W3 docs</a> 3287 */ 3288 public static final int EMBED_TAG = JavadocParser.RULE_embedTag + RULE_TYPES_OFFSET; 3289 3290 /** 3291 * HTML void element {@code <keygen>}. 3292 * 3293 * @see #SINGLETON_ELEMENT 3294 * @see <a href="https://www.w3.org/TR/html51/sec-forms.html#elementdef-keygen"> 3295 * W3 docs</a> 3296 */ 3297 public static final int KEYGEN_TAG = JavadocParser.RULE_keygenTag + RULE_TYPES_OFFSET; 3298 3299 /** 3300 * HTML void element {@code <source>}. 3301 * 3302 * @see #SINGLETON_ELEMENT 3303 * @see <a href= 3304 * "https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-media-source"> 3305 * W3 docs</a> 3306 */ 3307 public static final int SOURCE_TAG = JavadocParser.RULE_sourceTag + RULE_TYPES_OFFSET; 3308 3309 /** 3310 * HTML void element {@code <track>}. 3311 * 3312 * <p><b>Example:</b></p> 3313 * <pre>{@code 3314 * <track kind="subtitles" src="subtitles_en.file" /> 3315 * }</pre> 3316 * <b>Tree:</b> 3317 * <pre> 3318 * {@code 3319 * |--HTML_ELEMENT -> HTML_ELEMENT 3320 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3321 * | `--TRACK_TAG -> TRACK_TAG 3322 * | |--START -> < 3323 * | |--TRACK_HTML_TAG_NAME -> track 3324 * | |--WS -> 3325 * | |--ATTRIBUTE -> ATTRIBUTE 3326 * | | |--HTML_TAG_NAME -> kind 3327 * | | |--EQUALS -> = 3328 * | | `--ATTR_VALUE -> "subtitles" 3329 * | |--WS -> 3330 * | |--ATTRIBUTE -> ATTRIBUTE 3331 * | | |--HTML_TAG_NAME -> src 3332 * | | |--EQUALS -> = 3333 * | | `--ATTR_VALUE -> "subtitles_en.file" 3334 * | `--END -> /> 3335 * |--NEWLINE -> \r\n 3336 * |--TEXT -> 3337 * } 3338 * </pre> 3339 * 3340 * @see #TRACK_TAG 3341 * @see <a href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-track"> 3342 * W3 docs</a> 3343 */ 3344 public static final int TRACK_TAG = JavadocParser.RULE_trackTag + RULE_TYPES_OFFSET; 3345 3346 /** 3347 * HTML void element {@code <wbr>}. 3348 * 3349 * @see #SINGLETON_ELEMENT 3350 * @see <a href="https://www.w3.org/TR/html51/textlevel-semantics.html#elementdef-wbr"> 3351 * W3 docs</a> 3352 */ 3353 public static final int WBR_TAG = JavadocParser.RULE_wbrTag + RULE_TYPES_OFFSET; 3354 3355 /////////////////////////////////////////////////////////////////////////////////////////////// 3356 3357 /** 3358 * Html comment: {@code <!-- --> }. 3359 */ 3360 public static final int HTML_COMMENT = JavadocParser.RULE_htmlComment 3361 + RULE_TYPES_OFFSET; 3362 /** 3363 * CHAR and WS sequence. 3364 */ 3365 public static final int TEXT = JavadocParser.RULE_text + RULE_TYPES_OFFSET; 3366 3367 /** Empty private constructor of the current class. */ 3368 private JavadocTokenTypes() { 3369 } 3370 3371}