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