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