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 character in HTML closing tags. 1037 * 1038 * <p><b>Example:</b></p> 1039 * <pre>{@code 1040 * <p>Paragraph Tag.</p> 1041 * }</pre> 1042 * <b>Tree:</b> 1043 * <pre> 1044 * {@code 1045 * HTML_ELEMENT -> HTML_ELEMENT 1046 * `--PARAGRAPH -> PARAGRAPH 1047 * |--P_TAG_START -> P_TAG_START 1048 * | |--START -> 1049 * | |--P_HTML_TAG_NAME -> p 1050 * | `--END -> > 1051 * |--TEXT -> Paragraph Tag. 1052 * `--P_TAG_END -> P_TAG_END 1053 * |--START -> 1054 * |--SLASH -> / 1055 * |--P_HTML_TAG_NAME -> p 1056 * `--END -> > 1057 * } 1058 * </pre> 1059 */ 1060 public static final int SLASH = JavadocParser.SLASH; 1061 1062 /** 1063 * End html tag component: {@code '>'}. 1064 */ 1065 public static final int END = JavadocParser.END; 1066 1067 /** 1068 * Slash close html tag component: {@code '/>'}. 1069 */ 1070 public static final int SLASH_END = JavadocParser.SLASH_END; 1071 1072 /** 1073 * Equals html tag component: {@code '='}. 1074 */ 1075 public static final int EQUALS = JavadocParser.EQUALS; 1076 1077 /** 1078 * Attribute value HTML tag component. 1079 * 1080 * <p><b>Example:</b></p> 1081 * 1082 * <pre> 1083 * <tag_name attr_name="attr_value">Content</tag_name> 1084 * </pre> 1085 * 1086 * <p><b>Tree:</b></p> 1087 * <pre>{@code 1088 * JAVADOC -> JAVADOC 1089 * |--NEWLINE -> \r\n 1090 * |--LEADING_ASTERISK -> * 1091 * |--TEXT -> 1092 * |--HTML_ELEMENT -> HTML_ELEMENT 1093 * | `--HTML_TAG -> HTML_TAG 1094 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1095 * | | |--START -> < 1096 * | | |--HTML_TAG_NAME -> tag_name 1097 * | | |--WS -> 1098 * | | |--ATTRIBUTE -> ATTRIBUTE 1099 * | | | |--HTML_TAG_NAME -> attr_name 1100 * | | | |--EQUALS -> = 1101 * | | | `--ATTR_VALUE -> "attr_value" 1102 * | | `--END -> > 1103 * | |--TEXT -> Content 1104 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1105 * | |--START -> < 1106 * | |--SLASH -> / 1107 * | |--HTML_TAG_NAME -> tag_name 1108 * | `--END -> > 1109 * }</pre> 1110 */ 1111 public static final int ATTR_VALUE = JavadocParser.ATTR_VALUE; 1112 1113 /////////////////////// HTML TAGS WITH OPTIONAL END TAG ///////////////////////////////////// 1114 1115 /** 1116 * Paragraph tag name. 1117 * 1118 * <p><b>Example:</b></p> 1119 * <pre>{@code <p>Paragraph Tag.</p>}</pre> 1120 * <b>Tree:</b> 1121 * <pre> 1122 * {@code 1123 * `--HTML_ELEMENT -> HTML_ELEMENT 1124 * `--PARAGRAPH -> PARAGRAPH 1125 * |--P_TAG_START -> P_TAG_START 1126 * | |--START -> < 1127 * | |--P_HTML_TAG_NAME -> p 1128 * | `--END -> > 1129 * |--TEXT -> Paragraph Tag. 1130 * `--P_TAG_END -> P_TAG_END 1131 * |--START -> < 1132 * |--SLASH -> / 1133 * |--P_HTML_TAG_NAME -> p 1134 * `--END -> > 1135 * } 1136 * </pre> 1137 * 1138 * @see 1139 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1140 * Comments are written in HTML</a> 1141 * @see #P_HTML_TAG_NAME 1142 */ 1143 public static final int P_HTML_TAG_NAME = JavadocParser.P_HTML_TAG_NAME; 1144 1145 /** 1146 * List item tag name. 1147 * 1148 * <p><b>Example:</b></p> 1149 * <pre>{@code 1150 * <ol> 1151 * <li>banana</li> 1152 * </ol> 1153 * }</pre> 1154 * <b>Tree:</b> 1155 * <pre> 1156 * {@code 1157 * HTML_ELEMENT -> HTML_ELEMENT 1158 * `--HTML_TAG -> HTML_TAG 1159 * |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1160 * | |--START -> < 1161 * | |--HTML_TAG_NAME -> ol 1162 * | `--END -> > 1163 * |--NEWLINE -> \r\n 1164 * |--LEADING_ASTERISK -> * 1165 * |--TEXT -> 1166 * |--HTML_ELEMENT -> HTML_ELEMENT 1167 * | `--LI -> LI 1168 * | |--LI_TAG_START -> LI_TAG_START 1169 * | | |--START -> < 1170 * | | |--LI_HTML_TAG_NAME -> li 1171 * | | `--END -> > 1172 * | |--TEXT -> banana 1173 * | `--LI_TAG_END -> LI_TAG_END 1174 * | |--START -> < 1175 * | |--SLASH -> / 1176 * | |--LI_HTML_TAG_NAME -> li 1177 * | `--END -> > 1178 * |--NEWLINE -> \r\n 1179 * |--LEADING_ASTERISK -> * 1180 * |--TEXT -> 1181 * `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1182 * |--START -> < 1183 * |--SLASH -> / 1184 * |--HTML_TAG_NAME -> ol 1185 * `--END -> > 1186 * } 1187 * </pre> 1188 * 1189 * @see 1190 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1191 * comments are written in HTML</a> 1192 * @see #LI_HTML_TAG_NAME 1193 */ 1194 public static final int LI_HTML_TAG_NAME = JavadocParser.LI_HTML_TAG_NAME; 1195 1196 /** 1197 * Table row tag name. 1198 * 1199 * <p><b>Example:</b></p> 1200 * <pre>{@code 1201 * <table> 1202 * <tr>Table Row</tr> 1203 * </table> 1204 * }</pre> 1205 * <b>Tree:</b> 1206 * <pre> 1207 * {@code 1208 * HTML_ELEMENT -> HTML_ELEMENT 1209 * `--HTML_TAG -> HTML_TAG 1210 * |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1211 * | |--START -> < 1212 * | |--HTML_TAG_NAME -> table 1213 * | `--END -> > 1214 * |--NEWLINE -> \r\n 1215 * |--LEADING_ASTERISK -> * 1216 * |--TEXT -> 1217 * |--HTML_ELEMENT -> HTML_ELEMENT 1218 * | `--TR -> TR 1219 * | |--TR_TAG_START -> TR_TAG_START 1220 * | | |--START -> < 1221 * | | |--TR_HTML_TAG_NAME -> tr 1222 * | | `--END -> > 1223 * | |--TEXT -> Table Row 1224 * | `--TR_TAG_END -> TR_TAG_END 1225 * | |--START -> < 1226 * | |--SLASH -> / 1227 * | |--TR_HTML_TAG_NAME -> tr 1228 * | `--END -> > 1229 * |--NEWLINE -> \r\n 1230 * |--LEADING_ASTERISK -> * 1231 * |--TEXT -> 1232 * `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1233 * |--START -> < 1234 * |--SLASH -> / 1235 * |--HTML_TAG_NAME -> table 1236 * `--END -> > 1237 * } 1238 * </pre> 1239 * 1240 * @see 1241 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1242 * comments are written in HTML</a> 1243 * @see #TR_HTML_TAG_NAME 1244 */ 1245 public static final int TR_HTML_TAG_NAME = JavadocParser.TR_HTML_TAG_NAME; 1246 1247 /** 1248 * Table cell tag name. 1249 * 1250 * <p><b>Example:</b></p> 1251 * <pre>{@code 1252 * <tr> 1253 * <td>Cell 1</td> 1254 * </tr> 1255 * }</pre> 1256 * <b>Tree:</b> 1257 * <pre> 1258 * {@code 1259 * HTML_ELEMENT -> HTML_ELEMENT 1260 * `--TR -> TR 1261 * |--TR_TAG_START -> TR_TAG_START 1262 * | |--START -> < 1263 * | |--TR_HTML_TAG_NAME -> tr 1264 * | `--END -> > 1265 * |--NEWLINE -> \r\n 1266 * |--LEADING_ASTERISK -> * 1267 * |--TEXT -> 1268 * |--TD -> TD 1269 * | |--TD_TAG_START -> TD_TAG_START 1270 * | | |--START -> < 1271 * | | |--TD_HTML_TAG_NAME -> td 1272 * | | `--END -> > 1273 * | |--TEXT -> Cell 1 1274 * | `--TD_TAG_END -> TD_TAG_END 1275 * | |--START -> < 1276 * | |--SLASH -> / 1277 * | |--TD_HTML_TAG_NAME -> td 1278 * | `--END -> > 1279 * |--NEWLINE -> \r\n 1280 * |--LEADING_ASTERISK -> * 1281 * |--TEXT -> 1282 * `--TR_TAG_END -> TR_TAG_END 1283 * |--START -> < 1284 * |--SLASH -> / 1285 * |--TR_HTML_TAG_NAME -> tr 1286 * `--END -> > 1287 * } 1288 * </pre> 1289 * 1290 * @see 1291 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1292 * comments are written in HTML</a> 1293 * @see #TD_HTML_TAG_NAME 1294 */ 1295 public static final int TD_HTML_TAG_NAME = JavadocParser.TD_HTML_TAG_NAME; 1296 1297 /** 1298 * Table header cell tag name. 1299 * 1300 * <p><b>Example:</b></p> 1301 * <pre>{@code 1302 * <tr> 1303 * <th>Table Head</th> 1304 * </tr> 1305 * }</pre> 1306 * <b>Tree:</b> 1307 * <pre> 1308 * {@code 1309 * HTML_ELEMENT -> HTML_ELEMENT 1310 * `--TR -> TR 1311 * |--TR_TAG_START -> TR_TAG_START 1312 * | |--START -> < 1313 * | |--TR_HTML_TAG_NAME -> tr 1314 * | `--END -> > 1315 * |--NEWLINE -> \r\n 1316 * |--LEADING_ASTERISK -> * 1317 * |--TEXT -> 1318 * |--TH -> TH 1319 * | |--TH_TAG_START -> TH_TAG_START 1320 * | | |--START -> < 1321 * | | |--TH_HTML_TAG_NAME -> th 1322 * | | `--END -> > 1323 * | |--TEXT -> Table Head 1324 * | `--TH_TAG_END -> TH_TAG_END 1325 * | |--START -> < 1326 * | |--SLASH -> / 1327 * | |--TH_HTML_TAG_NAME -> th 1328 * | `--END -> > 1329 * |--NEWLINE -> \r\n 1330 * |--LEADING_ASTERISK -> * 1331 * |--TEXT -> 1332 * `--TR_TAG_END -> TR_TAG_END 1333 * |--START -> < 1334 * |--SLASH -> / 1335 * |--TR_HTML_TAG_NAME -> tr 1336 * `--END -> > 1337 * } 1338 * </pre> 1339 * 1340 * @see 1341 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1342 * comments are written in HTML</a> 1343 * @see #TH_HTML_TAG_NAME 1344 */ 1345 public static final int TH_HTML_TAG_NAME = JavadocParser.TH_HTML_TAG_NAME; 1346 1347 /** 1348 * Body tag name. 1349 * 1350 * <p><b>Example:</b></p> 1351 * <pre> 1352 * <body> 1353 * <p>Body Content</p> 1354 * </body> 1355 * </pre> 1356 * <b>Tree:</b> 1357 * <pre> 1358 * {@code 1359 * HTML_ELEMENT -> HTML_ELEMENT 1360 * `--BODY -> BODY 1361 * |--BODY_TAG_START -> BODY_TAG_START 1362 * | |--START -> < 1363 * | |--BODY_HTML_TAG_NAME -> body 1364 * | `--END -> > 1365 * |--NEWLINE -> \r\n 1366 * |--LEADING_ASTERISK -> * 1367 * |--TEXT -> 1368 * |--PARAGRAPH -> PARAGRAPH 1369 * | |--P_TAG_START -> P_TAG_START 1370 * | | |--START -> < 1371 * | | |--P_HTML_TAG_NAME -> p 1372 * | | `--END -> > 1373 * | |--TEXT -> Body Content 1374 * | `--P_TAG_END -> P_TAG_END 1375 * | |--START -> < 1376 * | |--SLASH -> / 1377 * | |--P_HTML_TAG_NAME -> p 1378 * | `--END -> > 1379 * |--NEWLINE -> \r\n 1380 * |--LEADING_ASTERISK -> * 1381 * |--TEXT -> 1382 * `--BODY_TAG_END -> BODY_TAG_END 1383 * |--START -> < 1384 * |--SLASH -> / 1385 * |--BODY_HTML_TAG_NAME -> body 1386 * `--END -> > 1387 * } 1388 * </pre> 1389 * 1390 * @see 1391 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1392 * comments are written in HTML</a> 1393 * @see #BODY_HTML_TAG_NAME 1394 */ 1395 public static final int BODY_HTML_TAG_NAME = JavadocParser.BODY_HTML_TAG_NAME; 1396 1397 /** 1398 * Colgroup tag name. 1399 * 1400 * <p><b>Example:</b></p> 1401 * <pre>{@code <colgroup><col span="2"></colgroup>}</pre> 1402 * <b>Tree:</b> 1403 * <pre> 1404 * {@code 1405 * |--HTML_ELEMENT -> HTML_ELEMENT 1406 * | `--COLGROUP -> COLGROUP 1407 * | |--COLGROUP_TAG_START -> COLGROUP_TAG_START 1408 * | | |--START -> < 1409 * | | |--COLGROUP_HTML_TAG_NAME -> colgroup 1410 * | | `--END -> > 1411 * | |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1412 * | | `--COL_TAG -> COL_TAG 1413 * | | |--START -> < 1414 * | | |--COL_HTML_TAG_NAME -> col 1415 * | | |--WS -> 1416 * | | |--ATTRIBUTE -> ATTRIBUTE 1417 * | | | |--HTML_TAG_NAME -> span 1418 * | | | |--EQUALS -> = 1419 * | | | `--ATTR_VALUE -> "2" 1420 * | | `--END -> > 1421 * | `--COLGROUP_TAG_END -> COLGROUP_TAG_END 1422 * | |--START -> < 1423 * | |--SLASH -> / 1424 * | |--COLGROUP_HTML_TAG_NAME -> colgroup 1425 * | `--END -> > 1426 * |--TEXT -> 1427 * `--EOF -> <EOF> 1428 * } 1429 * </pre> 1430 * 1431 * @see #COLGROUP_HTML_TAG_NAME 1432 */ 1433 public static final int COLGROUP_HTML_TAG_NAME = JavadocParser.COLGROUP_HTML_TAG_NAME; 1434 1435 /** 1436 * Description of a term tag name. 1437 * 1438 * <p><b>Example:</b></p> 1439 * <pre>{@code 1440 * <dl> 1441 * <dt>Java</dt> 1442 * <dd>A high-level programming language.</dd> 1443 * </dl> 1444 * }</pre> 1445 * <b>Tree:</b> 1446 * <pre> 1447 * {@code 1448 * HTML_ELEMENT -> HTML_ELEMENT 1449 * `--HTML_TAG -> HTML_TAG 1450 * |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1451 * | |--START -> < 1452 * | |--HTML_TAG_NAME -> dl 1453 * | `--END -> > 1454 * |--NEWLINE -> \r\n 1455 * |--LEADING_ASTERISK -> * 1456 * |--TEXT -> 1457 * |--HTML_ELEMENT -> HTML_ELEMENT 1458 * | `--DT -> DT 1459 * | |--DT_TAG_START -> DT_TAG_START 1460 * | | |--START -> < 1461 * | | |--DT_HTML_TAG_NAME -> dt 1462 * | | `--END -> > 1463 * | |--TEXT -> Java 1464 * | `--DT_TAG_END -> DT_TAG_END 1465 * | |--START -> < 1466 * | |--SLASH -> / 1467 * | |--DT_HTML_TAG_NAME -> dt 1468 * | `--END -> > 1469 * |--NEWLINE -> \r\n 1470 * |--LEADING_ASTERISK -> * 1471 * |--TEXT -> 1472 * |--HTML_ELEMENT -> HTML_ELEMENT 1473 * | `--DD -> DD 1474 * | |--DD_TAG_START -> DD_TAG_START 1475 * | | |--START -> < 1476 * | | |--DD_HTML_TAG_NAME -> dd 1477 * | | `--END -> > 1478 * | |--TEXT -> A high-level programming language. 1479 * | `--DD_TAG_END -> DD_TAG_END 1480 * | |--START -> < 1481 * | |--SLASH -> / 1482 * | |--DD_HTML_TAG_NAME -> dd 1483 * | `--END -> > 1484 * |--NEWLINE -> \r\n 1485 * |--LEADING_ASTERISK -> * 1486 * |--TEXT -> 1487 * `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1488 * |--START -> < 1489 * |--SLASH -> / 1490 * |--HTML_TAG_NAME -> dl 1491 * `--END -> > 1492 * } 1493 * </pre> 1494 * 1495 * @see #DD_HTML_TAG_NAME 1496 */ 1497 public static final int DD_HTML_TAG_NAME = JavadocParser.DD_HTML_TAG_NAME; 1498 1499 /** 1500 * Description term tag name. 1501 * 1502 * <p><b>Example:</b></p> 1503 * <pre>{@code 1504 * <dl> 1505 * <dt>Java</dt> 1506 * </dl> 1507 * }</pre> 1508 * <b>Tree:</b> 1509 * <pre> 1510 * {@code 1511 * HTML_ELEMENT -> HTML_ELEMENT 1512 * `--HTML_TAG -> HTML_TAG 1513 * |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1514 * | |--START -> < 1515 * | |--HTML_TAG_NAME -> dl 1516 * | `--END -> > 1517 * |--NEWLINE -> \r\n 1518 * |--LEADING_ASTERISK -> * 1519 * |--TEXT -> 1520 * |--HTML_ELEMENT -> HTML_ELEMENT 1521 * | `--DT -> DT 1522 * | |--DT_TAG_START -> DT_TAG_START 1523 * | | |--START -> < 1524 * | | |--DT_HTML_TAG_NAME -> dt 1525 * | | `--END -> > 1526 * | |--TEXT -> Java 1527 * | `--DT_TAG_END -> DT_TAG_END 1528 * | |--START -> < 1529 * | |--SLASH -> / 1530 * | |--DT_HTML_TAG_NAME -> dt 1531 * | `--END -> > 1532 * |--NEWLINE -> \r\n 1533 * |--LEADING_ASTERISK -> * 1534 * |--TEXT -> 1535 * `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1536 * |--START -> < 1537 * |--SLASH -> / 1538 * |--HTML_TAG_NAME -> dl 1539 * `--END -> > 1540 * } 1541 * </pre> 1542 * 1543 * @see #DT_HTML_TAG_NAME 1544 */ 1545 public static final int DT_HTML_TAG_NAME = JavadocParser.DT_HTML_TAG_NAME; 1546 1547 /** 1548 * Head tag name. 1549 * 1550 * <p><b>Example:</b></p> 1551 * <pre> 1552 * <head> 1553 * <title>Page Title</title> 1554 * <meta charset="UTF-8"> 1555 * </head> 1556 * </pre> 1557 * <b>Tree:</b> 1558 * <pre>{@code 1559 * HEAD -> HEAD 1560 * |--HEAD_TAG_START -> HEAD_TAG_START 1561 * | |--START -> < 1562 * | |--HEAD_HTML_TAG_NAME -> head 1563 * | `--END -> > 1564 * |--NEWLINE -> \r\n 1565 * |--LEADING_ASTERISK -> * 1566 * |--TEXT -> 1567 * |--HTML_TAG -> HTML_TAG 1568 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 1569 * | | |--START -> < 1570 * | | |--HTML_TAG_NAME -> title 1571 * | | `--END -> > 1572 * | |--TEXT -> Page Title 1573 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 1574 * | |--START -> < 1575 * | |--SLASH -> / 1576 * | |--HTML_TAG_NAME -> title 1577 * | `--END -> > 1578 * |--NEWLINE -> \r\n 1579 * |--LEADING_ASTERISK -> * 1580 * |--TEXT -> 1581 * |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1582 * | `--META_TAG -> META_TAG 1583 * | |--START -> < 1584 * | |--META_HTML_TAG_NAME -> meta 1585 * | |--WS -> 1586 * | |--ATTRIBUTE -> ATTRIBUTE 1587 * | | |--HTML_TAG_NAME -> charset 1588 * | | |--EQUALS -> = 1589 * | | `--ATTR_VALUE -> "UTF-8" 1590 * | `--END -> > 1591 * |--NEWLINE -> \r\n 1592 * |--LEADING_ASTERISK -> * 1593 * |--TEXT -> 1594 * `--HEAD_TAG_END -> HEAD_TAG_END 1595 * |--START -> < 1596 * |--SLASH -> / 1597 * |--HEAD_HTML_TAG_NAME -> head 1598 * `--END -> > 1599 * } 1600 * </pre> 1601 * 1602 * @see #HEAD_HTML_TAG_NAME 1603 */ 1604 public static final int HEAD_HTML_TAG_NAME = JavadocParser.HEAD_HTML_TAG_NAME; 1605 1606 /** Html tag name. */ 1607 public static final int HTML_HTML_TAG_NAME = JavadocParser.HTML_HTML_TAG_NAME; 1608 1609 /** 1610 * Option tag name. 1611 * 1612 * <p><b>Example:</b></p> 1613 * <pre><option value="yes">Yes</option></pre> 1614 * <b>Tree:</b> 1615 * <pre> 1616 * {@code 1617 * JAVADOC -> JAVADOC 1618 * |--NEWLINE -> \r\n 1619 * |--LEADING_ASTERISK -> * 1620 * |--HTML_ELEMENT -> HTML_ELEMENT 1621 * | `--OPTION -> OPTION 1622 * | |--OPTION_TAG_START -> OPTION_TAG_START 1623 * | | |--START -> < 1624 * | | |--OPTION_HTML_TAG_NAME -> option 1625 * | | |--WS -> 1626 * | | |--ATTRIBUTE -> ATTRIBUTE 1627 * | | | |--HTML_TAG_NAME -> value 1628 * | | | |--EQUALS -> = 1629 * | | | `--ATTR_VALUE -> "yes" 1630 * | | `--END -> > 1631 * | |--TEXT -> Yes 1632 * | `--OPTION_TAG_END -> OPTION_TAG_END 1633 * | |--START -> < 1634 * | |--SLASH -> / 1635 * | |--OPTION_HTML_TAG_NAME -> option 1636 * | `--END -> > 1637 * |--NEWLINE -> \r\n 1638 * |--TEXT -> 1639 * |--EOF -> <EOF> 1640 * } 1641 * </pre> 1642 */ 1643 public static final int OPTION_HTML_TAG_NAME = JavadocParser.OPTION_HTML_TAG_NAME; 1644 1645 /** 1646 * Table body tag name. 1647 * 1648 * <p><b>Example:</b></p> 1649 * <pre> 1650 * <tbody> 1651 * <tr> 1652 * <td>Row1</td> 1653 * </tr> 1654 * </tbody> 1655 * </pre> 1656 * <b>Tree:</b> 1657 * <pre> 1658 * {@code 1659 * JAVADOC -> JAVADOC 1660 * |--NEWLINE -> \n 1661 * |--LEADING_ASTERISK -> * 1662 * |--TEXT -> 1663 * |--HTML_ELEMENT -> HTML_ELEMENT 1664 * | `--TBODY -> TBODY 1665 * | |--TBODY_TAG_START -> TBODY_TAG_START 1666 * | | |--START -> < 1667 * | | |--TBODY_HTML_TAG_NAME -> tbody 1668 * | | `--END -> > 1669 * | |--NEWLINE -> \n 1670 * | |--LEADING_ASTERISK -> * 1671 * | |--TEXT -> 1672 * | |--TR -> TR 1673 * | | |--TR_TAG_START -> TR_TAG_START 1674 * | | | |--START -> < 1675 * | | | |--TR_HTML_TAG_NAME -> tr 1676 * | | | `--END -> > 1677 * | | |--NEWLINE -> \n 1678 * | | |--LEADING_ASTERISK -> * 1679 * | | |--TEXT -> 1680 * | | |--TD -> TD 1681 * | | | |--TD_TAG_START -> TD_TAG_START 1682 * | | | | |--START -> < 1683 * | | | | |--TD_HTML_TAG_NAME -> td 1684 * | | | | `--END -> > 1685 * | | | |--TEXT -> Row1 1686 * | | | `--TD_TAG_END -> TD_TAG_END 1687 * | | | |--START -> < 1688 * | | | |--SLASH -> / 1689 * | | | |--TD_HTML_TAG_NAME -> td 1690 * | | | `--END -> > 1691 * | | |--NEWLINE -> \n 1692 * | | |--LEADING_ASTERISK -> * 1693 * | | |--TEXT -> 1694 * | | `--TR_TAG_END -> TR_TAG_END 1695 * | | |--START -> < 1696 * | | |--SLASH -> / 1697 * | | |--TR_HTML_TAG_NAME -> tr 1698 * | | `--END -> > 1699 * | |--NEWLINE -> \n 1700 * | |--LEADING_ASTERISK -> * 1701 * | |--TEXT -> 1702 * | `--TBODY_TAG_END -> TBODY_TAG_END 1703 * | |--START -> < 1704 * | |--SLASH -> / 1705 * | |--TBODY_HTML_TAG_NAME -> tbody 1706 * | `--END -> > 1707 * |--NEWLINE -> \n 1708 * |--TEXT -> 1709 * `--EOF -> <EOF> 1710 * } 1711 * </pre> 1712 */ 1713 public static final int TBODY_HTML_TAG_NAME = JavadocParser.TBODY_HTML_TAG_NAME; 1714 1715 /** Table foot tag name. */ 1716 public static final int TFOOT_HTML_TAG_NAME = JavadocParser.TFOOT_HTML_TAG_NAME; 1717 1718 /** 1719 * Table head tag name. 1720 * 1721 * <p><b>Example:</b></p> 1722 * <pre> 1723 * <thead> 1724 * <tr> 1725 * <th>Header</th> 1726 * </tr> 1727 * </thead> 1728 * </pre> 1729 * <b>Tree:</b> 1730 * <pre> 1731 * {@code 1732 * JAVADOC -> JAVADOC 1733 * |--NEWLINE -> \n 1734 * |--LEADING_ASTERISK -> * 1735 * |--TEXT -> 1736 * |--HTML_ELEMENT -> HTML_ELEMENT 1737 * | `--THEAD -> THEAD 1738 * | |--THEAD_TAG_START -> THEAD_TAG_START 1739 * | | |--START -> < 1740 * | | |--THEAD_HTML_TAG_NAME -> thead 1741 * | | `--END -> > 1742 * | |--TR -> TR 1743 * | | |--TR_TAG_START -> TR_TAG_START 1744 * | | | |--START -> < 1745 * | | | |--TR_HTML_TAG_NAME -> tr 1746 * | | | `--END -> > 1747 * | | |--TH -> TH 1748 * | | | |--TH_TAG_START -> TH_TAG_START 1749 * | | | | |--START -> < 1750 * | | | | |--TH_HTML_TAG_NAME -> th 1751 * | | | | `--END -> > 1752 * | | | |--TEXT -> Header 1753 * | | | `--TH_TAG_END -> TH_TAG_END 1754 * | | | |--START -> < 1755 * | | | |--SLASH -> / 1756 * | | | |--TH_HTML_TAG_NAME -> th 1757 * | | | `--END -> > 1758 * | | `--TR_TAG_END -> TR_TAG_END 1759 * | | |--START -> < 1760 * | | |--SLASH -> / 1761 * | | |--TR_HTML_TAG_NAME -> tr 1762 * | | `--END -> > 1763 * | `--THEAD_TAG_END -> THEAD_TAG_END 1764 * | |--START -> < 1765 * | |--SLASH -> / 1766 * | |--THEAD_HTML_TAG_NAME -> thead 1767 * | `--END -> > 1768 * |--NEWLINE -> \n 1769 * |--TEXT -> 1770 * `--EOF -> <EOF> 1771 * } 1772 * </pre> 1773 */ 1774 public static final int THEAD_HTML_TAG_NAME = JavadocParser.THEAD_HTML_TAG_NAME; 1775 1776 /** `optgroup` tag name. */ 1777 public static final int OPTGROUP_HTML_TAG_NAME = JavadocParser.OPTGROUP_HTML_TAG_NAME; 1778 1779 /** `rb` tag name. */ 1780 public static final int RB_HTML_TAG_NAME = JavadocParser.RB_HTML_TAG_NAME; 1781 1782 /** `rt` tag name. */ 1783 public static final int RT_HTML_TAG_NAME = JavadocParser.RT_HTML_TAG_NAME; 1784 1785 /** `rtc` tag name. */ 1786 public static final int RTC_HTML_TAG_NAME = JavadocParser.RTC_HTML_TAG_NAME; 1787 1788 /** 1789 * RP tag name. 1790 * 1791 * <p><b>Example:</b></p> 1792 * <pre> 1793 * <rp>Fallback</rp> 1794 * </pre> 1795 * 1796 * <b>Tree:</b> 1797 * <pre> 1798 * {@code 1799 * HTML_ELEMENT -> HTML_ELEMENT 1800 * `--RP -> RP 1801 * |--RP_TAG_START -> RP_TAG_START 1802 * | |--START -> < 1803 * | |--RP_HTML_TAG_NAME -> rp 1804 * | `--END -> > 1805 * |--TEXT -> Fallback 1806 * `--RP_TAG_END -> RP_TAG_END 1807 * |--START -> < 1808 * |--SLASH -> / 1809 * |--RP_HTML_TAG_NAME -> rp 1810 * `--END -> > 1811 * } 1812 * </pre> 1813 */ 1814 public static final int RP_HTML_TAG_NAME = JavadocParser.RP_HTML_TAG_NAME; 1815 1816 /////////////////////////////////////////////////////////////////////////////////////////////// 1817 1818 /////////////////////// SINGLETON HTML TAGS ////////////////////////////////////////////////// 1819 /** 1820 * Area tag name. 1821 * 1822 * <p><b>Example:</b></p> 1823 * <pre>{@code < area shape="rect" >}</pre> 1824 * <b>Tree:</b> 1825 * <pre> 1826 * {@code 1827 * JAVADOC -> JAVADOC 1828 * |--NEWLINE -> \n 1829 * |--LEADING_ASTERISK -> * 1830 * |--TEXT -> 1831 * |--HTML_ELEMENT -> HTML_ELEMENT 1832 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1833 * | `--AREA_TAG -> AREA_TAG 1834 * | |--START -> < 1835 * | |--AREA_HTML_TAG_NAME -> area 1836 * | |--WS -> 1837 * | |--ATTRIBUTE -> ATTRIBUTE 1838 * | | |--HTML_TAG_NAME -> shape 1839 * | | |--EQUALS -> = 1840 * | | `--ATTR_VALUE -> "rect" 1841 * | `--END -> > 1842 * |--TEXT -> 1843 * |--NEWLINE -> \n 1844 * |--TEXT -> 1845 * } 1846 * </pre> 1847 */ 1848 1849 public static final int AREA_HTML_TAG_NAME = JavadocParser.AREA_HTML_TAG_NAME; 1850 1851 /** 1852 * Base tag name. 1853 * 1854 * <p><b>Example:</b></p> 1855 * <pre>{@code <base href="https://example.com/">}</pre> 1856 * 1857 * <p><b>Tree:</b></p> 1858 * <pre>{@code 1859 * --HTML_ELEMENT -> HTML_ELEMENT 1860 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1861 * `--BASE_TAG -> BASE_TAG 1862 * |--START -> < 1863 * |--BASE_HTML_TAG_NAME -> base 1864 * |--WS -> 1865 * |--ATTRIBUTE -> ATTRIBUTE 1866 * | |--HTML_TAG_NAME -> href 1867 * | |--EQUALS -> = 1868 * | `--ATTR_VALUE -> "https://example.com/" 1869 * `--END -> > 1870 * } 1871 * </pre> 1872 */ 1873 public static final int BASE_HTML_TAG_NAME = JavadocParser.BASE_HTML_TAG_NAME; 1874 1875 /** Basefont tag name. */ 1876 public static final int BASEFONT_HTML_TAG_NAME = JavadocParser.BASEFONT_HTML_TAG_NAME; 1877 1878 /** 1879 * Br tag name. 1880 * 1881 * <p><b>Example:</b></p> 1882 * <pre>{@code text before break < br > text after break}</pre> 1883 * <b>Tree:</b> 1884 * <pre> 1885 * {@code 1886 * `--JAVADOC -> JAVADOC 1887 * |--NEWLINE -> \r\n 1888 * |--LEADING_ASTERISK -> * 1889 * |--TEXT -> text before break 1890 * |--HTML_ELEMENT -> HTML_ELEMENT 1891 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1892 * | `--BR_TAG -> BR_TAG 1893 * | |--START -> < 1894 * | |--BR_HTML_TAG_NAME -> br 1895 * | `--END -> > 1896 * |--TEXT -> text after break 1897 * |--NEWLINE -> \r\n 1898 * |--TEXT -> 1899 * } 1900 * </pre> 1901 */ 1902 1903 public static final int BR_HTML_TAG_NAME = JavadocParser.BR_HTML_TAG_NAME; 1904 1905 /** Col tag name. */ 1906 public static final int COL_HTML_TAG_NAME = JavadocParser.COL_HTML_TAG_NAME; 1907 1908 /** 1909 * Frame tag name. 1910 * 1911 * <p><b>Example:</b></p> 1912 * <pre>{@code <frame src="frame_a.html">}</pre> 1913 * 1914 * <p><b>Tree:</b></p> 1915 * <pre> 1916 * {@code 1917 * |--HTML_ELEMENT -> HTML_ELEMENT 1918 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1919 * | `--FRAME_TAG -> FRAME_TAG 1920 * | |--START -> < 1921 * | |--FRAME_HTML_TAG_NAME -> frame 1922 * | |--WS -> 1923 * | |--ATTRIBUTE -> ATTRIBUTE 1924 * | | |--HTML_TAG_NAME -> src 1925 * | | |--EQUALS -> = 1926 * | | `--ATTR_VALUE -> "frame_a.html" 1927 * | `--END -> > 1928 * } 1929 * </pre> 1930 */ 1931 public static final int FRAME_HTML_TAG_NAME = JavadocParser.FRAME_HTML_TAG_NAME; 1932 1933 /** 1934 * Hr tag name. 1935 * 1936 * <p><b>Example:</b></p> 1937 * <pre>{@code text before horizontal rule < hr > text after horizontal rule}</pre> 1938 * <b>Tree:</b> 1939 * <pre> 1940 * {@code 1941 * |--TEXT -> text before horizontal rule 1942 * |--HTML_ELEMENT -> HTML_ELEMENT 1943 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1944 * | `--HR_TAG -> HR_TAG 1945 * | |--START -> < 1946 * | |--HR_HTML_TAG_NAME -> hr 1947 * | `--END -> > 1948 * |--TEXT -> text after horizontal rule 1949 * |--NEWLINE -> \r\n 1950 * } 1951 * </pre> 1952 */ 1953 1954 public static final int HR_HTML_TAG_NAME = JavadocParser.HR_HTML_TAG_NAME; 1955 1956 /** Img tag name. */ 1957 public static final int IMG_HTML_TAG_NAME = JavadocParser.IMG_HTML_TAG_NAME; 1958 1959 /** 1960 * Input tag name. 1961 * 1962 * <p><b>Example:</b></p> 1963 * <pre>{@code <input name="Name" type="text" placeholder="Enter your name"/>}</pre> 1964 * <b>Tree:</b> 1965 * <pre> 1966 * {@code 1967 * HTML_ELEMENT -> HTML_ELEMENT 1968 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1969 * `--INPUT_TAG -> INPUT_TAG 1970 * |--START -> < 1971 * |--INPUT_HTML_TAG_NAME -> input 1972 * |--WS -> 1973 * |--ATTRIBUTE -> ATTRIBUTE 1974 * | |--HTML_TAG_NAME -> name 1975 * | |--EQUALS -> = 1976 * | `--ATTR_VALUE -> "Name" 1977 * |--WS -> 1978 * |--ATTRIBUTE -> ATTRIBUTE 1979 * | |--HTML_TAG_NAME -> type 1980 * | |--EQUALS -> = 1981 * | `--ATTR_VALUE -> "text" 1982 * |--WS -> 1983 * |--ATTRIBUTE -> ATTRIBUTE 1984 * | |--HTML_TAG_NAME -> placeholder 1985 * | |--EQUALS -> = 1986 * | `--ATTR_VALUE -> "Enter your name" 1987 * `--SLASH_END -> /> 1988 * } 1989 * </pre> 1990 * 1991 * @see 1992 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1993 * comments are written in HTML</a> 1994 * @see #INPUT_HTML_TAG_NAME 1995 */ 1996 public static final int INPUT_HTML_TAG_NAME = JavadocParser.INPUT_HTML_TAG_NAME; 1997 1998 /** Isindex tag name. */ 1999 public static final int ISINDEX_HTML_TAG_NAME = JavadocParser.ISINDEX_HTML_TAG_NAME; 2000 2001 /** 2002 * Link tag name. 2003 * 2004 * <p><b>Example:</b></p> 2005 * <pre>{@code <link rel="stylesheet" href="Style.css">}</pre> 2006 * <b>Tree:</b> 2007 * <pre> 2008 * {@code 2009 * HTML_ELEMENT -> HTML_ELEMENT 2010 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2011 * `--LINK_TAG -> LINK_TAG 2012 * |--START -> < 2013 * |--LINK_HTML_TAG_NAME -> link 2014 * |--WS -> 2015 * |--ATTRIBUTE -> ATTRIBUTE 2016 * | |--HTML_TAG_NAME -> rel 2017 * | |--EQUALS -> = 2018 * | `--ATTR_VALUE -> "stylesheet" 2019 * |--WS -> 2020 * |--ATTRIBUTE -> ATTRIBUTE 2021 * | |--HTML_TAG_NAME -> href 2022 * | |--EQUALS -> = 2023 * | `--ATTR_VALUE -> "Style.css" 2024 * `--END -> > 2025 * } 2026 * </pre> 2027 * 2028 * @see 2029 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 2030 * comments are written in HTML</a> 2031 * @see #LINK_HTML_TAG_NAME 2032 */ 2033 public static final int LINK_HTML_TAG_NAME = JavadocParser.LINK_HTML_TAG_NAME; 2034 2035 /** 2036 * Meta tag name. 2037 * 2038 * <p><b>Example:</b></p> 2039 * <pre>{@code <meta charset="UTF-8">}</pre> 2040 * <b>Tree:</b> 2041 * <pre> 2042 * {@code 2043 * HTML_ELEMENT -> HTML_ELEMENT 2044 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2045 * `--META_TAG -> META_TAG 2046 * |--START -> < 2047 * |--META_HTML_TAG_NAME -> meta 2048 * |--WS -> 2049 * |--ATTRIBUTE -> ATTRIBUTE 2050 * | |--HTML_TAG_NAME -> charset 2051 * | |--EQUALS -> = 2052 * | `--ATTR_VALUE -> "UTF-8" 2053 * `--END -> > 2054 * } 2055 * </pre> 2056 */ 2057 public static final int META_HTML_TAG_NAME = JavadocParser.META_HTML_TAG_NAME; 2058 2059 /** Param tag name. */ 2060 public static final int PARAM_HTML_TAG_NAME = JavadocParser.PARAM_HTML_TAG_NAME; 2061 /** "embed" tag name. */ 2062 public static final int EMBED_HTML_TAG_NAME = JavadocParser.EMBED_HTML_TAG_NAME; 2063 /** "keygen" tag name. */ 2064 public static final int KEYGEN_HTML_TAG_NAME = JavadocParser.KEYGEN_HTML_TAG_NAME; 2065 /** "source" tag name. */ 2066 public static final int SOURCE_HTML_TAG_NAME = JavadocParser.SOURCE_HTML_TAG_NAME; 2067 /** "track" tag name. */ 2068 public static final int TRACK_HTML_TAG_NAME = JavadocParser.TRACK_HTML_TAG_NAME; 2069 /** "wbr" tag name. */ 2070 public static final int WBR_HTML_TAG_NAME = JavadocParser.WBR_HTML_TAG_NAME; 2071 /////////////////////////////////////////////////////////////////////////////////////////////// 2072 2073 /** 2074 * HTML comment start symbol '<!--'. 2075 * 2076 * <p><b>Example:</b></p> 2077 * <pre> 2078 * <!-- 2079 * This is an HTML multi-line comment: 2080 * This is another comment 2081 * --> 2082 * </pre> 2083 * <b>Tree:</b> 2084 * <pre> 2085 * {@code 2086 * HTML_COMMENT -> HTML_COMMENT 2087 * |--HTML_COMMENT_START -> <!-- 2088 * |--NEWLINE -> \n 2089 * |--LEADING_ASTERISK -> * 2090 * |--TEXT -> This is an HTML multi-line comment: 2091 * |--NEWLINE -> \n 2092 * |--LEADING_ASTERISK -> * 2093 * |--TEXT -> This is another comment 2094 * |--NEWLINE -> \n 2095 * |--LEADING_ASTERISK -> * 2096 * |--TEXT -> 2097 * `--HTML_COMMENT_END -> --> 2098 * } 2099 * </pre> 2100 */ 2101 public static final int HTML_COMMENT_START = JavadocParser.HTML_COMMENT_START; 2102 2103 /** 2104 * HTML comment end symbol {@code '-->'} . 2105 * 2106 * <p><b>Example:</b></p> 2107 * <pre>{@code 2108 * <!-- 2109 * This is an HTML multi-line comment: 2110 * This is another comment 2111 * --> 2112 * }</pre> 2113 * <b>Tree:</b> 2114 * <pre> 2115 * {@code 2116 * HTML_COMMENT -> HTML_COMMENT 2117 * |--HTML_COMMENT_START -> <!-- 2118 * |--NEWLINE -> \n 2119 * |--LEADING_ASTERISK -> * 2120 * |--TEXT -> This is an HTML multi-line comment: 2121 * |--NEWLINE -> \n 2122 * |--LEADING_ASTERISK -> * 2123 * |--TEXT -> This is another comment 2124 * |--NEWLINE -> \n 2125 * |--LEADING_ASTERISK -> * 2126 * |--TEXT -> 2127 * `--HTML_COMMENT_END -> --> 2128 * } 2129 * </pre> 2130 */ 2131 public static final int HTML_COMMENT_END = JavadocParser.HTML_COMMENT_END; 2132 2133 // ------------------------------------------------------------------------------------------ // 2134 // ----------------- OTHER -------------------------------------------------- // 2135 // ------------------------------------------------------------------------------------------ // 2136 2137 /** Leading asterisk. */ 2138 public static final int LEADING_ASTERISK = JavadocParser.LEADING_ASTERISK; 2139 2140 /** 2141 * Newline symbol - '\n'. 2142 */ 2143 public static final int NEWLINE = JavadocParser.NEWLINE; 2144 2145 /** 2146 * Any other symbol. 2147 */ 2148 public static final int CHAR = JavadocParser.CHAR; 2149 2150 /** 2151 * Whitespace or tab ('\t') symbol. 2152 */ 2153 public static final int WS = JavadocParser.WS; 2154 2155 /** 2156 * End Of File symbol. Copied from 2157 * {@link org.antlr.v4.runtime.Recognizer#EOF} to avoid ANTLR dependency in 2158 * API. 2159 */ 2160 public static final int EOF = -1; 2161 2162 // ------------------------------------------------------------------------------------------ // 2163 // ------ JAVADOC TAGS DEPENDING ON RULE TYPES OFFSET --------------------------------------- // 2164 // ------------------------------------------------------------------------------------------ // 2165 2166 /** 2167 * Rule types offset. 2168 * RULE_TYPES_OFFSET constant is used to split lexer tokens types and parser rules types. 2169 * We need unique numbers for all tokens, 2170 * ANTLR do not need this and that is why these types are mixed by used values. 2171 * All values we can take a look at 2172 * target/generated-sources/antlr/com/puppycrawl/tools/checkstyle/grammar/javadoc/JavadocParser.java 2173 * For example: LEADING_ASTERISK=1 and RULE_htmlElement = 1. 2174 * RULE_TYPES_OFFSET required to shift parser rules, 2175 * to let them not overlap with types that have prefix "RULE_". 2176 */ 2177 private static final int RULE_TYPES_OFFSET = 10000; 2178 2179 /** 2180 * Root node of any Javadoc comment. 2181 * Last child is always {@link #EOF}. 2182 * 2183 * <p><b>Tree for example:</b></p> 2184 * <pre>{@code 2185 * JAVADOC -> JAVADOC 2186 * |--NEWLINE -> \n 2187 * |--LEADING_ASTERISK -> * 2188 * |--WS -> 2189 * |--JAVADOC_TAG -> JAVADOC_TAG 2190 * | |--PARAM_LITERAL -> @param 2191 * | |--WS -> 2192 * | |--PARAMETER_NAME -> T 2193 * | |--WS -> 2194 * | `--DESCRIPTION -> DESCRIPTION 2195 * | |--TEXT -> The bar. 2196 * | |--NEWLINE -> \n 2197 * | `--TEXT -> 2198 * `--EOF -> <EOF> 2199 * }</pre> 2200 */ 2201 public static final int JAVADOC = JavadocParser.RULE_javadoc + RULE_TYPES_OFFSET; 2202 2203 /** 2204 * Javadoc tag. 2205 * 2206 * <p>Type of Javadoc tag is resolved by literal node that is first child of this node.</p> 2207 * 2208 * <p>As literal could be:</p> 2209 * <ul> 2210 * <li>{@link #RETURN_LITERAL}</li> 2211 * <li>{@link #DEPRECATED_LITERAL}</li> 2212 * <li>{@link #SINCE_LITERAL}</li> 2213 * <li>{@link #SERIAL_DATA_LITERAL}</li> 2214 * <li>{@link #SERIAL_FIELD_LITERAL}</li> 2215 * <li>{@link #PARAM_LITERAL}</li> 2216 * <li>{@link #SEE_LITERAL}</li> 2217 * <li>{@link #SERIAL_LITERAL}</li> 2218 * <li>{@link #VERSION_LITERAL}</li> 2219 * <li>{@link #EXCEPTION_LITERAL}</li> 2220 * <li>{@link #THROWS_LITERAL}</li> 2221 * <li>{@link #AUTHOR_LITERAL}</li> 2222 * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc tag.</li> 2223 * </ul> 2224 * 2225 * <p><b>Example</b></p> 2226 * <pre>{@code @param T The bar.}</pre> 2227 * <b>Tree</b> 2228 * <pre>{@code 2229 * JAVADOC_TAG -> JAVADOC_TAG 2230 * |--PARAM_LITERAL -> @param 2231 * |--WS -> 2232 * |--PARAMETER_NAME -> T 2233 * |--WS -> 2234 * `--DESCRIPTION -> DESCRIPTION 2235 * |--TEXT -> The bar. 2236 * |--NEWLINE -> \r\n 2237 * `--TEXT -> 2238 * }</pre> 2239 */ 2240 2241 public static final int JAVADOC_TAG = JavadocParser.RULE_javadocTag + RULE_TYPES_OFFSET; 2242 /** 2243 * Javadoc inline tag. 2244 * 2245 * <p>Type of Javadoc inline tag is resolved by literal node that is second child of this node. 2246 * First child is always {@link #JAVADOC_INLINE_TAG_START} and last node is always 2247 * {@link #JAVADOC_INLINE_TAG_END}.</p> 2248 * 2249 * <p>As literal could be:</p> 2250 * <ul> 2251 * <li>{@link #CODE_LITERAL}</li> 2252 * <li>{@link #DOC_ROOT_LITERAL}</li> 2253 * <li>{@link #LINK_LITERAL}</li> 2254 * <li>{@link #INHERIT_DOC_LITERAL}</li> 2255 * <li>{@link #LINKPLAIN_LITERAL}</li> 2256 * <li>{@link #LITERAL_LITERAL}</li> 2257 * <li>{@link #VALUE_LITERAL}</li> 2258 * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc inline tag.</li> 2259 * </ul> 2260 * 2261 * <p><b>Example:</b></p> 2262 * <pre>{@literal {@link String} }</pre> 2263 * <b>Tree:</b> 2264 * <pre> 2265 * {@code 2266 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 2267 * |--JAVADOC_INLINE_TAG_START -> { 2268 * |--LINK_LITERAL -> @link 2269 * |--WS -> 2270 * |--REFERENCE -> REFERENCE 2271 * `--PACKAGE_CLASS -> String 2272 * `--JAVADOC_INLINE_TAG_END -> } 2273 * } 2274 * </pre> 2275 */ 2276 public static final int JAVADOC_INLINE_TAG = JavadocParser.RULE_javadocInlineTag 2277 + RULE_TYPES_OFFSET; 2278 2279 /** 2280 * Parameter of the Javadoc tags listed below. 2281 * <ul> 2282 * <li>{@link #SEE_LITERAL @see}</li> 2283 * <li>{@link #LINK_LITERAL {@link}}</li> 2284 * <li>{@link #LINKPLAIN_LITERAL {@linkplain}}</li> 2285 * <li>{@link #VALUE_LITERAL {@value}}</li> 2286 * </ul> 2287 */ 2288 public static final int REFERENCE = JavadocParser.RULE_reference + RULE_TYPES_OFFSET; 2289 2290 /** 2291 * Parameters part in {@link #REFERENCE}. 2292 * It is used to specify parameters for {@link #MEMBER method}. 2293 * Always contains {@link #LEFT_BRACE} as first child and {@link #RIGHT_BRACE} as last child. 2294 * Each parameter is represented by {@link #ARGUMENT} node. 2295 * Arguments in braces are separated by {@link #COMMA} (and optional {@link #WS}). 2296 * 2297 * <p><b>Example:</b></p> 2298 * <pre>{@code @see #method(Processor, String)}</pre> 2299 * <b>Tree:</b> 2300 * <pre> 2301 * {@code 2302 * JAVADOC_TAG -> JAVADOC_TAG 2303 * |--SEE_LITERAL -> @see 2304 * |--WS -> 2305 * |--REFERENCE -> REFERENCE 2306 * |--HASH -> # 2307 * |--MEMBER -> method 2308 * `--PARAMETERS -> PARAMETERS 2309 * |--LEFT_BRACE -> ( 2310 * |--ARGUMENT -> Processor 2311 * |--COMMA -> , 2312 * |--WS -> 2313 * |--ARGUMENT -> String 2314 * `--RIGHT_BRACE -> ) 2315 * } 2316 * </pre> 2317 */ 2318 public static final int PARAMETERS = JavadocParser.RULE_parameters + RULE_TYPES_OFFSET; 2319 2320 /** 2321 * Description node. It contains: 2322 * <ul> 2323 * <li>{@link #TEXT}</li> 2324 * <li>{@link #WS}</li> 2325 * <li>{@link #NEWLINE}</li> 2326 * <li>{@link #HTML_ELEMENT}</li> 2327 * </ul> 2328 * 2329 * <p>It is argument for many Javadoc tags and inline tags.</p> 2330 * 2331 * <p><b>Example:</b></p> 2332 * <pre>{@code @throws IOException if <b>connection</b> problems occur}</pre> 2333 * <b>Tree:</b> 2334 * <pre> 2335 * {@code 2336 * --JAVADOC_TAG -> JAVADOC_TAG 2337 * |--THROWS_LITERAL -> @throws 2338 * |--WS -> 2339 * |--CLASS_NAME -> IOException 2340 * |--WS -> 2341 * `--DESCRIPTION -> DESCRIPTION 2342 * |--TEXT -> if 2343 * |--HTML_ELEMENT -> HTML_ELEMENT 2344 * | `--HTML_TAG -> HTML_TAG 2345 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 2346 * | | |--START -> < 2347 * | | |--HTML_TAG_NAME -> b 2348 * | | `--END -> > 2349 * | |--TEXT -> connection 2350 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 2351 * | |--START -> < 2352 * | |--SLASH -> / 2353 * | |--HTML_TAG_NAME -> b 2354 * | `--END -> > 2355 * |--TEXT -> problems occur 2356 * } 2357 * </pre> 2358 */ 2359 public static final int DESCRIPTION = JavadocParser.RULE_description + RULE_TYPES_OFFSET; 2360 2361 // ------------------------------------------------------------------------------------------ // 2362 // -------- HTML TAGS DEPENDING ON RULE TYPES OFFSET ---------------------------------------- // 2363 // ------------------------------------------------------------------------------------------ // 2364 2365 /** 2366 * Parent node for all html tags. 2367 */ 2368 public static final int HTML_ELEMENT = JavadocParser.RULE_htmlElement 2369 + RULE_TYPES_OFFSET; 2370 2371 /** 2372 * Start html tag: {@code <XXXX>}. 2373 */ 2374 public static final int HTML_ELEMENT_START = JavadocParser.RULE_htmlElementStart 2375 + RULE_TYPES_OFFSET; 2376 2377 /** 2378 * End html tag: {@code <XXXX>}. 2379 */ 2380 public static final int HTML_ELEMENT_END = JavadocParser.RULE_htmlElementEnd 2381 + RULE_TYPES_OFFSET; 2382 2383 /** 2384 * Non-special HTML tag. 2385 */ 2386 public static final int HTML_TAG = JavadocParser.RULE_htmlTag + RULE_TYPES_OFFSET; 2387 2388 /** 2389 * Html tag attribute. Parent node for: {@code HTML_TAG_IDENT, EQUALS, ATTR_VALUE}. 2390 * 2391 * <p><b>Example</b></p> 2392 * <pre>{@code <p class="highlight">Sample text</p>}</pre> 2393 * <b>Tree</b> 2394 * <pre> 2395 * {@code 2396 * HTML_ELEMENT -> HTML_ELEMENT 2397 * `--PARAGRAPH -> PARAGRAPH 2398 * |--P_TAG_START -> P_TAG_START 2399 * | |--START -> < 2400 * | |--P_HTML_TAG_NAME -> p 2401 * | |--WS -> 2402 * | |--ATTRIBUTE -> ATTRIBUTE 2403 * | | |--HTML_TAG_NAME -> class 2404 * | | |--EQUALS -> = 2405 * | | `--ATTR_VALUE -> "highlight" 2406 * | `--END -> > 2407 * |--TEXT -> Sample text 2408 * `--P_TAG_END -> P_TAG_END 2409 * |--START -> < 2410 * |--SLASH -> / 2411 * |--P_HTML_TAG_NAME -> p 2412 * `--END -> > 2413 * } 2414 * </pre> 2415 */ 2416 public static final int ATTRIBUTE = JavadocParser.RULE_attribute 2417 + RULE_TYPES_OFFSET; 2418 2419 /////////////////////// HTML TAGS WITH OPTIONAL END TAG ///////////////////////////////////// 2420 /** 2421 * Paragraph html tag. 2422 * 2423 * <p><b>Example:</b></p> 2424 * <pre>{@code <p>Sample text</p>}</pre> 2425 * <b>Tree:</b> 2426 * <pre> 2427 * {@code 2428 * `--JAVADOC -> JAVADOC 2429 * |--NEWLINE -> \r\n 2430 * |--LEADING_ASTERISK -> * 2431 * |--TEXT -> 2432 * |--HTML_ELEMENT -> HTML_ELEMENT 2433 * | `--PARAGRAPH -> PARAGRAPH 2434 * | |--P_TAG_START -> P_TAG_START 2435 * | | |--START -> < 2436 * | | |--P_HTML_TAG_NAME -> p 2437 * | | `--END -> > 2438 * | |--TEXT -> Sample text 2439 * | `--P_TAG_END -> P_TAG_END 2440 * | |--START -> < 2441 * | |--SLASH -> / 2442 * | |--P_HTML_TAG_NAME -> p 2443 * | `--END -> > 2444 * |--NEWLINE -> \r\n 2445 * |--TEXT -> 2446 * } 2447 * </pre> 2448 */ 2449 public static final int PARAGRAPH = JavadocParser.RULE_paragraph + RULE_TYPES_OFFSET; 2450 /** Start paragraph tag. */ 2451 public static final int P_TAG_START = JavadocParser.RULE_pTagStart + RULE_TYPES_OFFSET; 2452 /** End paragraph tag. */ 2453 public static final int P_TAG_END = JavadocParser.RULE_pTagEnd + RULE_TYPES_OFFSET; 2454 2455 /** 2456 * List items html tag. 2457 * 2458 * <p><b>Example:</b></p> 2459 * <pre>{@code 2460 * <ul> 2461 * <li>Item 1</li> 2462 * </ul> 2463 * }</pre> 2464 * <b>Tree:</b> 2465 * <pre> 2466 * {@code 2467 * --JAVADOC -> JAVADOC 2468 * |--NEWLINE -> \n 2469 * |--LEADING_ASTERISK -> * 2470 * |--TEXT -> 2471 * |--HTML_ELEMENT -> HTML_ELEMENT 2472 * | `--HTML_TAG -> HTML_TAG 2473 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 2474 * | | |--START -> < 2475 * | | |--HTML_TAG_NAME -> ul 2476 * | | `--END -> > 2477 * | |--NEWLINE -> \n 2478 * | |--LEADING_ASTERISK -> * 2479 * | |--TEXT -> 2480 * | |--HTML_ELEMENT -> HTML_ELEMENT 2481 * | | `--LI -> LI 2482 * | | |--LI_TAG_START -> LI_TAG_START 2483 * | | | |--START -> < 2484 * | | | |--LI_HTML_TAG_NAME -> li 2485 * | | | `--END -> > 2486 * | | |--TEXT -> Item 1 2487 * | | `--LI_TAG_END -> LI_TAG_END 2488 * | | |--START -> < 2489 * | | |--SLASH -> / 2490 * | | |--LI_HTML_TAG_NAME -> li 2491 * | | `--END -> > 2492 * | |--NEWLINE -> \n 2493 * | |--LEADING_ASTERISK -> * 2494 * | |--TEXT -> 2495 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 2496 * | |--START -> < 2497 * | |--SLASH -> / 2498 * | |--HTML_TAG_NAME -> ul 2499 * | `--END -> > 2500 * |--NEWLINE -> \n 2501 * |--TEXT -> 2502 * } 2503 * </pre> 2504 */ 2505 public static final int LI = JavadocParser.RULE_li + RULE_TYPES_OFFSET; 2506 /** Start list item tag. */ 2507 public static final int LI_TAG_START = JavadocParser.RULE_liTagStart + RULE_TYPES_OFFSET; 2508 /** End list item tag. */ 2509 public static final int LI_TAG_END = JavadocParser.RULE_liTagEnd + RULE_TYPES_OFFSET; 2510 2511 /** 2512 * Table row html tag. 2513 * 2514 * <p><b>Example:</b></p> 2515 * <pre>{@code <tr></tr>}</pre> 2516 * <b>Tree:</b> 2517 * <pre> 2518 * {@code 2519 * JAVADOC -> JAVADOC 2520 * |--NEWLINE -> \r\n 2521 * |--LEADING_ASTERISK -> * 2522 * |--TEXT -> 2523 * |--HTML_ELEMENT -> HTML_ELEMENT 2524 * | `--TR -> TR 2525 * | |--TR_TAG_START -> TR_TAG_START 2526 * | | |--START -> < 2527 * | | |--TR_HTML_TAG_NAME -> tr 2528 * | | `--END -> > 2529 * | `--TR_TAG_END -> TR_TAG_END 2530 * | |--START -> < 2531 * | |--SLASH -> / 2532 * | |--TR_HTML_TAG_NAME -> tr 2533 * | `--END -> > 2534 * |--NEWLINE -> \r\n 2535 * |--TEXT -> 2536 * } 2537 * </pre> 2538 */ 2539 public static final int TR = JavadocParser.RULE_tr + RULE_TYPES_OFFSET; 2540 /** Start table row tag. */ 2541 public static final int TR_TAG_START = JavadocParser.RULE_trTagStart + RULE_TYPES_OFFSET; 2542 /** End table row tag. */ 2543 public static final int TR_TAG_END = JavadocParser.RULE_trTagEnd + RULE_TYPES_OFFSET; 2544 2545 /** 2546 * Table cell HTML tag. 2547 * 2548 * <p><b>Example:</b></p> 2549 * <pre>{@code <td>Cell Content</td>}</pre> 2550 * <b>Tree:</b> 2551 * <pre> 2552 * {@code 2553 * HTML_ELEMENT -> HTML_ELEMENT 2554 * `--TD -> TD 2555 * |--TD_TAG_START -> TD_TAG_START 2556 * | |--START -> < 2557 * | |--TD_HTML_TAG_NAME -> td 2558 * | `--END -> > 2559 * |--TEXT -> Cell Content 2560 * `--TD_TAG_END -> TD_TAG_END 2561 * |--START -> < 2562 * |--SLASH -> / 2563 * |--TD_HTML_TAG_NAME -> td 2564 * `--END -> > 2565 * } 2566 * </pre> 2567 */ 2568 public static final int TD = JavadocParser.RULE_td + RULE_TYPES_OFFSET; 2569 /** Start table cell tag. */ 2570 public static final int TD_TAG_START = JavadocParser.RULE_tdTagStart + RULE_TYPES_OFFSET; 2571 /** End table cell tag. */ 2572 public static final int TD_TAG_END = JavadocParser.RULE_tdTagEnd + RULE_TYPES_OFFSET; 2573 2574 /** Table header cell html tag: {@code <th></th>}. */ 2575 public static final int TH = JavadocParser.RULE_th + RULE_TYPES_OFFSET; 2576 /** Start table header cell tag. */ 2577 public static final int TH_TAG_START = JavadocParser.RULE_thTagStart + RULE_TYPES_OFFSET; 2578 /** End table header cell tag. */ 2579 public static final int TH_TAG_END = JavadocParser.RULE_thTagEnd + RULE_TYPES_OFFSET; 2580 2581 /** Body html tag. */ 2582 public static final int BODY = JavadocParser.RULE_body + RULE_TYPES_OFFSET; 2583 2584 /** 2585 * Start body tag. 2586 * 2587 * <p><b>Example:</b></p> 2588 * <pre> 2589 * <body> 2590 * This is a test 2591 * </body> 2592 * </pre> 2593 * <b>Tree:</b> 2594 * <pre> 2595 * {@code 2596 * JAVADOC -> JAVADOC 2597 * |--TEXT -> /** 2598 * |--NEWLINE -> \n 2599 * |--LEADING_ASTERISK -> * 2600 * |--TEXT -> 2601 * |--HTML_ELEMENT -> HTML_ELEMENT 2602 * | `--BODY -> BODY 2603 * | |--BODY_TAG_START -> BODY_TAG_START 2604 * | | |--START -> < 2605 * | | |--BODY_HTML_TAG_NAME -> body 2606 * | | `--END -> > 2607 * | |--NEWLINE -> \n 2608 * | |--LEADING_ASTERISK -> * 2609 * | |--TEXT -> This is inside the body tag. 2610 * | |--NEWLINE -> \n 2611 * | |--LEADING_ASTERISK -> * 2612 * | |--TEXT -> 2613 * | `--BODY_TAG_END -> BODY_TAG_END 2614 * | |--START -> < 2615 * | |--SLASH -> / 2616 * | |--BODY_HTML_TAG_NAME -> body 2617 * | `--END -> > 2618 * |--NEWLINE -> \n 2619 * |--LEADING_ASTERISK -> * 2620 * |--TEXT -> / 2621 * |--NEWLINE -> \n 2622 * |--TEXT -> public class Test { 2623 * |--NEWLINE -> \n 2624 * |--TEXT -> } 2625 * |--NEWLINE -> \n 2626 * } 2627 * </pre> 2628 */ 2629 public static final int BODY_TAG_START = JavadocParser.RULE_bodyTagStart + RULE_TYPES_OFFSET; 2630 2631 /** 2632 * End body tag. 2633 * 2634 * <p><b>Example:</b></p> 2635 * <pre> 2636 * <body> 2637 * This is a test 2638 * </body> 2639 * </pre> 2640 * <b>Tree:</b> 2641 * <pre> 2642 * {@code 2643 * JAVADOC -> JAVADOC 2644 * |--TEXT -> /** 2645 * |--NEWLINE -> \n 2646 * |--LEADING_ASTERISK -> * 2647 * |--TEXT -> 2648 * |--HTML_ELEMENT -> HTML_ELEMENT 2649 * | `--BODY -> BODY 2650 * | |--BODY_TAG_START -> BODY_TAG_START 2651 * | | |--START -> < 2652 * | | |--BODY_HTML_TAG_NAME -> body 2653 * | | `--END -> > 2654 * | |--NEWLINE -> \n 2655 * | |--LEADING_ASTERISK -> * 2656 * | |--TEXT -> This is inside the body tag. 2657 * | |--NEWLINE -> \n 2658 * | |--LEADING_ASTERISK -> * 2659 * | |--TEXT -> 2660 * | `--BODY_TAG_END -> BODY_TAG_END 2661 * | |--START -> < 2662 * | |--SLASH -> / 2663 * | |--BODY_HTML_TAG_NAME -> body 2664 * | `--END -> > 2665 * |--NEWLINE -> \n 2666 * |--LEADING_ASTERISK -> * 2667 * |--TEXT -> / 2668 * |--NEWLINE -> \n 2669 * |--TEXT -> public class Test { 2670 * |--NEWLINE -> \n 2671 * |--TEXT -> } 2672 * |--NEWLINE -> \n 2673 * } 2674 * </pre> 2675 */ 2676 public static final int BODY_TAG_END = JavadocParser.RULE_bodyTagEnd + RULE_TYPES_OFFSET; 2677 2678 /** 2679 * Colgroup html tag. 2680 * 2681 * <p><b>Example:</b></p> 2682 * <pre>{@code 2683 * <colgroup> 2684 * <col /> 2685 * <col span="2" class="batman" /> 2686 * </colgroup> 2687 * }</pre> 2688 * <b>Tree:</b> 2689 * <pre> 2690 * {@code 2691 * --JAVADOC -> JAVADOC 2692 * |--NEWLINE -> \n 2693 * |--LEADING_ASTERISK -> * 2694 * |--TEXT -> 2695 * |--HTML_ELEMENT -> HTML_ELEMENT 2696 * | `--COLGROUP -> COLGROUP 2697 * | |--COLGROUP_TAG_START -> COLGROUP_TAG_START 2698 * | | |--START -> < 2699 * | | |--COLGROUP_HTML_TAG_NAME -> colgroup 2700 * | | | `--END -> > 2701 * | |--NEWLINE -> \n 2702 * | |--LEADING_ASTERISK -> * 2703 * | |--TEXT -> 2704 * | |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2705 * | | `--COL_TAG -> COL_TAG 2706 * | | |--START -> < 2707 * | | |--COL_HTML_TAG_NAME -> col 2708 * | | |--WS -> 2709 * | | `--SLASH_END -> /> 2710 * | |--NEWLINE -> \n 2711 * | |--LEADING_ASTERISK -> * 2712 * | |--TEXT -> 2713 * | |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2714 * | | `--COL_TAG -> COL_TAG 2715 * | | |--START -> < 2716 * | | |--COL_HTML_TAG_NAME -> col 2717 * | | |--WS -> 2718 * | | |--ATTRIBUTE -> ATTRIBUTE 2719 * | | | |--HTML_TAG_NAME -> span 2720 * | | | |--EQUALS -> = 2721 * | | | `--ATTR_VALUE -> "2" 2722 * | | |--WS -> 2723 * | | |--ATTRIBUTE -> ATTRIBUTE 2724 * | | | |--HTML_TAG_NAME -> class 2725 * | | | |--EQUALS -> = 2726 * | | | `--ATTR_VALUE -> "batman" 2727 * | | |--WS -> 2728 * | | `--SLASH_END -> /> 2729 * | |--NEWLINE -> \n 2730 * | |--LEADING_ASTERISK -> * 2731 * | |--TEXT -> 2732 * | `--COLGROUP_TAG_END -> COLGROUP_TAG_END 2733 * | | |--START -> < 2734 * | | |--SLASH -> / 2735 * | | |--COLGROUP_HTML_TAG_NAME -> colgroup 2736 * | | `--END -> > 2737 * |--NEWLINE -> \n 2738 * |--TEXT -> 2739 * } 2740 * </pre> 2741 */ 2742 public static final int COLGROUP = JavadocParser.RULE_colgroup + RULE_TYPES_OFFSET; 2743 /** Start colgroup tag. */ 2744 public static final int COLGROUP_TAG_START = JavadocParser.RULE_colgroupTagStart 2745 + RULE_TYPES_OFFSET; 2746 /** End colgroup tag. */ 2747 public static final int COLGROUP_TAG_END = JavadocParser.RULE_colgroupTagEnd 2748 + RULE_TYPES_OFFSET; 2749 2750 /** 2751 * DD html tag. 2752 * 2753 * <p><b>Example AST:</b></p> 2754 * <pre>{@code <dd>Description content</dd>}</pre> 2755 * <pre> 2756 * {@code 2757 * --HTML_ELEMENT -> HTML_ELEMENT 2758 * `--DD -> DD 2759 * |--DD_TAG_START -> DD_TAG_START 2760 * | |--START -> < 2761 * | |--DD_HTML_TAG_NAME -> dd 2762 * | `--END -> > 2763 * |--TEXT -> "Description content" 2764 * `--DD_TAG_END -> DD_TAG_END 2765 * |--START -> < 2766 * |--SLASH -> / 2767 * |--DD_HTML_TAG_NAME -> dd 2768 * `--END -> > 2769 * } 2770 * </pre> 2771 */ 2772 public static final int DD = JavadocParser.RULE_dd + RULE_TYPES_OFFSET; 2773 /** Start description of a term tag. */ 2774 public static final int DD_TAG_START = JavadocParser.RULE_ddTagStart + RULE_TYPES_OFFSET; 2775 /** End description of a term tag. */ 2776 public static final int DD_TAG_END = JavadocParser.RULE_ddTagEnd + RULE_TYPES_OFFSET; 2777 2778 /** 2779 * DT html tag. 2780 * 2781 * <p><b>Example AST:</b></p> 2782 * <pre>{@code <dd>Description Term</dd>}</pre> 2783 * <pre> 2784 * {@code 2785 * --HTML_ELEMENT -> HTML_ELEMENT 2786 * `--DT -> DT 2787 * |--DT_TAG_START -> DT_TAG_START 2788 * | |--START -> < 2789 * | |--DT_HTML_TAG_NAME -> dt 2790 * | `--END -> > 2791 * |--TEXT -> "Description term" 2792 * `--DT_TAG_END -> DT_TAG_END 2793 * |--START -> < 2794 * |--SLASH -> / 2795 * |--DT_HTML_TAG_NAME -> dt 2796 * `--END -> > 2797 * } 2798 * </pre> 2799 */ 2800 public static final int DT = JavadocParser.RULE_dt + RULE_TYPES_OFFSET; 2801 /** Start description term tag. */ 2802 public static final int DT_TAG_START = JavadocParser.RULE_dtTagStart + RULE_TYPES_OFFSET; 2803 /** End description term tag. */ 2804 public static final int DT_TAG_END = JavadocParser.RULE_dtTagEnd + RULE_TYPES_OFFSET; 2805 2806 /** Head html tag. */ 2807 public static final int HEAD = JavadocParser.RULE_head + RULE_TYPES_OFFSET; 2808 /** Start head tag. */ 2809 public static final int HEAD_TAG_START = JavadocParser.RULE_headTagStart + RULE_TYPES_OFFSET; 2810 /** End head tag. */ 2811 public static final int HEAD_TAG_END = JavadocParser.RULE_headTagEnd + RULE_TYPES_OFFSET; 2812 2813 /** Html html tag. */ 2814 public static final int HTML = JavadocParser.RULE_html + RULE_TYPES_OFFSET; 2815 /** Start html tag. */ 2816 public static final int HTML_TAG_START = JavadocParser.RULE_htmlTagStart + RULE_TYPES_OFFSET; 2817 /** End html tag. */ 2818 public static final int HTML_TAG_END = JavadocParser.RULE_htmlTagEnd + RULE_TYPES_OFFSET; 2819 2820 /** Option html tag. */ 2821 public static final int OPTION = JavadocParser.RULE_option + RULE_TYPES_OFFSET; 2822 /** Start option tag. */ 2823 public static final int OPTION_TAG_START = 2824 JavadocParser.RULE_optionTagStart + RULE_TYPES_OFFSET; 2825 /** End option tag. */ 2826 public static final int OPTION_TAG_END = JavadocParser.RULE_optionTagEnd 2827 + RULE_TYPES_OFFSET; 2828 2829 /** 2830 * Table body html tag. 2831 * 2832 * <p><b>Example:</b></p> 2833 * <pre>{@code <table><tbody></tbody></table>}</pre> 2834 * <b>Tree:</b> 2835 * <pre> 2836 * {@code 2837 * JAVADOC -> JAVADOC 2838 * |--NEWLINE -> \r\n 2839 * |--LEADING_ASTERISK -> * 2840 * |--TEXT -> 2841 * |--HTML_ELEMENT -> HTML_ELEMENT 2842 * | `--HTML_TAG -> HTML_TAG 2843 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 2844 * | | |--START -> < 2845 * | | |--HTML_TAG_NAME -> table 2846 * | | `--END -> > 2847 * | |--HTML_ELEMENT -> HTML_ELEMENT 2848 * | | `--TBODY -> TBODY 2849 * | | |--TBODY_TAG_START -> TBODY_TAG_START 2850 * | | | |--START -> < 2851 * | | | |--TBODY_HTML_TAG_NAME -> tbody 2852 * | | | `--END -> > 2853 * | | `--TBODY_TAG_END -> TBODY_TAG_END 2854 * | | |--START -> < 2855 * | | |--SLASH -> / 2856 * | | |--TBODY_HTML_TAG_NAME -> tbody 2857 * | | `--END -> > 2858 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 2859 * | |--START -> < 2860 * | |--SLASH -> / 2861 * | |--HTML_TAG_NAME -> table 2862 * | `--END -> > 2863 * |--NEWLINE -> \r\n 2864 * } 2865 * </pre> 2866 */ 2867 public static final int TBODY = JavadocParser.RULE_tbody + RULE_TYPES_OFFSET; 2868 /** Start table body tag. */ 2869 public static final int TBODY_TAG_START = JavadocParser.RULE_tbodyTagStart + RULE_TYPES_OFFSET; 2870 /** End table body tag. */ 2871 public static final int TBODY_TAG_END = JavadocParser.RULE_tbodyTagEnd + RULE_TYPES_OFFSET; 2872 2873 /** Table foot html tag. */ 2874 public static final int TFOOT = JavadocParser.RULE_tfoot + RULE_TYPES_OFFSET; 2875 /** Start table foot tag. */ 2876 public static final int TFOOT_TAG_START = JavadocParser.RULE_tfootTagStart + RULE_TYPES_OFFSET; 2877 /** End table foot tag. */ 2878 public static final int TFOOT_TAG_END = JavadocParser.RULE_tfootTagEnd + RULE_TYPES_OFFSET; 2879 2880 /** Table head html tag. */ 2881 public static final int THEAD = JavadocParser.RULE_thead + RULE_TYPES_OFFSET; 2882 /** Start table head tag. */ 2883 public static final int THEAD_TAG_START = JavadocParser.RULE_theadTagStart + RULE_TYPES_OFFSET; 2884 /** End table head tag. */ 2885 public static final int THEAD_TAG_END = JavadocParser.RULE_theadTagEnd + RULE_TYPES_OFFSET; 2886 2887 /** `optgroup` html tag. */ 2888 public static final int OPTGROUP = JavadocParser.RULE_optgroup + RULE_TYPES_OFFSET; 2889 /** `optgroup` tag start. */ 2890 public static final int OPTGROUP_TAG_START = 2891 JavadocParser.RULE_optgroupTagStart + RULE_TYPES_OFFSET; 2892 /** `optgroup` tag end. */ 2893 public static final int OPTGROUP_TAG_END = 2894 JavadocParser.RULE_optgroupTagEnd + RULE_TYPES_OFFSET; 2895 2896 /** `rb` html tag. */ 2897 public static final int RB = JavadocParser.RULE_rb + RULE_TYPES_OFFSET; 2898 /** `rb` tag start. */ 2899 public static final int RB_TAG_START = 2900 JavadocParser.RULE_rbTagStart + RULE_TYPES_OFFSET; 2901 /** `rb` tag end. */ 2902 public static final int RB_TAG_END = 2903 JavadocParser.RULE_rbTagEnd + RULE_TYPES_OFFSET; 2904 2905 /** `rt` html tag. */ 2906 public static final int RT = JavadocParser.RULE_rt + RULE_TYPES_OFFSET; 2907 /** `rt` tag start. */ 2908 public static final int RT_TAG_START = 2909 JavadocParser.RULE_rtTagStart + RULE_TYPES_OFFSET; 2910 /** `rt` tag end. */ 2911 public static final int RT_TAG_END = 2912 JavadocParser.RULE_rtTagEnd + RULE_TYPES_OFFSET; 2913 2914 /** `rtc` html tag. */ 2915 public static final int RTC = JavadocParser.RULE_rtc + RULE_TYPES_OFFSET; 2916 /** `rtc` tag start. */ 2917 public static final int RTC_TAG_START = 2918 JavadocParser.RULE_rtcTagStart + RULE_TYPES_OFFSET; 2919 /** `rtc` tag end. */ 2920 public static final int RTC_TAG_END = 2921 JavadocParser.RULE_rtcTagEnd + RULE_TYPES_OFFSET; 2922 2923 /** `rp` html tag. */ 2924 public static final int RP = JavadocParser.RULE_rp + RULE_TYPES_OFFSET; 2925 /** `rp` tag start. */ 2926 public static final int RP_TAG_START = 2927 JavadocParser.RULE_rpTagStart + RULE_TYPES_OFFSET; 2928 /** `rp` tag end. */ 2929 public static final int RP_TAG_END = 2930 JavadocParser.RULE_rpTagEnd + RULE_TYPES_OFFSET; 2931 2932 /////////////////////// SINGLETON HTML TAGS ////////////////////////////////////////////////// 2933 /** 2934 * Parent node for all singleton html tags. 2935 */ 2936 public static final int SINGLETON_ELEMENT = JavadocParser.RULE_singletonElement 2937 + RULE_TYPES_OFFSET; 2938 2939 /** 2940 * Represents an empty (self-closing) HTML tag in Javadoc comments, 2941 * such as {@code <justsometag />}. 2942 * 2943 * <p><b>Example:</b></p> 2944 * <pre>{@code <justsometag />}</pre> 2945 * 2946 * <p><b>AST Tree:</b></p> 2947 * <pre>{@code 2948 * --HTML_ELEMENT -> HTML_ELEMENT 2949 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2950 * `--EMPTY_TAG -> EMPTY_TAG 2951 * |--START -> < 2952 * |--HTML_TAG_NAME -> justsometag 2953 * |--WS 2954 * `--SLASH_END -> > 2955 * }</pre> 2956 */ 2957 public static final int EMPTY_TAG = 2958 JavadocParser.RULE_emptyTag + RULE_TYPES_OFFSET; 2959 2960 /** 2961 * Area html tag. 2962 * 2963 * <p><b>Example:</b></p> 2964 * <pre>{@code < area shape="rect" >}</pre> 2965 * <b>Tree:</b> 2966 * <pre> 2967 * {@code 2968 * JAVADOC -> JAVADOC 2969 * |--NEWLINE -> \n 2970 * |--LEADING_ASTERISK -> * 2971 * |--TEXT -> 2972 * |--HTML_ELEMENT -> HTML_ELEMENT 2973 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2974 * | `--AREA_TAG -> AREA_TAG 2975 * | |--START -> < 2976 * | |--AREA_HTML_TAG_NAME -> area 2977 * | |--WS -> 2978 * | |--ATTRIBUTE -> ATTRIBUTE 2979 * | | |--HTML_TAG_NAME -> shape 2980 * | | |--EQUALS -> = 2981 * | | `--ATTR_VALUE -> "rect" 2982 * | `--END -> > 2983 * |--TEXT -> 2984 * |--NEWLINE -> \n 2985 * |--TEXT -> 2986 * } 2987 * </pre> 2988 */ 2989 public static final int AREA_TAG = JavadocParser.RULE_areaTag + RULE_TYPES_OFFSET; 2990 2991 /** Base html tag. */ 2992 public static final int BASE_TAG = JavadocParser.RULE_baseTag + RULE_TYPES_OFFSET; 2993 2994 /** Basefont html tag. */ 2995 public static final int BASEFONT_TAG = JavadocParser.RULE_basefontTag + RULE_TYPES_OFFSET; 2996 2997 /** 2998 * Br html tag. 2999 * 3000 * <p><b>Example:</b></p> 3001 * <pre>{@code <br> line breaks<br/>}</pre> 3002 * <b>Tree:</b> 3003 * <pre> 3004 * {@code 3005 * JAVADOC -> JAVADOC 3006 * |--NEWLINE -> \r\n 3007 * |--LEADING_ASTERISK -> * 3008 * |--TEXT -> 3009 * |--HTML_ELEMENT -> HTML_ELEMENT 3010 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3011 * | `--BR_TAG -> BR_TAG 3012 * | |--START -> < 3013 * | |--BR_HTML_TAG_NAME -> br 3014 * | `--END -> > 3015 * |--TEXT -> line breaks 3016 * |--HTML_ELEMENT -> HTML_ELEMENT 3017 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3018 * | `--BR_TAG -> BR_TAG 3019 * | |--START -> < 3020 * | |--BR_HTML_TAG_NAME -> br 3021 * | `--SLASH_END -> /> 3022 * } 3023 * </pre> 3024 */ 3025 public static final int BR_TAG = JavadocParser.RULE_brTag + RULE_TYPES_OFFSET; 3026 3027 /** Col html tag. */ 3028 public static final int COL_TAG = JavadocParser.RULE_colTag + RULE_TYPES_OFFSET; 3029 3030 /** 3031 * Frame html tag. 3032 * 3033 * <p><b>Example:</b></p> 3034 * <pre> 3035 * <frameset cols="50%,50%"> 3036 * <frame src="page1.html"> 3037 * </frameset> 3038 * </pre> 3039 * <b>Tree:</b> 3040 * <pre> 3041 * {@code 3042 * HTML_ELEMENT -> HTML_ELEMENT 3043 * `--HTML_TAG -> HTML_TAG 3044 * |--HTML_ELEMENT_START -> HTML_ELEMENT_START 3045 * | |--START -> < 3046 * | |--HTML_TAG_NAME -> frameset 3047 * | |--WS -> 3048 * | |--ATTRIBUTE -> ATTRIBUTE 3049 * | | |--HTML_TAG_NAME -> cols 3050 * | | |--EQUALS -> = 3051 * | | `--ATTR_VALUE -> "50%,50%" 3052 * | `--END -> > 3053 * |--NEWLINE -> \r\n 3054 * |--LEADING_ASTERISK -> * 3055 * |--TEXT -> 3056 * |--HTML_ELEMENT -> HTML_ELEMENT 3057 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3058 * | `--FRAME_TAG -> FRAME_TAG 3059 * | |--START -> < 3060 * | |--FRAME_HTML_TAG_NAME -> frame 3061 * | |--WS -> 3062 * | |--ATTRIBUTE -> ATTRIBUTE 3063 * | | |--HTML_TAG_NAME -> src 3064 * | | |--EQUALS -> = 3065 * | | `--ATTR_VALUE -> "page1.html" 3066 * | `--END -> > 3067 * |--NEWLINE -> \r\n 3068 * |--LEADING_ASTERISK -> * 3069 * |--TEXT -> 3070 * `--HTML_ELEMENT_END -> HTML_ELEMENT_END 3071 * |--START -> < 3072 * |--SLASH -> / 3073 * |--HTML_TAG_NAME -> frameset 3074 * `--END -> > 3075 * } 3076 * </pre> 3077 */ 3078 public static final int FRAME_TAG = JavadocParser.RULE_frameTag + RULE_TYPES_OFFSET; 3079 3080 /** 3081 * Hr html tag. 3082 * 3083 * <p><b>Example:</b></p> 3084 * <pre>{@code text above line<hr> test after line}</pre> 3085 * <b>Tree:</b> 3086 * <pre> 3087 * {@code 3088 * |--LEADING_ASTERISK -> * 3089 * |--TEXT -> text above line 3090 * |--HTML_ELEMENT -> HTML_ELEMENT 3091 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3092 * | `--HR_TAG -> HR_TAG 3093 * | |--START -> < 3094 * | |--HR_HTML_TAG_NAME -> hr 3095 * | `--END -> > 3096 * |--TEXT -> test after line 3097 * |--NEWLINE -> \r\n 3098 * |--TEXT -> 3099 * } 3100 * </pre> 3101 */ 3102 public static final int HR_TAG = JavadocParser.RULE_hrTag + RULE_TYPES_OFFSET; 3103 3104 /** 3105 * Img html tag. 3106 * 3107 * <p><b>Example:</b></p> 3108 * <pre>{@code <img src="./image.png" alt="image description" width="200" height="100"> }</pre> 3109 * <b>Tree:</b> 3110 * <pre> 3111 * {@code 3112 * `--JAVADOC -> JAVADOC 3113 * |--NEWLINE -> \r\n 3114 * |--LEADING_ASTERISK -> * 3115 * |--TEXT -> 3116 * |--HTML_ELEMENT -> HTML_ELEMENT 3117 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3118 * | `--IMG_TAG -> IMG_TAG 3119 * | |--START -> < 3120 * | |--IMG_HTML_TAG_NAME -> img 3121 * | |--WS -> 3122 * | |--ATTRIBUTE -> ATTRIBUTE 3123 * | | |--HTML_TAG_NAME -> src 3124 * | | |--EQUALS -> = 3125 * | | `--ATTR_VALUE -> "./image.png" 3126 * | |--WS -> 3127 * | |--ATTRIBUTE -> ATTRIBUTE 3128 * | | |--HTML_TAG_NAME -> alt 3129 * | | |--EQUALS -> = 3130 * | | `--ATTR_VALUE -> "image description" 3131 * | |--WS -> 3132 * | |--ATTRIBUTE -> ATTRIBUTE 3133 * | | |--HTML_TAG_NAME -> width 3134 * | | |--EQUALS -> = 3135 * | | `--ATTR_VALUE -> "200" 3136 * | |--WS -> 3137 * | |--ATTRIBUTE -> ATTRIBUTE 3138 * | | |--HTML_TAG_NAME -> height 3139 * | | |--EQUALS -> = 3140 * | | `--ATTR_VALUE -> "100" 3141 * | `--END -> > 3142 * |--NEWLINE -> \r\n 3143 * |--TEXT -> 3144 * } 3145 * </pre> 3146 */ 3147 public static final int IMG_TAG = JavadocParser.RULE_imgTag + RULE_TYPES_OFFSET; 3148 3149 /** 3150 * Input html tag. 3151 * 3152 * <p><b>Example:</b></p> 3153 * <pre>{@code Type here: <input type="text" id="id" name="name"> }</pre> 3154 * <b>Tree:</b> 3155 * <pre> 3156 * {@code 3157 * JAVADOC -> JAVADOC 3158 * |--NEWLINE -> \r\n 3159 * |--LEADING_ASTERISK -> * 3160 * |--TEXT -> Type here: 3161 * |--HTML_ELEMENT -> HTML_ELEMENT 3162 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3163 * | `--INPUT_TAG -> INPUT_TAG 3164 * | |--START -> < 3165 * | |--INPUT_HTML_TAG_NAME -> input 3166 * | |--WS -> 3167 * | |--ATTRIBUTE -> ATTRIBUTE 3168 * | | |--HTML_TAG_NAME -> type 3169 * | | |--EQUALS -> = 3170 * | | `--ATTR_VALUE -> "text" 3171 * | |--WS -> 3172 * | |--ATTRIBUTE -> ATTRIBUTE 3173 * | | |--HTML_TAG_NAME -> id 3174 * | | |--EQUALS -> = 3175 * | | `--ATTR_VALUE -> "id" 3176 * | |--WS -> 3177 * | |--ATTRIBUTE -> ATTRIBUTE 3178 * | | |--HTML_TAG_NAME -> name 3179 * | | |--EQUALS -> = 3180 * | | `--ATTR_VALUE -> "name" 3181 * | `--END -> > 3182 * |--NEWLINE -> \r\n 3183 * |--TEXT -> 3184 * } 3185 * </pre> 3186 */ 3187 public static final int INPUT_TAG = JavadocParser.RULE_inputTag + RULE_TYPES_OFFSET; 3188 3189 /** 3190 * Isindex tag name. 3191 * 3192 * <p><b>Example:</b></p> 3193 * <pre> 3194 * <head> 3195 * <isindex prompt="search"> 3196 * </head> 3197 * </pre> 3198 * <b>Tree:</b> 3199 * <pre> 3200 * {@code 3201 * |--HTML_ELEMENT -> HTML_ELEMENT 3202 * | `--HEAD -> HEAD 3203 * | |--HEAD_TAG_START -> HEAD_TAG_START 3204 * | | |--START -> < 3205 * | | |--HEAD_HTML_TAG_NAME -> head 3206 * | | `--END -> > 3207 * | |--NEWLINE -> \r\n 3208 * | |--LEADING_ASTERISK -> * 3209 * | |--TEXT -> 3210 * | |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3211 * | | `--ISINDEX_TAG -> ISINDEX_TAG 3212 * | | |--START -> < 3213 * | | |--ISINDEX_HTML_TAG_NAME -> isindex 3214 * | | |--WS -> 3215 * | | |--ATTRIBUTE -> ATTRIBUTE 3216 * | | | |--HTML_TAG_NAME -> prompt 3217 * | | | |--EQUALS -> = 3218 * | | | `--ATTR_VALUE -> "search" 3219 * | | `--END -> > 3220 * | |--NEWLINE -> \r\n 3221 * | |--LEADING_ASTERISK -> * 3222 * | |--TEXT -> 3223 * | `--HEAD_TAG_END -> HEAD_TAG_END 3224 * | |--START -> < 3225 * | |--SLASH -> / 3226 * | |--HEAD_HTML_TAG_NAME -> head 3227 * | `--END -> > 3228 * |--NEWLINE -> \r\n 3229 * |--TEXT -> 3230 * } 3231 * </pre> 3232 */ 3233 public static final int ISINDEX_TAG = JavadocParser.RULE_isindexTag + RULE_TYPES_OFFSET; 3234 3235 /** 3236 * Link html tag. 3237 * 3238 * <p><b>Example:</b></p> 3239 * <pre>{@code <link rel="stylesheet" href="styles.css">}</pre> 3240 * 3241 * <b>Tree:</b> 3242 * <pre> 3243 * {@code 3244 * HTML_ELEMENT -> HTML_ELEMENT 3245 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3246 * `--LINK_TAG -> LINK_TAG 3247 * |--START -> < 3248 * |--LINK_HTML_TAG_NAME -> link 3249 * |--ATTRIBUTE -> ATTRIBUTE 3250 * | |--HTML_TAG_NAME -> rel 3251 * | |--EQUALS -> = 3252 * | `--ATTR_VALUE -> "stylesheet" 3253 * |--ATTRIBUTE -> ATTRIBUTE 3254 * | |--HTML_TAG_NAME -> href 3255 * | |--EQUALS -> = 3256 * | `--ATTR_VALUE -> "styles.css" 3257 * `--END -> > 3258 * } 3259 * </pre> 3260 */ 3261 public static final int LINK_TAG = JavadocParser.RULE_linkTag + RULE_TYPES_OFFSET; 3262 3263 /** 3264 * Meta html tag. 3265 * 3266 * <p><b>Example:</b></p> 3267 * <pre>{@code <meta charset="UTF-8"> }</pre> 3268 * <b>Tree:</b> 3269 * <pre> 3270 * {@code 3271 * `--JAVADOC -> JAVADOC 3272 * |--NEWLINE -> \r\n 3273 * |--LEADING_ASTERISK -> * 3274 * |--TEXT -> 3275 * |--HTML_ELEMENT -> HTML_ELEMENT 3276 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3277 * | `--META_TAG -> META_TAG 3278 * | |--START -> < 3279 * | |--META_HTML_TAG_NAME -> meta 3280 * | |--WS -> 3281 * | |--ATTRIBUTE -> ATTRIBUTE 3282 * | | |--HTML_TAG_NAME -> charset 3283 * | | |--EQUALS -> = 3284 * | | `--ATTR_VALUE -> "UTF-8" 3285 * | `--END -> > 3286 * |--NEWLINE -> \r\n 3287 * |--TEXT -> 3288 * } 3289 * </pre> 3290 */ 3291 public static final int META_TAG = JavadocParser.RULE_metaTag + RULE_TYPES_OFFSET; 3292 3293 /** Param html tag. */ 3294 public static final int PARAM_TAG = JavadocParser.RULE_paramTag + RULE_TYPES_OFFSET; 3295 3296 /** 3297 * HTML void element. 3298 * 3299 * <p><b>Example:</b></p> 3300 * <pre>{@code 3301 * <embed src="URL" type="MIME_type"> 3302 * }</pre> 3303 * <b>Tree:</b> 3304 * <pre> 3305 * {@code 3306 * |--HTML_ELEMENT -> HTML_ELEMENT 3307 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3308 * | `--EMBED_TAG -> EMBED_TAG 3309 * | |--START -> < 3310 * | |--EMBED_HTML_TAG_NAME -> embed 3311 * | |--WS -> 3312 * | |--ATTRIBUTE -> ATTRIBUTE 3313 * | | |--HTML_TAG_NAME -> src 3314 * | | |--EQUALS -> = 3315 * | | `--ATTR_VALUE -> "URL" 3316 * | |--WS -> 3317 * | |--ATTRIBUTE -> ATTRIBUTE 3318 * | | |--HTML_TAG_NAME -> type 3319 * | | |--EQUALS -> = 3320 * | | `--ATTR_VALUE -> "MIME_type" 3321 * | `--END -> > 3322 * |--NEWLINE -> \r\n 3323 * |--TEXT -> 3324 * } 3325 * </pre> 3326 * 3327 * @see #EMBED_TAG 3328 * @see <a href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-embed"> 3329 * W3 docs</a> 3330 */ 3331 public static final int EMBED_TAG = JavadocParser.RULE_embedTag + RULE_TYPES_OFFSET; 3332 3333 /** 3334 * HTML void element {@code <keygen>}. 3335 * 3336 * @see #SINGLETON_ELEMENT 3337 * @see <a href="https://www.w3.org/TR/html51/sec-forms.html#elementdef-keygen"> 3338 * W3 docs</a> 3339 */ 3340 public static final int KEYGEN_TAG = JavadocParser.RULE_keygenTag + RULE_TYPES_OFFSET; 3341 3342 /** 3343 * HTML void element {@code <source>}. 3344 * 3345 * @see #SINGLETON_ELEMENT 3346 * @see <a href= 3347 * "https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-media-source"> 3348 * W3 docs</a> 3349 */ 3350 public static final int SOURCE_TAG = JavadocParser.RULE_sourceTag + RULE_TYPES_OFFSET; 3351 3352 /** 3353 * HTML void element {@code <track>} tag. 3354 * 3355 * <p><b>Example:</b></p> 3356 * <pre>{@code 3357 * <track kind="subtitles" src="subtitles_en.file" /> 3358 * }</pre> 3359 * <b>Tree:</b> 3360 * <pre> 3361 * {@code 3362 * --HTML_ELEMENT -> HTML_ELEMENT 3363 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3364 * `--TRACK_TAG -> TRACK_TAG 3365 * |--START -> < 3366 * |--TRACK_HTML_TAG_NAME -> track 3367 * |--WS -> 3368 * |--ATTRIBUTE -> ATTRIBUTE 3369 * | |--HTML_TAG_NAME -> kind 3370 * | |--EQUALS -> = 3371 * | `--ATTR_VALUE -> "subtitles" 3372 * |--WS -> 3373 * |--ATTRIBUTE -> ATTRIBUTE 3374 * | |--HTML_TAG_NAME -> src 3375 * | |--EQUALS -> = 3376 * | `--ATTR_VALUE -> "subtitles_en.file" 3377 * |--WS -> 3378 * `--SLASH_END -> /> 3379 * } 3380 * </pre> 3381 * 3382 * @see #TRACK_TAG 3383 * @see <a href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-track"> 3384 * W3C HTML5 specification</a> 3385 */ 3386 public static final int TRACK_TAG = JavadocParser.RULE_trackTag + RULE_TYPES_OFFSET; 3387 3388 /** 3389 * HTML void element {@code <wbr>} tag. 3390 * 3391 * <p><b>Example:</b></p> 3392 * <pre>{@code 3393 * <wbr /> 3394 * }</pre> 3395 * <b>Tree:</b> 3396 * <pre> 3397 * {@code 3398 * HTML_ELEMENT -> HTML_ELEMENT 3399 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 3400 * `--WBR_TAG -> WBR_TAG 3401 * |--START -> < 3402 * |--WBR_HTML_TAG_NAME -> wbr 3403 * `--SLASH_END -> /> 3404 * } 3405 * </pre> 3406 * 3407 * @see #WBR_TAG 3408 * @see <a href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-wbr"> 3409 * W3C HTML5 specification</a> 3410 */ 3411 public static final int WBR_TAG = JavadocParser.RULE_wbrTag + RULE_TYPES_OFFSET; 3412 3413 /////////////////////////////////////////////////////////////////////////////////////////////// 3414 3415 /** 3416 * Html comment: {@code <!-- --> }. 3417 */ 3418 public static final int HTML_COMMENT = JavadocParser.RULE_htmlComment 3419 + RULE_TYPES_OFFSET; 3420 /** 3421 * CHAR and WS sequence. 3422 */ 3423 public static final int TEXT = JavadocParser.RULE_text + RULE_TYPES_OFFSET; 3424 3425 /** Empty private constructor of the current class. */ 3426 private JavadocTokenTypes() { 3427 } 3428 3429}