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