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 /** `rp` tag name. */ 1644 public static final int RP_HTML_TAG_NAME = JavadocParser.RP_HTML_TAG_NAME; 1645 /////////////////////////////////////////////////////////////////////////////////////////////// 1646 1647 /////////////////////// SINGLETON HTML TAGS ////////////////////////////////////////////////// 1648 /** 1649 * Area tag name. 1650 * 1651 * <p><b>Example:</b></p> 1652 * <pre>{@code < area shape="rect" >}</pre> 1653 * <b>Tree:</b> 1654 * <pre> 1655 * {@code 1656 * JAVADOC -> JAVADOC 1657 * |--NEWLINE -> \n 1658 * |--LEADING_ASTERISK -> * 1659 * |--TEXT -> 1660 * |--HTML_ELEMENT -> HTML_ELEMENT 1661 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1662 * | `--AREA_TAG -> AREA_TAG 1663 * | |--START -> < 1664 * | |--AREA_HTML_TAG_NAME -> area 1665 * | |--WS -> 1666 * | |--ATTRIBUTE -> ATTRIBUTE 1667 * | | |--HTML_TAG_NAME -> shape 1668 * | | |--EQUALS -> = 1669 * | | `--ATTR_VALUE -> "rect" 1670 * | `--END -> > 1671 * |--TEXT -> 1672 * |--NEWLINE -> \n 1673 * |--TEXT -> 1674 * } 1675 * </pre> 1676 */ 1677 1678 public static final int AREA_HTML_TAG_NAME = JavadocParser.AREA_HTML_TAG_NAME; 1679 1680 /** Base tag name. */ 1681 public static final int BASE_HTML_TAG_NAME = JavadocParser.BASE_HTML_TAG_NAME; 1682 1683 /** Basefont tag name. */ 1684 public static final int BASEFONT_HTML_TAG_NAME = JavadocParser.BASEFONT_HTML_TAG_NAME; 1685 1686 /** 1687 * Br tag name. 1688 * 1689 * <p><b>Example:</b></p> 1690 * <pre>{@code text before break < br > text after break}</pre> 1691 * <b>Tree:</b> 1692 * <pre> 1693 * {@code 1694 * `--JAVADOC -> JAVADOC 1695 * |--NEWLINE -> \r\n 1696 * |--LEADING_ASTERISK -> * 1697 * |--TEXT -> text before break 1698 * |--HTML_ELEMENT -> HTML_ELEMENT 1699 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1700 * | `--BR_TAG -> BR_TAG 1701 * | |--START -> < 1702 * | |--BR_HTML_TAG_NAME -> br 1703 * | `--END -> > 1704 * |--TEXT -> text after break 1705 * |--NEWLINE -> \r\n 1706 * |--TEXT -> 1707 * } 1708 * </pre> 1709 */ 1710 1711 public static final int BR_HTML_TAG_NAME = JavadocParser.BR_HTML_TAG_NAME; 1712 1713 /** Col tag name. */ 1714 public static final int COL_HTML_TAG_NAME = JavadocParser.COL_HTML_TAG_NAME; 1715 1716 /** Frame tag name. */ 1717 public static final int FRAME_HTML_TAG_NAME = JavadocParser.FRAME_HTML_TAG_NAME; 1718 1719 /** 1720 * Hr tag name. 1721 * 1722 * <p><b>Example:</b></p> 1723 * <pre>{@code text before horizontal rule < hr > text after horizontal rule}</pre> 1724 * <b>Tree:</b> 1725 * <pre> 1726 * {@code 1727 * |--TEXT -> text before horizontal rule 1728 * |--HTML_ELEMENT -> HTML_ELEMENT 1729 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1730 * | `--HR_TAG -> HR_TAG 1731 * | |--START -> < 1732 * | |--HR_HTML_TAG_NAME -> hr 1733 * | `--END -> > 1734 * |--TEXT -> text after horizontal rule 1735 * |--NEWLINE -> \r\n 1736 * } 1737 * </pre> 1738 */ 1739 1740 public static final int HR_HTML_TAG_NAME = JavadocParser.HR_HTML_TAG_NAME; 1741 1742 /** Img tag name. */ 1743 public static final int IMG_HTML_TAG_NAME = JavadocParser.IMG_HTML_TAG_NAME; 1744 1745 /** 1746 * Input tag name. 1747 * 1748 * <p><b>Example:</b></p> 1749 * <pre>{@code <input name="Name" type="text" placeholder="Enter your name"/>}</pre> 1750 * <b>Tree:</b> 1751 * <pre> 1752 * {@code 1753 * HTML_ELEMENT -> HTML_ELEMENT 1754 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1755 * `--INPUT_TAG -> INPUT_TAG 1756 * |--START -> < 1757 * |--INPUT_HTML_TAG_NAME -> input 1758 * |--WS -> 1759 * |--ATTRIBUTE -> ATTRIBUTE 1760 * | |--HTML_TAG_NAME -> name 1761 * | |--EQUALS -> = 1762 * | `--ATTR_VALUE -> "Name" 1763 * |--WS -> 1764 * |--ATTRIBUTE -> ATTRIBUTE 1765 * | |--HTML_TAG_NAME -> type 1766 * | |--EQUALS -> = 1767 * | `--ATTR_VALUE -> "text" 1768 * |--WS -> 1769 * |--ATTRIBUTE -> ATTRIBUTE 1770 * | |--HTML_TAG_NAME -> placeholder 1771 * | |--EQUALS -> = 1772 * | `--ATTR_VALUE -> "Enter your name" 1773 * `--SLASH_END -> /> 1774 * } 1775 * </pre> 1776 * 1777 * @see 1778 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1779 * comments are written in HTML</a> 1780 * @see #INPUT_HTML_TAG_NAME 1781 */ 1782 public static final int INPUT_HTML_TAG_NAME = JavadocParser.INPUT_HTML_TAG_NAME; 1783 1784 /** Isindex tag name. */ 1785 public static final int ISINDEX_HTML_TAG_NAME = JavadocParser.ISINDEX_HTML_TAG_NAME; 1786 1787 /** 1788 * Link tag name. 1789 * 1790 * <p><b>Example:</b></p> 1791 * <pre>{@code <link rel="stylesheet" href="Style.css">}</pre> 1792 * <b>Tree:</b> 1793 * <pre> 1794 * {@code 1795 * HTML_ELEMENT -> HTML_ELEMENT 1796 * `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 1797 * `--LINK_TAG -> LINK_TAG 1798 * |--START -> < 1799 * |--LINK_HTML_TAG_NAME -> link 1800 * |--WS -> 1801 * |--ATTRIBUTE -> ATTRIBUTE 1802 * | |--HTML_TAG_NAME -> rel 1803 * | |--EQUALS -> = 1804 * | `--ATTR_VALUE -> "stylesheet" 1805 * |--WS -> 1806 * |--ATTRIBUTE -> ATTRIBUTE 1807 * | |--HTML_TAG_NAME -> href 1808 * | |--EQUALS -> = 1809 * | `--ATTR_VALUE -> "Style.css" 1810 * `--END -> > 1811 * } 1812 * </pre> 1813 * 1814 * @see 1815 * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#JSSOR647"> 1816 * comments are written in HTML</a> 1817 * @see #LINK_HTML_TAG_NAME 1818 */ 1819 public static final int LINK_HTML_TAG_NAME = JavadocParser.LINK_HTML_TAG_NAME; 1820 1821 /** Meta tag name. */ 1822 public static final int META_HTML_TAG_NAME = JavadocParser.META_HTML_TAG_NAME; 1823 1824 /** Param tag name. */ 1825 public static final int PARAM_HTML_TAG_NAME = JavadocParser.PARAM_HTML_TAG_NAME; 1826 /** "embed" tag name. */ 1827 public static final int EMBED_HTML_TAG_NAME = JavadocParser.EMBED_HTML_TAG_NAME; 1828 /** "keygen" tag name. */ 1829 public static final int KEYGEN_HTML_TAG_NAME = JavadocParser.KEYGEN_HTML_TAG_NAME; 1830 /** "source" tag name. */ 1831 public static final int SOURCE_HTML_TAG_NAME = JavadocParser.SOURCE_HTML_TAG_NAME; 1832 /** "track" tag name. */ 1833 public static final int TRACK_HTML_TAG_NAME = JavadocParser.TRACK_HTML_TAG_NAME; 1834 /** "wbr" tag name. */ 1835 public static final int WBR_HTML_TAG_NAME = JavadocParser.WBR_HTML_TAG_NAME; 1836 /////////////////////////////////////////////////////////////////////////////////////////////// 1837 1838 /** 1839 * HTML comment start symbol '<!--'. 1840 * 1841 * <p><b>Example:</b></p> 1842 * <pre>{@code 1843 * <!-- 1844 * This is an HTML multi-line comment: 1845 * This is another comment 1846 * --> 1847 * }</pre> 1848 * <b>Tree:</b> 1849 * <pre> 1850 * {@code 1851 * HTML_COMMENT -> HTML_COMMENT 1852 * |--HTML_COMMENT_START -> <!-- 1853 * |--NEWLINE -> \n 1854 * |--LEADING_ASTERISK -> * 1855 * |--TEXT -> This is an HTML multi-line comment: 1856 * |--NEWLINE -> \n 1857 * |--LEADING_ASTERISK -> * 1858 * |--TEXT -> This is another comment 1859 * |--NEWLINE -> \n 1860 * |--LEADING_ASTERISK -> * 1861 * |--TEXT -> 1862 * `--HTML_COMMENT_END -> --> 1863 * } 1864 * </pre> 1865 */ 1866 public static final int HTML_COMMENT_START = JavadocParser.HTML_COMMENT_START; 1867 1868 /** 1869 * HTML comment end symbol '-->'. 1870 * 1871 * <p><b>Example:</b></p> 1872 * <pre>{@code 1873 * <!-- 1874 * This is an HTML multi-line comment: 1875 * This is another comment 1876 * --> 1877 * }</pre> 1878 * <b>Tree:</b> 1879 * <pre> 1880 * {@code 1881 * HTML_COMMENT -> HTML_COMMENT 1882 * |--HTML_COMMENT_START -> <!-- 1883 * |--NEWLINE -> \n 1884 * |--LEADING_ASTERISK -> * 1885 * |--TEXT -> This is an HTML multi-line comment: 1886 * |--NEWLINE -> \n 1887 * |--LEADING_ASTERISK -> * 1888 * |--TEXT -> This is another comment 1889 * |--NEWLINE -> \n 1890 * |--LEADING_ASTERISK -> * 1891 * |--TEXT -> 1892 * `--HTML_COMMENT_END -> --> 1893 * } 1894 * </pre> 1895 */ 1896 public static final int HTML_COMMENT_END = JavadocParser.HTML_COMMENT_END; 1897 1898 // ------------------------------------------------------------------------------------------ // 1899 // ----------------- OTHER -------------------------------------------------- // 1900 // ------------------------------------------------------------------------------------------ // 1901 1902 /** Leading asterisk. */ 1903 public static final int LEADING_ASTERISK = JavadocParser.LEADING_ASTERISK; 1904 1905 /** 1906 * Newline symbol - '\n'. 1907 */ 1908 public static final int NEWLINE = JavadocParser.NEWLINE; 1909 1910 /** 1911 * Any other symbol. 1912 */ 1913 public static final int CHAR = JavadocParser.CHAR; 1914 1915 /** 1916 * Whitespace or tab ('\t') symbol. 1917 */ 1918 public static final int WS = JavadocParser.WS; 1919 1920 /** 1921 * End Of File symbol. Copied from 1922 * {@link org.antlr.v4.runtime.Recognizer#EOF} to avoid ANTLR dependency in 1923 * API. 1924 */ 1925 public static final int EOF = -1; 1926 1927 // ------------------------------------------------------------------------------------------ // 1928 // ------ JAVADOC TAGS DEPENDING ON RULE TYPES OFFSET --------------------------------------- // 1929 // ------------------------------------------------------------------------------------------ // 1930 1931 /** 1932 * Rule types offset. 1933 * RULE_TYPES_OFFSET constant is used to split lexer tokens types and parser rules types. 1934 * We need unique numbers for all tokens, 1935 * ANTLR do not need this and that is why these types are mixed by used values. 1936 * All values we can take a look at 1937 * target/generated-sources/antlr/com/puppycrawl/tools/checkstyle/grammar/javadoc/JavadocParser.java 1938 * For example: LEADING_ASTERISK=1 and RULE_htmlElement = 1. 1939 * RULE_TYPES_OFFSET required to shift parser rules, 1940 * to let them not overlap with types that have prefix "RULE_". 1941 */ 1942 private static final int RULE_TYPES_OFFSET = 10000; 1943 1944 /** 1945 * Root node of any Javadoc comment. 1946 * Last child is always {@link #EOF}. 1947 * 1948 * <p><b>Tree for example:</b></p> 1949 * <pre>{@code 1950 * JAVADOC -> JAVADOC 1951 * |--NEWLINE -> \n 1952 * |--LEADING_ASTERISK -> * 1953 * |--WS -> 1954 * |--JAVADOC_TAG -> JAVADOC_TAG 1955 * | |--PARAM_LITERAL -> @param 1956 * | |--WS -> 1957 * | |--PARAMETER_NAME -> T 1958 * | |--WS -> 1959 * | `--DESCRIPTION -> DESCRIPTION 1960 * | |--TEXT -> The bar. 1961 * | |--NEWLINE -> \n 1962 * | `--TEXT -> 1963 * `--EOF -> <EOF> 1964 * }</pre> 1965 */ 1966 public static final int JAVADOC = JavadocParser.RULE_javadoc + RULE_TYPES_OFFSET; 1967 1968 /** 1969 * Javadoc tag. 1970 * 1971 * <p>Type of Javadoc tag is resolved by literal node that is first child of this node.</p> 1972 * 1973 * <p>As literal could be:</p> 1974 * <ul> 1975 * <li>{@link #RETURN_LITERAL}</li> 1976 * <li>{@link #DEPRECATED_LITERAL}</li> 1977 * <li>{@link #SINCE_LITERAL}</li> 1978 * <li>{@link #SERIAL_DATA_LITERAL}</li> 1979 * <li>{@link #SERIAL_FIELD_LITERAL}</li> 1980 * <li>{@link #PARAM_LITERAL}</li> 1981 * <li>{@link #SEE_LITERAL}</li> 1982 * <li>{@link #SERIAL_LITERAL}</li> 1983 * <li>{@link #VERSION_LITERAL}</li> 1984 * <li>{@link #EXCEPTION_LITERAL}</li> 1985 * <li>{@link #THROWS_LITERAL}</li> 1986 * <li>{@link #AUTHOR_LITERAL}</li> 1987 * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc tag.</li> 1988 * </ul> 1989 * 1990 * <p><b>Example</b></p> 1991 * <pre>{@code @param T The bar.}</pre> 1992 * <b>Tree</b> 1993 * <pre>{@code 1994 * JAVADOC_TAG -> JAVADOC_TAG 1995 * |--PARAM_LITERAL -> @param 1996 * |--WS -> 1997 * |--PARAMETER_NAME -> T 1998 * |--WS -> 1999 * `--DESCRIPTION -> DESCRIPTION 2000 * |--TEXT -> The bar. 2001 * |--NEWLINE -> \r\n 2002 * `--TEXT -> 2003 * }</pre> 2004 */ 2005 2006 public static final int JAVADOC_TAG = JavadocParser.RULE_javadocTag + RULE_TYPES_OFFSET; 2007 /** 2008 * Javadoc inline tag. 2009 * 2010 * <p>Type of Javadoc inline tag is resolved by literal node that is second child of this node. 2011 * First child is always {@link #JAVADOC_INLINE_TAG_START} and last node is always 2012 * {@link #JAVADOC_INLINE_TAG_END}.</p> 2013 * 2014 * <p>As literal could be:</p> 2015 * <ul> 2016 * <li>{@link #CODE_LITERAL}</li> 2017 * <li>{@link #DOC_ROOT_LITERAL}</li> 2018 * <li>{@link #LINK_LITERAL}</li> 2019 * <li>{@link #INHERIT_DOC_LITERAL}</li> 2020 * <li>{@link #LINKPLAIN_LITERAL}</li> 2021 * <li>{@link #LITERAL_LITERAL}</li> 2022 * <li>{@link #VALUE_LITERAL}</li> 2023 * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc inline tag.</li> 2024 * </ul> 2025 * 2026 * <p><b>Example:</b></p> 2027 * <pre><code>{@link String}</code></pre> 2028 * <b>Tree:</b> 2029 * <pre> 2030 * {@code 2031 * JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG 2032 * |--JAVADOC_INLINE_TAG_START -> { 2033 * |--LINK_LITERAL -> @link 2034 * |--WS -> 2035 * |--REFERENCE -> REFERENCE 2036 * `--PACKAGE_CLASS -> String 2037 * `--JAVADOC_INLINE_TAG_END -> } 2038 * } 2039 * </pre> 2040 * 2041 * @noinspection HtmlTagCanBeJavadocTag 2042 * @noinspection HtmlTagCanBeJavadocTag 2043 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 2044 * replaced with Javadoc tag 2045 */ 2046 public static final int JAVADOC_INLINE_TAG = JavadocParser.RULE_javadocInlineTag 2047 + RULE_TYPES_OFFSET; 2048 2049 /** 2050 * Parameter of the Javadoc tags listed below. 2051 * <ul> 2052 * <li>{@link #SEE_LITERAL @see}</li> 2053 * <li>{@link #LINK_LITERAL {@link}}</li> 2054 * <li>{@link #LINKPLAIN_LITERAL {@linkplain}}</li> 2055 * <li>{@link #VALUE_LITERAL {@value}}</li> 2056 * </ul> 2057 */ 2058 public static final int REFERENCE = JavadocParser.RULE_reference + RULE_TYPES_OFFSET; 2059 2060 /** 2061 * Parameters part in {@link #REFERENCE}. 2062 * It is used to specify parameters for {@link #MEMBER method}. 2063 * Always contains {@link #LEFT_BRACE} as first child and {@link #RIGHT_BRACE} as last child. 2064 * Each parameter is represented by {@link #ARGUMENT} node. 2065 * Arguments in braces are separated by {@link #COMMA} (and optional {@link #WS}). 2066 * 2067 * <p><b>Example:</b></p> 2068 * <pre>{@code @see #method(Processor, String)}</pre> 2069 * <b>Tree:</b> 2070 * <pre> 2071 * {@code 2072 * JAVADOC_TAG -> JAVADOC_TAG 2073 * |--SEE_LITERAL -> @see 2074 * |--WS -> 2075 * |--REFERENCE -> REFERENCE 2076 * |--HASH -> # 2077 * |--MEMBER -> method 2078 * `--PARAMETERS -> PARAMETERS 2079 * |--LEFT_BRACE -> ( 2080 * |--ARGUMENT -> Processor 2081 * |--COMMA -> , 2082 * |--WS -> 2083 * |--ARGUMENT -> String 2084 * `--RIGHT_BRACE -> ) 2085 * } 2086 * </pre> 2087 */ 2088 public static final int PARAMETERS = JavadocParser.RULE_parameters + RULE_TYPES_OFFSET; 2089 2090 /** 2091 * Description node. It contains: 2092 * <ul> 2093 * <li>{@link #TEXT}</li> 2094 * <li>{@link #WS}</li> 2095 * <li>{@link #NEWLINE}</li> 2096 * <li>{@link #HTML_ELEMENT}</li> 2097 * </ul> 2098 * 2099 * <p>It is argument for many Javadoc tags and inline tags.</p> 2100 * 2101 * <p><b>Example:</b></p> 2102 * <pre>{@code @throws IOException if <b>connection</b> problems occur}</pre> 2103 * <b>Tree:</b> 2104 * <pre> 2105 * {@code 2106 * --JAVADOC_TAG -> JAVADOC_TAG 2107 * |--THROWS_LITERAL -> @throws 2108 * |--WS -> 2109 * |--CLASS_NAME -> IOException 2110 * |--WS -> 2111 * `--DESCRIPTION -> DESCRIPTION 2112 * |--TEXT -> if 2113 * |--HTML_ELEMENT -> HTML_ELEMENT 2114 * | `--HTML_TAG -> HTML_TAG 2115 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 2116 * | | |--START -> < 2117 * | | |--HTML_TAG_NAME -> b 2118 * | | `--END -> > 2119 * | |--TEXT -> connection 2120 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 2121 * | |--START -> < 2122 * | |--SLASH -> / 2123 * | |--HTML_TAG_NAME -> b 2124 * | `--END -> > 2125 * |--TEXT -> problems occur 2126 * } 2127 * </pre> 2128 */ 2129 public static final int DESCRIPTION = JavadocParser.RULE_description + RULE_TYPES_OFFSET; 2130 2131 // ------------------------------------------------------------------------------------------ // 2132 // -------- HTML TAGS DEPENDING ON RULE TYPES OFFSET ---------------------------------------- // 2133 // ------------------------------------------------------------------------------------------ // 2134 2135 /** 2136 * Parent node for all html tags. 2137 */ 2138 public static final int HTML_ELEMENT = JavadocParser.RULE_htmlElement 2139 + RULE_TYPES_OFFSET; 2140 2141 /** 2142 * Start html tag: <XXXX>. 2143 */ 2144 public static final int HTML_ELEMENT_START = JavadocParser.RULE_htmlElementStart 2145 + RULE_TYPES_OFFSET; 2146 2147 /** 2148 * End html tag: <XXXX>. 2149 */ 2150 public static final int HTML_ELEMENT_END = JavadocParser.RULE_htmlElementEnd 2151 + RULE_TYPES_OFFSET; 2152 2153 /** 2154 * Non-special HTML tag. 2155 */ 2156 public static final int HTML_TAG = JavadocParser.RULE_htmlTag + RULE_TYPES_OFFSET; 2157 2158 /** 2159 * Html tag attribute. Parent node for: {@code HTML_TAG_IDENT, EQUALS, ATTR_VALUE}. 2160 * 2161 * <p><b>Example</b></p> 2162 * <pre>{@code <p class="highlight">Sample text</p>}</pre> 2163 * <b>Tree</b> 2164 * <pre> 2165 * {@code 2166 * HTML_ELEMENT -> HTML_ELEMENT 2167 * `--PARAGRAPH -> PARAGRAPH 2168 * |--P_TAG_START -> P_TAG_START 2169 * | |--START -> < 2170 * | |--P_HTML_TAG_NAME -> p 2171 * | |--WS -> 2172 * | |--ATTRIBUTE -> ATTRIBUTE 2173 * | | |--HTML_TAG_NAME -> class 2174 * | | |--EQUALS -> = 2175 * | | `--ATTR_VALUE -> "highlight" 2176 * | `--END -> > 2177 * |--TEXT -> Sample text 2178 * `--P_TAG_END -> P_TAG_END 2179 * |--START -> < 2180 * |--SLASH -> / 2181 * |--P_HTML_TAG_NAME -> p 2182 * `--END -> > 2183 * } 2184 * </pre> 2185 */ 2186 public static final int ATTRIBUTE = JavadocParser.RULE_attribute 2187 + RULE_TYPES_OFFSET; 2188 2189 /////////////////////// HTML TAGS WITH OPTIONAL END TAG ///////////////////////////////////// 2190 /** 2191 * Paragraph html tag. 2192 * 2193 * <p><b>Example:</b></p> 2194 * <pre>{@code <p>Sample text</p>}</pre> 2195 * <b>Tree:</b> 2196 * <pre> 2197 * {@code 2198 * `--JAVADOC -> JAVADOC 2199 * |--NEWLINE -> \r\n 2200 * |--LEADING_ASTERISK -> * 2201 * |--TEXT -> 2202 * |--HTML_ELEMENT -> HTML_ELEMENT 2203 * | `--PARAGRAPH -> PARAGRAPH 2204 * | |--P_TAG_START -> P_TAG_START 2205 * | | |--START -> < 2206 * | | |--P_HTML_TAG_NAME -> p 2207 * | | `--END -> > 2208 * | |--TEXT -> Sample text 2209 * | `--P_TAG_END -> P_TAG_END 2210 * | |--START -> < 2211 * | |--SLASH -> / 2212 * | |--P_HTML_TAG_NAME -> p 2213 * | `--END -> > 2214 * |--NEWLINE -> \r\n 2215 * |--TEXT -> 2216 * } 2217 * </pre> 2218 */ 2219 public static final int PARAGRAPH = JavadocParser.RULE_paragraph + RULE_TYPES_OFFSET; 2220 /** Start paragraph tag. */ 2221 public static final int P_TAG_START = JavadocParser.RULE_pTagStart + RULE_TYPES_OFFSET; 2222 /** End paragraph tag. */ 2223 public static final int P_TAG_END = JavadocParser.RULE_pTagEnd + RULE_TYPES_OFFSET; 2224 2225 /** 2226 * List items html tag. 2227 * 2228 * <p><b>Example:</b></p> 2229 * <pre>{@code 2230 * <ul> 2231 * <li>Item 1</li> 2232 * </ul> 2233 * }</pre> 2234 * <b>Tree:</b> 2235 * <pre> 2236 * {@code 2237 * --JAVADOC -> JAVADOC 2238 * |--NEWLINE -> \n 2239 * |--LEADING_ASTERISK -> * 2240 * |--TEXT -> 2241 * |--HTML_ELEMENT -> HTML_ELEMENT 2242 * | `--HTML_TAG -> HTML_TAG 2243 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 2244 * | | |--START -> < 2245 * | | |--HTML_TAG_NAME -> ul 2246 * | | `--END -> > 2247 * | |--NEWLINE -> \n 2248 * | |--LEADING_ASTERISK -> * 2249 * | |--TEXT -> 2250 * | |--HTML_ELEMENT -> HTML_ELEMENT 2251 * | | `--LI -> LI 2252 * | | |--LI_TAG_START -> LI_TAG_START 2253 * | | | |--START -> < 2254 * | | | |--LI_HTML_TAG_NAME -> li 2255 * | | | `--END -> > 2256 * | | |--TEXT -> Item 1 2257 * | | `--LI_TAG_END -> LI_TAG_END 2258 * | | |--START -> < 2259 * | | |--SLASH -> / 2260 * | | |--LI_HTML_TAG_NAME -> li 2261 * | | `--END -> > 2262 * | |--NEWLINE -> \n 2263 * | |--LEADING_ASTERISK -> * 2264 * | |--TEXT -> 2265 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 2266 * | |--START -> < 2267 * | |--SLASH -> / 2268 * | |--HTML_TAG_NAME -> ul 2269 * | `--END -> > 2270 * |--NEWLINE -> \n 2271 * |--TEXT -> 2272 * } 2273 * </pre> 2274 */ 2275 public static final int LI = JavadocParser.RULE_li + RULE_TYPES_OFFSET; 2276 /** Start list item tag. */ 2277 public static final int LI_TAG_START = JavadocParser.RULE_liTagStart + RULE_TYPES_OFFSET; 2278 /** End list item tag. */ 2279 public static final int LI_TAG_END = JavadocParser.RULE_liTagEnd + RULE_TYPES_OFFSET; 2280 2281 /** 2282 * Table row html tag. 2283 * 2284 * <p><b>Example:</b></p> 2285 * <pre>{@code <tr></tr>}</pre> 2286 * <b>Tree:</b> 2287 * <pre> 2288 * {@code 2289 * JAVADOC -> JAVADOC 2290 * |--NEWLINE -> \r\n 2291 * |--LEADING_ASTERISK -> * 2292 * |--TEXT -> 2293 * |--HTML_ELEMENT -> HTML_ELEMENT 2294 * | `--TR -> TR 2295 * | |--TR_TAG_START -> TR_TAG_START 2296 * | | |--START -> < 2297 * | | |--TR_HTML_TAG_NAME -> tr 2298 * | | `--END -> > 2299 * | `--TR_TAG_END -> TR_TAG_END 2300 * | |--START -> < 2301 * | |--SLASH -> / 2302 * | |--TR_HTML_TAG_NAME -> tr 2303 * | `--END -> > 2304 * |--NEWLINE -> \r\n 2305 * |--TEXT -> 2306 * } 2307 * </pre> 2308 */ 2309 public static final int TR = JavadocParser.RULE_tr + RULE_TYPES_OFFSET; 2310 /** Start table row tag. */ 2311 public static final int TR_TAG_START = JavadocParser.RULE_trTagStart + RULE_TYPES_OFFSET; 2312 /** End table row tag. */ 2313 public static final int TR_TAG_END = JavadocParser.RULE_trTagEnd + RULE_TYPES_OFFSET; 2314 2315 /** 2316 * Table cell HTML tag. 2317 * 2318 * <p><b>Example:</b></p> 2319 * <pre>{@code <td>Cell Content</td>}</pre> 2320 * <b>Tree:</b> 2321 * <pre> 2322 * {@code 2323 * HTML_ELEMENT -> HTML_ELEMENT 2324 * `--TD -> TD 2325 * |--TD_TAG_START -> TD_TAG_START 2326 * | |--START -> < 2327 * | |--TD_HTML_TAG_NAME -> td 2328 * | `--END -> > 2329 * |--TEXT -> Cell Content 2330 * `--TD_TAG_END -> TD_TAG_END 2331 * |--START -> < 2332 * |--SLASH -> / 2333 * |--TD_HTML_TAG_NAME -> td 2334 * `--END -> > 2335 * } 2336 * </pre> 2337 */ 2338 public static final int TD = JavadocParser.RULE_td + RULE_TYPES_OFFSET; 2339 /** Start table cell tag. */ 2340 public static final int TD_TAG_START = JavadocParser.RULE_tdTagStart + RULE_TYPES_OFFSET; 2341 /** End table cell tag. */ 2342 public static final int TD_TAG_END = JavadocParser.RULE_tdTagEnd + RULE_TYPES_OFFSET; 2343 2344 /** Table header cell html tag: {@code <th></th>}. */ 2345 public static final int TH = JavadocParser.RULE_th + RULE_TYPES_OFFSET; 2346 /** Start table header cell tag. */ 2347 public static final int TH_TAG_START = JavadocParser.RULE_thTagStart + RULE_TYPES_OFFSET; 2348 /** End table header cell tag. */ 2349 public static final int TH_TAG_END = JavadocParser.RULE_thTagEnd + RULE_TYPES_OFFSET; 2350 2351 /** Body html tag. */ 2352 public static final int BODY = JavadocParser.RULE_body + RULE_TYPES_OFFSET; 2353 2354 /** 2355 * Start body tag. 2356 * 2357 * <p><b>Example:</b></p> 2358 * <pre>{@code 2359 * <body> 2360 * This is a test 2361 * </body> 2362 * }</pre> 2363 * <b>Tree:</b> 2364 * <pre> 2365 * {@code 2366 * JAVADOC -> JAVADOC 2367 * |--TEXT -> /** 2368 * |--NEWLINE -> \n 2369 * |--LEADING_ASTERISK -> * 2370 * |--TEXT -> 2371 * |--HTML_ELEMENT -> HTML_ELEMENT 2372 * | `--BODY -> BODY 2373 * | |--BODY_TAG_START -> BODY_TAG_START 2374 * | | |--START -> < 2375 * | | |--BODY_HTML_TAG_NAME -> body 2376 * | | `--END -> > 2377 * | |--NEWLINE -> \n 2378 * | |--LEADING_ASTERISK -> * 2379 * | |--TEXT -> This is inside the body tag. 2380 * | |--NEWLINE -> \n 2381 * | |--LEADING_ASTERISK -> * 2382 * | |--TEXT -> 2383 * | `--BODY_TAG_END -> BODY_TAG_END 2384 * | |--START -> < 2385 * | |--SLASH -> / 2386 * | |--BODY_HTML_TAG_NAME -> body 2387 * | `--END -> > 2388 * |--NEWLINE -> \n 2389 * |--LEADING_ASTERISK -> * 2390 * |--TEXT -> / 2391 * |--NEWLINE -> \n 2392 * |--TEXT -> public class Test { 2393 * |--NEWLINE -> \n 2394 * |--TEXT -> } 2395 * |--NEWLINE -> \n 2396 * } 2397 * </pre> 2398 */ 2399 public static final int BODY_TAG_START = JavadocParser.RULE_bodyTagStart + RULE_TYPES_OFFSET; 2400 2401 /** 2402 * End body tag. 2403 * 2404 * <p><b>Example:</b></p> 2405 * <pre>{@code 2406 * <body> 2407 * This is a test 2408 * </body> 2409 * }</pre> 2410 * <b>Tree:</b> 2411 * <pre> 2412 * {@code 2413 * JAVADOC -> JAVADOC 2414 * |--TEXT -> /** 2415 * |--NEWLINE -> \n 2416 * |--LEADING_ASTERISK -> * 2417 * |--TEXT -> 2418 * |--HTML_ELEMENT -> HTML_ELEMENT 2419 * | `--BODY -> BODY 2420 * | |--BODY_TAG_START -> BODY_TAG_START 2421 * | | |--START -> < 2422 * | | |--BODY_HTML_TAG_NAME -> body 2423 * | | `--END -> > 2424 * | |--NEWLINE -> \n 2425 * | |--LEADING_ASTERISK -> * 2426 * | |--TEXT -> This is inside the body tag. 2427 * | |--NEWLINE -> \n 2428 * | |--LEADING_ASTERISK -> * 2429 * | |--TEXT -> 2430 * | `--BODY_TAG_END -> BODY_TAG_END 2431 * | |--START -> < 2432 * | |--SLASH -> / 2433 * | |--BODY_HTML_TAG_NAME -> body 2434 * | `--END -> > 2435 * |--NEWLINE -> \n 2436 * |--LEADING_ASTERISK -> * 2437 * |--TEXT -> / 2438 * |--NEWLINE -> \n 2439 * |--TEXT -> public class Test { 2440 * |--NEWLINE -> \n 2441 * |--TEXT -> } 2442 * |--NEWLINE -> \n 2443 * } 2444 * </pre> 2445 */ 2446 public static final int BODY_TAG_END = JavadocParser.RULE_bodyTagEnd + RULE_TYPES_OFFSET; 2447 2448 /** 2449 * Colgroup html tag. 2450 * 2451 * <p><b>Example:</b></p> 2452 * <pre>{@code 2453 * <colgroup> 2454 * <col /> 2455 * <col span="2" class="batman" /> 2456 * </colgroup> 2457 * }</pre> 2458 * <b>Tree:</b> 2459 * <pre> 2460 * {@code 2461 * --JAVADOC -> JAVADOC 2462 * |--NEWLINE -> \n 2463 * |--LEADING_ASTERISK -> * 2464 * |--TEXT -> 2465 * |--HTML_ELEMENT -> HTML_ELEMENT 2466 * | `--COLGROUP -> COLGROUP 2467 * | |--COLGROUP_TAG_START -> COLGROUP_TAG_START 2468 * | | |--START -> < 2469 * | | |--COLGROUP_HTML_TAG_NAME -> colgroup 2470 * | | | `--END -> > 2471 * | |--NEWLINE -> \n 2472 * | |--LEADING_ASTERISK -> * 2473 * | |--TEXT -> 2474 * | |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2475 * | | `--COL_TAG -> COL_TAG 2476 * | | |--START -> < 2477 * | | |--COL_HTML_TAG_NAME -> col 2478 * | | |--WS -> 2479 * | | `--SLASH_END -> /> 2480 * | |--NEWLINE -> \n 2481 * | |--LEADING_ASTERISK -> * 2482 * | |--TEXT -> 2483 * | |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2484 * | | `--COL_TAG -> COL_TAG 2485 * | | |--START -> < 2486 * | | |--COL_HTML_TAG_NAME -> col 2487 * | | |--WS -> 2488 * | | |--ATTRIBUTE -> ATTRIBUTE 2489 * | | | |--HTML_TAG_NAME -> span 2490 * | | | |--EQUALS -> = 2491 * | | | `--ATTR_VALUE -> "2" 2492 * | | |--WS -> 2493 * | | |--ATTRIBUTE -> ATTRIBUTE 2494 * | | | |--HTML_TAG_NAME -> class 2495 * | | | |--EQUALS -> = 2496 * | | | `--ATTR_VALUE -> "batman" 2497 * | | |--WS -> 2498 * | | `--SLASH_END -> /> 2499 * | |--NEWLINE -> \n 2500 * | |--LEADING_ASTERISK -> * 2501 * | |--TEXT -> 2502 * | `--COLGROUP_TAG_END -> COLGROUP_TAG_END 2503 * | | |--START -> < 2504 * | | |--SLASH -> / 2505 * | | |--COLGROUP_HTML_TAG_NAME -> colgroup 2506 * | | `--END -> > 2507 * |--NEWLINE -> \n 2508 * |--TEXT -> 2509 * } 2510 * </pre> 2511 */ 2512 public static final int COLGROUP = JavadocParser.RULE_colgroup + RULE_TYPES_OFFSET; 2513 /** Start colgroup tag. */ 2514 public static final int COLGROUP_TAG_START = JavadocParser.RULE_colgroupTagStart 2515 + RULE_TYPES_OFFSET; 2516 /** End colgroup tag. */ 2517 public static final int COLGROUP_TAG_END = JavadocParser.RULE_colgroupTagEnd 2518 + RULE_TYPES_OFFSET; 2519 2520 /** 2521 * DD html tag. 2522 * 2523 * <p><b>Example AST:</b></p> 2524 * <pre>{@code <dd>Description content</dd>}</pre> 2525 * <pre> 2526 * {@code 2527 * --HTML_ELEMENT -> HTML_ELEMENT 2528 * `--DD -> DD 2529 * |--DD_TAG_START -> DD_TAG_START 2530 * | |--START -> < 2531 * | |--DD_HTML_TAG_NAME -> dd 2532 * | `--END -> > 2533 * |--TEXT -> "Description content" 2534 * `--DD_TAG_END -> DD_TAG_END 2535 * |--START -> < 2536 * |--SLASH -> / 2537 * |--DD_HTML_TAG_NAME -> dd 2538 * `--END -> > 2539 * } 2540 * </pre> 2541 */ 2542 public static final int DD = JavadocParser.RULE_dd + RULE_TYPES_OFFSET; 2543 /** Start description of a term tag. */ 2544 public static final int DD_TAG_START = JavadocParser.RULE_ddTagStart + RULE_TYPES_OFFSET; 2545 /** End description of a term tag. */ 2546 public static final int DD_TAG_END = JavadocParser.RULE_ddTagEnd + RULE_TYPES_OFFSET; 2547 2548 /** 2549 * DT html tag. 2550 * 2551 * <p><b>Example AST:</b></p> 2552 * <pre>{@code <dd>Description Term</dd>}</pre> 2553 * <pre> 2554 * {@code 2555 * --HTML_ELEMENT -> HTML_ELEMENT 2556 * `--DT -> DT 2557 * |--DT_TAG_START -> DT_TAG_START 2558 * | |--START -> < 2559 * | |--DT_HTML_TAG_NAME -> dt 2560 * | `--END -> > 2561 * |--TEXT -> "Description term" 2562 * `--DT_TAG_END -> DT_TAG_END 2563 * |--START -> < 2564 * |--SLASH -> / 2565 * |--DT_HTML_TAG_NAME -> dt 2566 * `--END -> > 2567 * } 2568 * </pre> 2569 */ 2570 public static final int DT = JavadocParser.RULE_dt + RULE_TYPES_OFFSET; 2571 /** Start description term tag. */ 2572 public static final int DT_TAG_START = JavadocParser.RULE_dtTagStart + RULE_TYPES_OFFSET; 2573 /** End description term tag. */ 2574 public static final int DT_TAG_END = JavadocParser.RULE_dtTagEnd + RULE_TYPES_OFFSET; 2575 2576 /** Head html tag. */ 2577 public static final int HEAD = JavadocParser.RULE_head + RULE_TYPES_OFFSET; 2578 /** Start head tag. */ 2579 public static final int HEAD_TAG_START = JavadocParser.RULE_headTagStart + RULE_TYPES_OFFSET; 2580 /** End head tag. */ 2581 public static final int HEAD_TAG_END = JavadocParser.RULE_headTagEnd + RULE_TYPES_OFFSET; 2582 2583 /** Html html tag. */ 2584 public static final int HTML = JavadocParser.RULE_html + RULE_TYPES_OFFSET; 2585 /** Start html tag. */ 2586 public static final int HTML_TAG_START = JavadocParser.RULE_htmlTagStart + RULE_TYPES_OFFSET; 2587 /** End html tag. */ 2588 public static final int HTML_TAG_END = JavadocParser.RULE_htmlTagEnd + RULE_TYPES_OFFSET; 2589 2590 /** Option html tag. */ 2591 public static final int OPTION = JavadocParser.RULE_option + RULE_TYPES_OFFSET; 2592 /** Start option tag. */ 2593 public static final int OPTION_TAG_START = 2594 JavadocParser.RULE_optionTagStart + RULE_TYPES_OFFSET; 2595 /** End option tag. */ 2596 public static final int OPTION_TAG_END = JavadocParser.RULE_optionTagEnd 2597 + RULE_TYPES_OFFSET; 2598 2599 /** 2600 * Table body html tag. 2601 * 2602 * <p><b>Example:</b></p> 2603 * <pre>{@code <table><tbody></tbody></table>}</pre> 2604 * <b>Tree:</b> 2605 * <pre> 2606 * {@code 2607 * JAVADOC -> JAVADOC 2608 * |--NEWLINE -> \r\n 2609 * |--LEADING_ASTERISK -> * 2610 * |--TEXT -> 2611 * |--HTML_ELEMENT -> HTML_ELEMENT 2612 * | `--HTML_TAG -> HTML_TAG 2613 * | |--HTML_ELEMENT_START -> HTML_ELEMENT_START 2614 * | | |--START -> < 2615 * | | |--HTML_TAG_NAME -> table 2616 * | | `--END -> > 2617 * | |--HTML_ELEMENT -> HTML_ELEMENT 2618 * | | `--TBODY -> TBODY 2619 * | | |--TBODY_TAG_START -> TBODY_TAG_START 2620 * | | | |--START -> < 2621 * | | | |--TBODY_HTML_TAG_NAME -> tbody 2622 * | | | `--END -> > 2623 * | | `--TBODY_TAG_END -> TBODY_TAG_END 2624 * | | |--START -> < 2625 * | | |--SLASH -> / 2626 * | | |--TBODY_HTML_TAG_NAME -> tbody 2627 * | | `--END -> > 2628 * | `--HTML_ELEMENT_END -> HTML_ELEMENT_END 2629 * | |--START -> < 2630 * | |--SLASH -> / 2631 * | |--HTML_TAG_NAME -> table 2632 * | `--END -> > 2633 * |--NEWLINE -> \r\n 2634 * } 2635 * </pre> 2636 */ 2637 public static final int TBODY = JavadocParser.RULE_tbody + RULE_TYPES_OFFSET; 2638 /** Start table body tag. */ 2639 public static final int TBODY_TAG_START = JavadocParser.RULE_tbodyTagStart + RULE_TYPES_OFFSET; 2640 /** End table body tag. */ 2641 public static final int TBODY_TAG_END = JavadocParser.RULE_tbodyTagEnd + RULE_TYPES_OFFSET; 2642 2643 /** Table foot html tag. */ 2644 public static final int TFOOT = JavadocParser.RULE_tfoot + RULE_TYPES_OFFSET; 2645 /** Start table foot tag. */ 2646 public static final int TFOOT_TAG_START = JavadocParser.RULE_tfootTagStart + RULE_TYPES_OFFSET; 2647 /** End table foot tag. */ 2648 public static final int TFOOT_TAG_END = JavadocParser.RULE_tfootTagEnd + RULE_TYPES_OFFSET; 2649 2650 /** Table head html tag. */ 2651 public static final int THEAD = JavadocParser.RULE_thead + RULE_TYPES_OFFSET; 2652 /** Start table head tag. */ 2653 public static final int THEAD_TAG_START = JavadocParser.RULE_theadTagStart + RULE_TYPES_OFFSET; 2654 /** End table head tag. */ 2655 public static final int THEAD_TAG_END = JavadocParser.RULE_theadTagEnd + RULE_TYPES_OFFSET; 2656 2657 /** `optgroup` html tag. */ 2658 public static final int OPTGROUP = JavadocParser.RULE_optgroup + RULE_TYPES_OFFSET; 2659 /** `optgroup` tag start. */ 2660 public static final int OPTGROUP_TAG_START = 2661 JavadocParser.RULE_optgroupTagStart + RULE_TYPES_OFFSET; 2662 /** `optgroup` tag end. */ 2663 public static final int OPTGROUP_TAG_END = 2664 JavadocParser.RULE_optgroupTagEnd + RULE_TYPES_OFFSET; 2665 2666 /** `rb` html tag. */ 2667 public static final int RB = JavadocParser.RULE_rb + RULE_TYPES_OFFSET; 2668 /** `rb` tag start. */ 2669 public static final int RB_TAG_START = 2670 JavadocParser.RULE_rbTagStart + RULE_TYPES_OFFSET; 2671 /** `rb` tag end. */ 2672 public static final int RB_TAG_END = 2673 JavadocParser.RULE_rbTagEnd + RULE_TYPES_OFFSET; 2674 2675 /** `rt` html tag. */ 2676 public static final int RT = JavadocParser.RULE_rt + RULE_TYPES_OFFSET; 2677 /** `rt` tag start. */ 2678 public static final int RT_TAG_START = 2679 JavadocParser.RULE_rtTagStart + RULE_TYPES_OFFSET; 2680 /** `rt` tag end. */ 2681 public static final int RT_TAG_END = 2682 JavadocParser.RULE_rtTagEnd + RULE_TYPES_OFFSET; 2683 2684 /** `rtc` html tag. */ 2685 public static final int RTC = JavadocParser.RULE_rtc + RULE_TYPES_OFFSET; 2686 /** `rtc` tag start. */ 2687 public static final int RTC_TAG_START = 2688 JavadocParser.RULE_rtcTagStart + RULE_TYPES_OFFSET; 2689 /** `rtc` tag end. */ 2690 public static final int RTC_TAG_END = 2691 JavadocParser.RULE_rtcTagEnd + RULE_TYPES_OFFSET; 2692 2693 /** `rp` html tag. */ 2694 public static final int RP = JavadocParser.RULE_rp + RULE_TYPES_OFFSET; 2695 /** `rp` tag start. */ 2696 public static final int RP_TAG_START = 2697 JavadocParser.RULE_rpTagStart + RULE_TYPES_OFFSET; 2698 /** `rp` tag end. */ 2699 public static final int RP_TAG_END = 2700 JavadocParser.RULE_rpTagEnd + RULE_TYPES_OFFSET; 2701 2702 /////////////////////// SINGLETON HTML TAGS ////////////////////////////////////////////////// 2703 /** 2704 * Parent node for all singleton html tags. 2705 */ 2706 public static final int SINGLETON_ELEMENT = JavadocParser.RULE_singletonElement 2707 + RULE_TYPES_OFFSET; 2708 2709 /** 2710 * Non-special empty html tag. 2711 */ 2712 public static final int EMPTY_TAG = JavadocParser.RULE_emptyTag 2713 + RULE_TYPES_OFFSET; 2714 2715 /** 2716 * Area html tag. 2717 * 2718 * <p><b>Example:</b></p> 2719 * <pre>{@code < area shape="rect" >}</pre> 2720 * <b>Tree:</b> 2721 * <pre> 2722 * {@code 2723 * JAVADOC -> JAVADOC 2724 * |--NEWLINE -> \n 2725 * |--LEADING_ASTERISK -> * 2726 * |--TEXT -> 2727 * |--HTML_ELEMENT -> HTML_ELEMENT 2728 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2729 * | `--AREA_TAG -> AREA_TAG 2730 * | |--START -> < 2731 * | |--AREA_HTML_TAG_NAME -> area 2732 * | |--WS -> 2733 * | |--ATTRIBUTE -> ATTRIBUTE 2734 * | | |--HTML_TAG_NAME -> shape 2735 * | | |--EQUALS -> = 2736 * | | `--ATTR_VALUE -> "rect" 2737 * | `--END -> > 2738 * |--TEXT -> 2739 * |--NEWLINE -> \n 2740 * |--TEXT -> 2741 * } 2742 * </pre> 2743 */ 2744 public static final int AREA_TAG = JavadocParser.RULE_areaTag + RULE_TYPES_OFFSET; 2745 2746 /** Base html tag. */ 2747 public static final int BASE_TAG = JavadocParser.RULE_baseTag + RULE_TYPES_OFFSET; 2748 2749 /** Basefont html tag. */ 2750 public static final int BASEFONT_TAG = JavadocParser.RULE_basefontTag + RULE_TYPES_OFFSET; 2751 2752 /** 2753 * Br html tag. 2754 * 2755 * <p><b>Example:</b></p> 2756 * <pre>{@code <br> line breaks<br/>}</pre> 2757 * <b>Tree:</b> 2758 * <pre> 2759 * {@code 2760 * JAVADOC -> JAVADOC 2761 * |--NEWLINE -> \r\n 2762 * |--LEADING_ASTERISK -> * 2763 * |--TEXT -> 2764 * |--HTML_ELEMENT -> HTML_ELEMENT 2765 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2766 * | `--BR_TAG -> BR_TAG 2767 * | |--START -> < 2768 * | |--BR_HTML_TAG_NAME -> br 2769 * | `--END -> > 2770 * |--TEXT -> line breaks 2771 * |--HTML_ELEMENT -> HTML_ELEMENT 2772 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2773 * | `--BR_TAG -> BR_TAG 2774 * | |--START -> < 2775 * | |--BR_HTML_TAG_NAME -> br 2776 * | `--SLASH_END -> /> 2777 * } 2778 * </pre> 2779 */ 2780 public static final int BR_TAG = JavadocParser.RULE_brTag + RULE_TYPES_OFFSET; 2781 2782 /** Col html tag. */ 2783 public static final int COL_TAG = JavadocParser.RULE_colTag + RULE_TYPES_OFFSET; 2784 2785 /** Frame html tag. */ 2786 public static final int FRAME_TAG = JavadocParser.RULE_frameTag + RULE_TYPES_OFFSET; 2787 2788 /** 2789 * Hr html tag. 2790 * 2791 * <p><b>Example:</b></p> 2792 * <pre>{@code text above line<hr> test after line}</pre> 2793 * <b>Tree:</b> 2794 * <pre> 2795 * {@code 2796 * |--LEADING_ASTERISK -> * 2797 * |--TEXT -> text above line 2798 * |--HTML_ELEMENT -> HTML_ELEMENT 2799 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2800 * | `--HR_TAG -> HR_TAG 2801 * | |--START -> < 2802 * | |--HR_HTML_TAG_NAME -> hr 2803 * | `--END -> > 2804 * |--TEXT -> test after line 2805 * |--NEWLINE -> \r\n 2806 * |--TEXT -> 2807 * } 2808 * </pre> 2809 */ 2810 public static final int HR_TAG = JavadocParser.RULE_hrTag + RULE_TYPES_OFFSET; 2811 2812 /** 2813 * Img html tag. 2814 * 2815 * <p><b>Example:</b></p> 2816 * <pre>{@code <img src="./image.png" alt="image description" width="200" height="100"> }</pre> 2817 * <b>Tree:</b> 2818 * <pre> 2819 * {@code 2820 * `--JAVADOC -> JAVADOC 2821 * |--NEWLINE -> \r\n 2822 * |--LEADING_ASTERISK -> * 2823 * |--TEXT -> 2824 * |--HTML_ELEMENT -> HTML_ELEMENT 2825 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2826 * | `--IMG_TAG -> IMG_TAG 2827 * | |--START -> < 2828 * | |--IMG_HTML_TAG_NAME -> img 2829 * | |--WS -> 2830 * | |--ATTRIBUTE -> ATTRIBUTE 2831 * | | |--HTML_TAG_NAME -> src 2832 * | | |--EQUALS -> = 2833 * | | `--ATTR_VALUE -> "./image.png" 2834 * | |--WS -> 2835 * | |--ATTRIBUTE -> ATTRIBUTE 2836 * | | |--HTML_TAG_NAME -> alt 2837 * | | |--EQUALS -> = 2838 * | | `--ATTR_VALUE -> "image description" 2839 * | |--WS -> 2840 * | |--ATTRIBUTE -> ATTRIBUTE 2841 * | | |--HTML_TAG_NAME -> width 2842 * | | |--EQUALS -> = 2843 * | | `--ATTR_VALUE -> "200" 2844 * | |--WS -> 2845 * | |--ATTRIBUTE -> ATTRIBUTE 2846 * | | |--HTML_TAG_NAME -> height 2847 * | | |--EQUALS -> = 2848 * | | `--ATTR_VALUE -> "100" 2849 * | `--END -> > 2850 * |--NEWLINE -> \r\n 2851 * |--TEXT -> 2852 * } 2853 * </pre> 2854 */ 2855 public static final int IMG_TAG = JavadocParser.RULE_imgTag + RULE_TYPES_OFFSET; 2856 2857 /** 2858 * Input html tag. 2859 * 2860 * <p><b>Example:</b></p> 2861 * <pre>{@code Type here: <input type="text" id="id" name="name"> }</pre> 2862 * <b>Tree:</b> 2863 * <pre> 2864 * {@code 2865 * JAVADOC -> JAVADOC 2866 * |--NEWLINE -> \r\n 2867 * |--LEADING_ASTERISK -> * 2868 * |--TEXT -> Type here: 2869 * |--HTML_ELEMENT -> HTML_ELEMENT 2870 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2871 * | `--INPUT_TAG -> INPUT_TAG 2872 * | |--START -> < 2873 * | |--INPUT_HTML_TAG_NAME -> input 2874 * | |--WS -> 2875 * | |--ATTRIBUTE -> ATTRIBUTE 2876 * | | |--HTML_TAG_NAME -> type 2877 * | | |--EQUALS -> = 2878 * | | `--ATTR_VALUE -> "text" 2879 * | |--WS -> 2880 * | |--ATTRIBUTE -> ATTRIBUTE 2881 * | | |--HTML_TAG_NAME -> id 2882 * | | |--EQUALS -> = 2883 * | | `--ATTR_VALUE -> "id" 2884 * | |--WS -> 2885 * | |--ATTRIBUTE -> ATTRIBUTE 2886 * | | |--HTML_TAG_NAME -> name 2887 * | | |--EQUALS -> = 2888 * | | `--ATTR_VALUE -> "name" 2889 * | `--END -> > 2890 * |--NEWLINE -> \r\n 2891 * |--TEXT -> 2892 * } 2893 * </pre> 2894 */ 2895 public static final int INPUT_TAG = JavadocParser.RULE_inputTag + RULE_TYPES_OFFSET; 2896 2897 /** 2898 * Isindex tag name. 2899 * 2900 * <p><b>Example:</b></p> 2901 * <pre>{@code 2902 * <head> 2903 * <isindex prompt="search"> 2904 * </head> 2905 * }</pre> 2906 * <b>Tree:</b> 2907 * <pre> 2908 * {@code 2909 * |--HTML_ELEMENT -> HTML_ELEMENT 2910 * | `--HEAD -> HEAD 2911 * | |--HEAD_TAG_START -> HEAD_TAG_START 2912 * | | |--START -> < 2913 * | | |--HEAD_HTML_TAG_NAME -> head 2914 * | | `--END -> > 2915 * | |--NEWLINE -> \r\n 2916 * | |--LEADING_ASTERISK -> * 2917 * | |--TEXT -> 2918 * | |--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2919 * | | `--ISINDEX_TAG -> ISINDEX_TAG 2920 * | | |--START -> < 2921 * | | |--ISINDEX_HTML_TAG_NAME -> isindex 2922 * | | |--WS -> 2923 * | | |--ATTRIBUTE -> ATTRIBUTE 2924 * | | | |--HTML_TAG_NAME -> prompt 2925 * | | | |--EQUALS -> = 2926 * | | | `--ATTR_VALUE -> "search" 2927 * | | `--END -> > 2928 * | |--NEWLINE -> \r\n 2929 * | |--LEADING_ASTERISK -> * 2930 * | |--TEXT -> 2931 * | `--HEAD_TAG_END -> HEAD_TAG_END 2932 * | |--START -> < 2933 * | |--SLASH -> / 2934 * | |--HEAD_HTML_TAG_NAME -> head 2935 * | `--END -> > 2936 * |--NEWLINE -> \r\n 2937 * |--TEXT -> 2938 * } 2939 * </pre> 2940 */ 2941 public static final int ISINDEX_TAG = JavadocParser.RULE_isindexTag + RULE_TYPES_OFFSET; 2942 2943 /** Link html tag. */ 2944 public static final int LINK_TAG = JavadocParser.RULE_linkTag + RULE_TYPES_OFFSET; 2945 2946 /** 2947 * Meta html tag. 2948 * 2949 * <p><b>Example:</b></p> 2950 * <pre>{@code <meta charset="UTF-8"> }</pre> 2951 * <b>Tree:</b> 2952 * <pre> 2953 * {@code 2954 * `--JAVADOC -> JAVADOC 2955 * |--NEWLINE -> \r\n 2956 * |--LEADING_ASTERISK -> * 2957 * |--TEXT -> 2958 * |--HTML_ELEMENT -> HTML_ELEMENT 2959 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2960 * | `--META_TAG -> META_TAG 2961 * | |--START -> < 2962 * | |--META_HTML_TAG_NAME -> meta 2963 * | |--WS -> 2964 * | |--ATTRIBUTE -> ATTRIBUTE 2965 * | | |--HTML_TAG_NAME -> charset 2966 * | | |--EQUALS -> = 2967 * | | `--ATTR_VALUE -> "UTF-8" 2968 * | `--END -> > 2969 * |--NEWLINE -> \r\n 2970 * |--TEXT -> 2971 * } 2972 * </pre> 2973 */ 2974 public static final int META_TAG = JavadocParser.RULE_metaTag + RULE_TYPES_OFFSET; 2975 2976 /** Param html tag. */ 2977 public static final int PARAM_TAG = JavadocParser.RULE_paramTag + RULE_TYPES_OFFSET; 2978 2979 /** 2980 * HTML void element. 2981 * 2982 * <p><b>Example:</b></p> 2983 * <pre>{@code 2984 * <embed src="URL" type="MIME_type"> 2985 * }</pre> 2986 * <b>Tree:</b> 2987 * <pre> 2988 * {@code 2989 * |--HTML_ELEMENT -> HTML_ELEMENT 2990 * | `--SINGLETON_ELEMENT -> SINGLETON_ELEMENT 2991 * | `--EMBED_TAG -> EMBED_TAG 2992 * | |--START -> < 2993 * | |--EMBED_HTML_TAG_NAME -> embed 2994 * | |--WS -> 2995 * | |--ATTRIBUTE -> ATTRIBUTE 2996 * | | |--HTML_TAG_NAME -> src 2997 * | | |--EQUALS -> = 2998 * | | `--ATTR_VALUE -> "URL" 2999 * | |--WS -> 3000 * | |--ATTRIBUTE -> ATTRIBUTE 3001 * | | |--HTML_TAG_NAME -> type 3002 * | | |--EQUALS -> = 3003 * | | `--ATTR_VALUE -> "MIME_type" 3004 * | `--END -> > 3005 * |--NEWLINE -> \r\n 3006 * |--TEXT -> 3007 * } 3008 * </pre> 3009 * 3010 * @see #EMBED_TAG 3011 * @see <a href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-embed"> 3012 * W3 docs</a> 3013 */ 3014 public static final int EMBED_TAG = JavadocParser.RULE_embedTag + RULE_TYPES_OFFSET; 3015 3016 /** 3017 * HTML void element {@code <keygen>}. 3018 * 3019 * @see #SINGLETON_ELEMENT 3020 * @see <a href="https://www.w3.org/TR/html51/sec-forms.html#elementdef-keygen"> 3021 * W3 docs</a> 3022 */ 3023 public static final int KEYGEN_TAG = JavadocParser.RULE_keygenTag + RULE_TYPES_OFFSET; 3024 3025 /** 3026 * HTML void element {@code <source>}. 3027 * 3028 * @see #SINGLETON_ELEMENT 3029 * @see <a href= 3030 * "https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-media-source"> 3031 * W3 docs</a> 3032 */ 3033 public static final int SOURCE_TAG = JavadocParser.RULE_sourceTag + RULE_TYPES_OFFSET; 3034 3035 /** 3036 * HTML void element {@code <track>}. 3037 * 3038 * @see #SINGLETON_ELEMENT 3039 * @see <a 3040 * href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-track"> 3041 * W3 docs</a> 3042 */ 3043 public static final int TRACK_TAG = JavadocParser.RULE_trackTag + RULE_TYPES_OFFSET; 3044 3045 /** 3046 * HTML void element {@code <wbr>}. 3047 * 3048 * @see #SINGLETON_ELEMENT 3049 * @see <a href="https://www.w3.org/TR/html51/textlevel-semantics.html#elementdef-wbr"> 3050 * W3 docs</a> 3051 */ 3052 public static final int WBR_TAG = JavadocParser.RULE_wbrTag + RULE_TYPES_OFFSET; 3053 3054 /////////////////////////////////////////////////////////////////////////////////////////////// 3055 3056 /** 3057 * Html comment: <code><!-- --></code>. 3058 * 3059 * @noinspection HtmlTagCanBeJavadocTag 3060 * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when 3061 * replaced with Javadoc tag 3062 */ 3063 public static final int HTML_COMMENT = JavadocParser.RULE_htmlComment 3064 + RULE_TYPES_OFFSET; 3065 /** 3066 * CHAR and WS sequence. 3067 */ 3068 public static final int TEXT = JavadocParser.RULE_text + RULE_TYPES_OFFSET; 3069 3070 /** Empty private constructor of the current class. */ 3071 private JavadocTokenTypes() { 3072 } 3073 3074}