View Javadoc
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 -&gt; JAVADOC_TAG
312      *    |--THROWS_LITERAL -&gt; @throws
313      *    |--WS -&gt;
314      *    |--CLASS_NAME -&gt; SQLException
315      *    |--WS -&gt;
316      *    `--DESCRIPTION -&gt; DESCRIPTION
317      *        `--TEXT -&gt; if query is not correct
318      * }</pre>
319      *
320      * @see
321      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCHAHD">
322      * Oracle Docs</a>
323      * @see #JAVADOC_TAG
324      */
325     public static final int THROWS_LITERAL = JavadocParser.THROWS_LITERAL;
326 
327     /**
328      * '@author' literal in {@code @author} Javadoc tag.
329      *
330      * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p>
331      *
332      * <p><b>Example:</b></p>
333      * <pre>{@code @author Baratali Izmailov}</pre>
334      * <b>Tree:</b>
335      * <pre>{@code
336      *   JAVADOC_TAG -> JAVADOC_TAG
337      *      |--AUTHOR_LITERAL -> @author
338      *      |--WS ->
339      *      `--DESCRIPTION -> DESCRIPTION
340      *          |--TEXT -> Baratali Izmailov
341      *          |--NEWLINE -> \r\n
342      * }</pre>
343      *
344      * @see
345      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCBAHA">
346      * Oracle Docs</a>
347      * @see #JAVADOC_TAG
348      */
349     public static final int AUTHOR_LITERAL = JavadocParser.AUTHOR_LITERAL;
350 
351     /**
352      * Name of custom Javadoc tag (or Javadoc inline tag).
353      *
354      * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p>
355      *
356      * <p><b>Example:</b></p>
357      * <pre>{@code @myJavadocTag some magic}</pre>
358      * <b>Tree:</b>
359      * <pre>{@code
360      *   JAVADOC_TAG --> JAVADOC_TAG
361      *       |--CUSTOM_NAME --> @myJavadocTag
362      *       |--WS -->
363      *       `--DESCRIPTION --> DESCRIPTION
364      *           |--TEXT --> some magic
365      * }</pre>
366      */
367     public static final int CUSTOM_NAME = JavadocParser.CUSTOM_NAME;
368 
369     /**
370      * First child of {@link #JAVADOC_INLINE_TAG} that represents left curly brace '{'.
371      *
372      * <p><b>Example:</b></p>
373      * <pre><code>{&#64;code Comparable&lt;E&gt;}</code></pre>
374      * <b>Tree:</b>
375      * <pre>
376      * <code> JAVADOC_INLINE_TAG --&gt; JAVADOC_INLINE_TAG
377      *         |--JAVADOC_INLINE_TAG_START --&gt; {
378      *         |--CODE_LITERAL --&gt; @code
379      *         |--WS --&gt;
380      *         |--TEXT --&gt; Comparable&lt;E&gt;
381      *         `--JAVADOC_INLINE_TAG_END --&gt; }
382      * </code>
383      * </pre>
384      *
385      * @noinspection HtmlTagCanBeJavadocTag
386      * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
387      *      replaced with Javadoc tag
388      */
389     public static final int JAVADOC_INLINE_TAG_START = JavadocParser.JAVADOC_INLINE_TAG_START;
390 
391     /**
392      * Last child of {@link #JAVADOC_INLINE_TAG} that represents right curly brace '}'.
393      *
394      * <p><b>Example:</b></p>
395      * <pre><code>{&#64;code Comparable&lt;E&gt;}</code></pre>
396      * <b>Tree:</b>
397      * <pre>
398      * <code>JAVADOC_INLINE_TAG --&gt; JAVADOC_INLINE_TAG
399      *        |--JAVADOC_INLINE_TAG_START --&gt; {
400      *        |--CODE_LITERAL --&gt; @code
401      *        |--WS --&gt;
402      *        |--TEXT --&gt; Comparable&lt;E&gt;
403      *        `--JAVADOC_INLINE_TAG_END --&gt; }
404      *
405      * </code>
406      * </pre>
407      *
408      * @noinspection HtmlTagCanBeJavadocTag
409      * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
410      *      replaced with Javadoc tag
411      */
412     public static final int JAVADOC_INLINE_TAG_END = JavadocParser.JAVADOC_INLINE_TAG_END;
413 
414     /**
415      * '@code' literal in {&#64;code} Javadoc inline tag.
416      *
417      * <p>Such Javadoc inline tag can have such child nodes:</p>
418      * <ul>
419      * <li>{@link #NEWLINE}</li>
420      * <li>{@link #WS}</li>
421      * <li>{@link #TEXT}</li>
422      * </ul>
423      *
424      * <p><b>Example:</b></p>
425      * <pre><code>{&#64;code Comparable&lt;E&gt;}</code></pre>
426      * <b>Tree:</b>
427      * <pre>
428      * <code>JAVADOC_TAG -&gt; JAVADOC_TAG
429      *        |--CUSTOM_NAME -&gt; @code
430      *        |--WS -&gt;
431      *        `--DESCRIPTION -&gt; DESCRIPTION
432      *            |--TEXT -&gt; Comparable&lt;E&gt;
433      * </code>
434      * </pre>
435      *
436      * @see
437      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDFHHBB">
438      * Oracle Docs</a>
439      * @see #JAVADOC_INLINE_TAG
440      * @noinspection HtmlTagCanBeJavadocTag
441      * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
442      *      replaced with Javadoc tag
443      */
444     public static final int CODE_LITERAL = JavadocParser.CODE_LITERAL;
445 
446     /**
447      * '@docRoot' literal in {&#64;docRoot} Javadoc inline tag.
448      *
449      * <p>Such Javadoc inline tag does not have any arguments and can have such child nodes:</p>
450      * <ul>
451      * <li>{@link #NEWLINE}</li>
452      * <li>{@link #WS}</li>
453      * </ul>
454      *
455      * <p><b>Example:</b></p>
456      * <pre><code>{&#64;docRoot}</code></pre>
457      * <b>Tree:</b>
458      * <pre>
459      * <code>  |--JAVADOC_INLINE_TAG[1x0] : [{&#64;docRoot}]
460      *            |--JAVADOC_INLINE_TAG_START[1x0] : [{]
461      *            |--DOC_ROOT_LITERAL[1x1] : [@docRoot]
462      *            |--JAVADOC_INLINE_TAG_END[2x0] : [}]
463      * </code>
464      * </pre>
465      *
466      * <p><b>Example:</b></p>
467      * <pre><code>{&#64;docRoot
468      * }</code></pre>
469      * <b>Tree:</b>
470      * <pre>
471      * <code>  |--JAVADOC_INLINE_TAG[1x0] : [{&#64;docRoot \n}]
472      *            |--JAVADOC_INLINE_TAG_START[1x0] : [{]
473      *            |--DOC_ROOT_LITERAL[1x1] : [@docRoot]
474      *            |--WS[1x9] : [ ]
475      *            |--NEWLINE[1x10] : [\n]
476      *            |--JAVADOC_INLINE_TAG_END[2x0] : [}]
477      * </code>
478      * </pre>
479      *
480      * @see
481      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDBACBF">
482      * Oracle Docs</a>
483      * @see #JAVADOC_INLINE_TAG
484      * @noinspection HtmlTagCanBeJavadocTag
485      * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
486      *      replaced with Javadoc tag
487      */
488     public static final int DOC_ROOT_LITERAL = JavadocParser.DOC_ROOT_LITERAL;
489 
490     /**
491      * '@link' literal in {&#64;link} Javadoc inline tag.
492      *
493      * <p>Such Javadoc inline tag can have one argument - {@link #REFERENCE}</p>
494      *
495      * <p><b>Example:</b></p>
496      *
497      * <pre><code>{&#64;link org.apache.utils.Lists.Comparator#compare(Object)}</code></pre>
498      *
499      * <p><b>Tree:</b></p>
500      *
501      * <pre>
502      * <code> |--JAVADOC_INLINE_TAG[1x0] :
503      *               [{&#64;link org.apache.utils.Lists.Comparator#compare(Object)}]
504      *        |--JAVADOC_INLINE_TAG_START[1x0] : [{]
505      *        |--LINK_LITERAL[1x1] : [@link]
506      *        |--WS[1x6] : [ ]
507      *        |--REFERENCE[1x7] : [org.apache.utils.Lists.Comparator#compare(Object)]
508      *            |--PACKAGE_CLASS[1x7] : [org.apache.utils]
509      *            |--DOT[1x23] : [.]
510      *            |--CLASS[1x24] : [Lists]
511      *            |--DOT[1x29] : [.]
512      *            |--CLASS[1x30] : [Comparator]
513      *            |--HASH[1x40] : [#]
514      *            |--MEMBER[1x41] : [compare]
515      *            |--PARAMETERS[1x48] : [(Object)]
516      *                |--LEFT_BRACE[1x48] : [(]
517      *                |--ARGUMENT[1x49] : [Object]
518      *                |--RIGHT_BRACE[1x55] : [)]
519      *        |--JAVADOC_INLINE_TAG_END[1x56] : [}]
520      * </code>
521      * </pre>
522      *
523      * @see
524      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDIECH">
525      * Oracle Docs</a>
526      * @see #JAVADOC_INLINE_TAG
527      * @noinspection HtmlTagCanBeJavadocTag
528      * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
529      *      replaced with Javadoc tag
530      */
531     public static final int LINK_LITERAL = JavadocParser.LINK_LITERAL;
532 
533     /**
534      * '@inheritDoc' literal in {&#64;inheritDoc} Javadoc inline tag.
535      *
536      * <p>Such Javadoc inline tag does not have any arguments and can have such child nodes:</p>
537      * <ul>
538      * <li>{@link #NEWLINE}</li>
539      * <li>{@link #WS}</li>
540      * </ul>
541      *
542      * <p><b>Example:</b></p>
543      * <pre><code>{&#64;inheritDoc}</code></pre>
544      * <b>Tree:</b>
545      * <pre>{@code
546      *   JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
547      *    |--JAVADOC_INLINE_TAG_START -> {
548      *    |--INHERIT_DOC_LITERAL -> @inheritDoc
549      *    |--JAVADOC_INLINE_TAG_END -> }
550      * }</pre>
551      *
552      * @see
553      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDGJCHC">
554      * Oracle Docs</a>
555      * @see #JAVADOC_INLINE_TAG
556      * @noinspection HtmlTagCanBeJavadocTag
557      * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
558      *      replaced with Javadoc tag
559      */
560     public static final int INHERIT_DOC_LITERAL = JavadocParser.INHERIT_DOC_LITERAL;
561 
562     /**
563      * '@linkplain' literal in {&#64;linkplain} Javadoc inline tag.
564      *
565      * <p>Such Javadoc inline tag can have one argument - {@link #REFERENCE}</p>
566      *
567      * <p><b>Example:</b></p>
568      * <pre><code>{&#64;linkplain org.apache.utils.Lists.Comparator#compare(Object) compare}</code>
569      * </pre>
570      * <b>Tree:</b>
571      * <pre>{@code
572      *   JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
573      *    |--JAVADOC_INLINE_TAG_START -> {
574      *    |--LINKPLAIN_LITERAL -> @linkplain
575      *    |--WS ->
576      *    |--REFERENCE -> org.apache.utils.Lists.Comparator#compare(Object)
577      *        |--PACKAGE_CLASS -> org.apache.utils
578      *        |--DOT -> .
579      *        |--CLASS -> Lists
580      *        |--DOT -> .
581      *        |--CLASS -> Comparator
582      *        |--HASH -> #
583      *        |--MEMBER -> compare
584      *        |--PARAMETERS -> (Object)
585      *            |--LEFT_BRACE -> (
586      *            |--ARGUMENT -> Object
587      *            |--RIGHT_BRACE -> )
588      *     |--DESCRIPTION -> compare
589      *         |--TEXT -> compare
590      *     |--JAVADOC_INLINE_TAG_END -> }
591      * }</pre>
592      *
593      * @see
594      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDGBICD">
595      * Oracle Docs</a>
596      * @see #JAVADOC_INLINE_TAG
597      * @noinspection HtmlTagCanBeJavadocTag
598      * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
599      *      replaced with Javadoc tag
600      */
601     public static final int LINKPLAIN_LITERAL = JavadocParser.LINKPLAIN_LITERAL;
602 
603     /**
604      * '@literal' literal in {&#64;literal} Javadoc inline tag.
605      *
606      * <p>Such Javadoc inline tag can have such child nodes:</p>
607      * <ul>
608      * <li>{@link #NEWLINE}</li>
609      * <li>{@link #WS}</li>
610      * <li>{@link #TEXT}</li>
611      * </ul>
612      *
613      * <p><b>Example:</b></p>
614      * <pre><code>{&#64;literal #compare(Object)}</code></pre>
615      * <b>Tree:</b>
616      * <pre>
617      * <code>
618      *     |--JAVADOC_INLINE_TAG -&gt; JAVADOC_INLINE_TAG
619      *        |--JAVADOC_INLINE_TAG_START -&gt; {
620      *        |--LITERAL_LITERAL -&gt; @literal
621      *        |--WS -&gt;
622      *        |--TEXT -&gt; #compare(Object)
623      *        `--JAVADOC_INLINE_TAG_END -&gt; }
624      * </code>
625      * </pre>
626      *
627      * @see
628      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCFJDG">
629      * Oracle Docs</a>
630      * @see #JAVADOC_INLINE_TAG
631      * @noinspection HtmlTagCanBeJavadocTag
632      * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
633      *      replaced with Javadoc tag
634      */
635     public static final int LITERAL_LITERAL = JavadocParser.LITERAL_LITERAL;
636 
637     /**
638      * '@value' literal in {&#64;value} Javadoc inline tag.
639      *
640      * <p>Such Javadoc inline tag has one argument {@link #REFERENCE}
641      * and can have such child nodes:</p>
642      * <ul>
643      * <li>{@link #NEWLINE}</li>
644      * <li>{@link #WS}</li>
645      * </ul>
646      *
647      * <p><b>Example:</b></p>
648      * <pre><code>{&#64;value Integer#MAX_VALUE}</code></pre>
649      * <b>Tree:</b>
650      * <pre>
651      * <code> JAVADOC_INLINE_TAG --&gt; JAVADOC_INLINE_TAG
652      *         |--JAVADOC_INLINE_TAG_START --&gt; {
653      *         |--VALUE_LITERAL --&gt; @value
654      *         |--WS --&gt;
655      *         |--REFERENCE --&gt; REFERENCE
656      *         |   |--PACKAGE_CLASS --&gt; Integer
657      *         |   |--HASH --&gt; #
658      *         |   `--MEMBER --&gt; MAX_VALUE
659      *         `--JAVADOC_INLINE_TAG_END --&gt; }
660      * </code>
661      * </pre>
662      *
663      * @see
664      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDCDHH">
665      * Oracle Docs</a>
666      * @see #JAVADOC_INLINE_TAG
667      * @noinspection HtmlTagCanBeJavadocTag
668      * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
669      *      replaced with Javadoc tag
670      */
671     public static final int VALUE_LITERAL = JavadocParser.VALUE_LITERAL;
672 
673     /**
674      * PACKAGE_CLASS represents the package or class which has been referenced in the `@see`,
675      * `@link`, `@linkplain` or `@value` javadoc tags. In the javadoc tree it shall be a child
676      * of {@link #REFERENCE}.
677      * <br>
678      * <strong>IMPORTANT:</strong> Constructs like
679      * {@code package.Class.NestedClassAtDepth1.NestedClassAtDepth2#member} are recognized by
680      * the javadoc tool from oracle, and no assumptions like, package names wouldn't consist of
681      * uppercase characters or class names begin with an uppercase character, are made.
682      * Also, <i>the reference</i> in a javadoc tag can consist just a package name or a
683      * simple class name or even a full class name. Thus, PACKAGE_CLASS can represent a
684      * package name or a simple class name or a full class name i.e. checkstyle doesn't
685      * resolve references at present.
686      *
687      * <p><b>Example:</b></p>
688      * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre>
689      * <b>Tree:</b>
690      * <pre>
691      * {@code
692      * JAVADOC_TAG -&gt JAVADOC_TAG
693      *  |--SEE_LITERAL -&gt @see
694      *  |--WS -&gt
695      *  |--REFERENCE -&gt REFERENCE
696      *  |   |--PACKAGE_CLASS -&gt org.apache.utils.Lists.Comparator
697      *  |   |--HASH -&gt #
698      *  |   |--MEMBER -&gt compare
699      *  |   `--PARAMETERS -&gt PARAMETERS
700      *  |       |--LEFT_BRACE -&gt (
701      *  |       |--ARGUMENT -&gt Object
702      *  |       `--RIGHT_BRACE -&gt )
703      *  |--NEWLINE -&gt \r\n
704      *  `--WS -&gt
705      * }
706      * </pre>
707      */
708     public static final int PACKAGE_CLASS = JavadocParser.PACKAGE_CLASS;
709 
710     /**
711      * Hash character in {@link #REFERENCE}.
712      * Hash character is used before specifying a class member.
713      *
714      * <p><b>Example:</b></p>
715      * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre>
716      * <b>Tree:</b>
717      * <pre>
718      * {@code
719      * JAVADOC_TAG -&gt JAVADOC_TAG
720      *  |--SEE_LITERAL -&gt @see
721      *  |--WS -&gt
722      *  |--REFERENCE -&gt REFERENCE
723      *      |--PACKAGE_CLASS -&gt org.apache.utils.Lists.Comparator
724      *      |--HASH -&gt #
725      *      |--MEMBER -&gt compare
726      *      `--PARAMETERS -&gt PARAMETERS
727      *          |--LEFT_BRACE -&gt (
728      *          |--ARGUMENT -&gt Object
729      *          `--RIGHT_BRACE -&gt )
730      * }
731      * </pre>
732      */
733     public static final int HASH = JavadocParser.HASH;
734 
735     /**
736      * A class member in {@link #REFERENCE}.
737      * Class member is specified after {@link #HASH} symbol.
738      *
739      * <p><b>Example:</b></p>
740      * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre>
741      * <b>Tree:</b>
742      * <pre>
743      * {@code
744      * JAVADOC_TAG -&gt JAVADOC_TAG
745      *  |--SEE_LITERAL -&gt @see
746      *  |--WS -&gt
747      *  |--REFERENCE -&gt REFERENCE
748      *      |--PACKAGE_CLASS -&gt org.apache.utils.Lists.Comparator
749      *      |--HASH -&gt #
750      *      |--MEMBER -&gt compare
751      *      `--PARAMETERS -&gt PARAMETERS
752      *          |--LEFT_BRACE -&gt (
753      *          |--ARGUMENT -&gt Object
754      *          `--RIGHT_BRACE -&gt )
755      * }
756      * </pre>
757      */
758     public static final int MEMBER = JavadocParser.MEMBER;
759 
760     /**
761      * Left brace in {@link #PARAMETERS} part of {@link #REFERENCE}.
762      *
763      * <p><b>Example:</b></p>
764      * <pre>{@code @see #method(Processor, String)}</pre>
765      * <b>Tree:</b>
766      * <pre>
767      * {@code JAVADOC_TAG -&gt JAVADOC_TAG
768      *         |--SEE_LITERAL -&gt @see
769      *         |--WS -&gt
770      *         |--REFERENCE -&gt REFERENCE
771      *         |   |--HASH -&gt #
772      *         |   |--MEMBER -&gt method
773      *         |   `--PARAMETERS -&gt PARAMETERS
774      *         |       |--LEFT_BRACE -&gt (
775      *         |       |--ARGUMENT -&gt Processor
776      *         |       |--COMMA -&gt ,
777      *         |       |--WS -&gt
778      *         |       |--ARGUMENT -&gt String
779      *         |       `--RIGHT_BRACE -&gt )
780      * }
781      * </pre>
782      */
783     public static final int LEFT_BRACE = JavadocParser.LEFT_BRACE;
784 
785     /**
786      * Right brace in {@link #PARAMETERS} part of {@link #REFERENCE}.
787      *
788      * <p><b>Example:</b></p>
789      * <pre>{@code @see #method(Processor, String)}</pre>
790      * <b>Tree:</b>
791      * <pre>
792      * {@code JAVADOC_TAG -&gt JAVADOC_TAG
793      *         |--SEE_LITERAL -&gt @see
794      *         |--WS -&gt
795      *         |--REFERENCE -&gt REFERENCE
796      *         |   |--HASH -&gt #
797      *         |   |--MEMBER -&gt method
798      *         |   `--PARAMETERS -&gt PARAMETERS
799      *         |       |--LEFT_BRACE -&gt (
800      *         |       |--ARGUMENT -&gt Processor
801      *         |       |--COMMA -&gt ,
802      *         |       |--WS -&gt
803      *         |       |--ARGUMENT -&gt String
804      *         |       `--RIGHT_BRACE -&gt )
805      * }
806      * </pre>
807      */
808     public static final int RIGHT_BRACE = JavadocParser.RIGHT_BRACE;
809 
810     /**
811      * Argument definition in {@link #PARAMETERS} part of {@link #REFERENCE}.
812      *
813      * <p><b>Example:</b></p>
814      * <pre>{@code @see #method(Processor, String)}</pre>
815      * <b>Tree:</b>
816      * <pre>
817      * {@code JAVADOC_TAG -&gt JAVADOC_TAG
818      *         |--SEE_LITERAL -&gt @see
819      *         |--WS -&gt
820      *         |--REFERENCE -&gt REFERENCE
821      *         |   |--HASH -&gt #
822      *         |   |--MEMBER -&gt method
823      *         |   `--PARAMETERS -&gt PARAMETERS
824      *         |       |--LEFT_BRACE -&gt (
825      *         |       |--ARGUMENT -&gt Processor
826      *         |       |--COMMA -&gt ,
827      *         |       |--WS -&gt
828      *         |       |--ARGUMENT -&gt String
829      *         |       `--RIGHT_BRACE -&gt )
830      *         `--NEWLINE -&gt \n
831      * }
832      * </pre>
833      */
834     public static final int ARGUMENT = JavadocParser.ARGUMENT;
835 
836     /**
837      * Comma separator between parameters in {@link #PARAMETERS} part of {@link #REFERENCE}.
838      *
839      * <p><b>Example:</b></p>
840      * <pre>{@code @see #method(Processor, String)}</pre>
841      * <b>Tree:</b>
842      * <pre>
843      * {@code
844      * JAVADOC_TAG -&gt JAVADOC_TAG
845      *  |--SEE_LITERAL -&gt @see
846      *  |--WS -&gt
847      *  |--REFERENCE -&gt REFERENCE
848      *  |   |--HASH -&gt #
849      *  |   |--MEMBER -&gt method
850      *  |   `--PARAMETERS -&gt PARAMETERS
851      *  |       |--LEFT_BRACE -&gt (
852      *  |       |--ARGUMENT -&gt Processor
853      *  |       |--COMMA -&gt ,
854      *  |       |--WS -&gt
855      *  |       |--ARGUMENT -&gt String
856      *  |       `--RIGHT_BRACE -&gt )
857      *  |--NEWLINE -&gt \r\n
858      *  `--WS -&gt
859      * }
860      * </pre>
861      *
862      * @see #PARAMETERS
863      * @see #REFERENCE
864      * @see #ARGUMENT
865      */
866     public static final int COMMA = JavadocParser.COMMA;
867 
868     /**
869      * Quoted text.
870      * One of possible {@code @see} tag arguments.
871      *
872      * <p><b>Example:</b></p>
873      * <pre>{@code @see "Spring Framework"}</pre>
874      * <b>Tree:</b>
875      * <pre>
876      * {@code
877      * JAVADOC_TAG -&gt JAVADOC_TAG
878      *  |--SEE_LITERAL -&gt @see
879      *  |--WS -&gt
880      *  |--STRING -&gt "Spring Framework"
881      *  |--NEWLINE -&gt \r\n
882      *  `--WS -&gt
883      * }
884      * </pre>
885      *
886      * @see #SEE_LITERAL
887      */
888     public static final int STRING = JavadocParser.STRING;
889 
890     /**
891      * Exception class name. First argument in {@link #THROWS_LITERAL @throws} and
892      * {@link #EXCEPTION_LITERAL @exception} Javadoc tags.
893      *
894      * <p><b>Example:</b></p>
895      * <pre>{@code @throws IOException connection problems}</pre>
896      * <b>Tree:</b>
897      * <pre>
898      * {@code
899      * JAVADOC_TAG -&gt JAVADOC_TAG
900      *  |--THROWS_LITERAL -&gt @throws
901      *  |--WS -&gt
902      *  |--CLASS_NAME -&gt IOException
903      *  |--WS -&gt
904      *  `--DESCRIPTION -&gt DESCRIPTION
905      *      |--TEXT -&gt connection problems
906      *      |--NEWLINE -&gt \r\n
907      *      `--TEXT -&gt
908      * }
909      * </pre>
910      *
911      * @see #EXCEPTION_LITERAL
912      * @see #THROWS_LITERAL
913      */
914     public static final int CLASS_NAME = JavadocParser.CLASS_NAME;
915 
916     /**
917      * First argument in {@link #PARAM_LITERAL @param} Javadoc tag.
918      *
919      * <p><b>Example:</b></p>
920      * <pre>{@code @param T The bar.}</pre>
921      * <b>Tree:</b>
922      * <pre>
923      * {@code JAVADOC_TAG -&gt JAVADOC_TAG
924      *         |--PARAM_LITERAL -&gt @param
925      *         |--WS -&gt
926      *         |--PARAMETER_NAME -&gt T
927      *         |--WS -&gt
928      *         `--DESCRIPTION -&gt DESCRIPTION
929      *             |--TEXT -&gt The bar.
930      *             |--NEWLINE -&gt \r\n
931      *             `--TEXT -&gt
932      * }
933      * </pre>
934      *
935      * @see
936      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHJECF">
937      * Oracle Docs</a>
938      * @see #PARAM_LITERAL
939      */
940     public static final int PARAMETER_NAME = JavadocParser.PARAMETER_NAME;
941 
942     /**
943      * 'exclude' literal.
944      * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments.
945      *
946      * <p><b>Example:</b></p>
947      * <pre>{@code @serial exclude}</pre>
948      * <b>Tree:</b>
949      * <pre>
950      * {@code
951      *   JAVADOC_TAG -> JAVADOC_TAG
952      *    |--SERIAL_LITERAL -> @serial
953      *    |--WS ->
954      *    `--DESCRIPTION -> DESCRIPTION
955      *        |--TEXT -> serialized company name
956      *        |--NEWLINE -> \r\n
957      *        `--TEXT ->
958      * }
959      * </pre>
960      *
961      * @see
962      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
963      * Oracle Docs</a>
964      * @see #SERIAL_LITERAL
965      */
966     public static final int LITERAL_EXCLUDE = JavadocParser.LITERAL_EXCLUDE;
967 
968     /**
969      * 'include' literal.
970      * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments.
971      *
972      * <p><b>Example:</b></p>
973      * <pre>{@code @serial include}</pre>
974      * <b>Tree:</b>
975      * <pre>
976      * {@code
977      * JAVADOC_TAG -&gt JAVADOC_TAG
978      *  |--SERIAL_LITERAL -&gt @serial
979      *  |--WS -&gt
980      *  |--LITERAL_INCLUDE -&gt include
981      *  |--NEWLINE -&gt \r\n
982      *  `--WS -&gt
983      * }
984      * </pre>
985      *
986      * @see
987      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
988      * Oracle Docs</a>
989      * @see #SERIAL_LITERAL
990      */
991     public static final int LITERAL_INCLUDE = JavadocParser.LITERAL_INCLUDE;
992 
993     /**
994      * Field name. First argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag.
995      *
996      * <p><b>Example:</b></p>
997      * <pre>{@code @serialField counter Integer objects counter}</pre>
998      * <b>Tree:</b>
999      * <pre>
1000      * {@code
1001      *   JAVADOC_TAG -&gt; JAVADOC_TAG
1002      *    |--SERIAL_FIELD_LITERAL -&gt; @serialField
1003      *    |--WS -&gt;
1004      *    |--FIELD_NAME -&gt; counter
1005      *    |--WS -&gt;
1006      *    |--FIELD_TYPE -&gt; Integer
1007      *    |--WS -&gt;
1008      *    `--DESCRIPTION -&gt; DESCRIPTION
1009      *        |--TEXT -&gt; objects counter
1010      *        |--NEWLINE -&gt; \r\n
1011      *        `--TEXT -&gt;
1012      * }</pre>
1013      *
1014      * @see
1015      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
1016      * Oracle Docs</a>
1017      * @see #SERIAL_FIELD_LITERAL
1018      */
1019     public static final int FIELD_NAME = JavadocParser.FIELD_NAME;
1020 
1021     /**
1022      * Field type. Second argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag.
1023      *
1024      * <p><b>Example:</b></p>
1025      * <pre>{@code @serialField counter Integer objects counter}</pre>
1026      * <b>Tree:</b>
1027      * <pre>
1028      * {@code JAVADOC_TAG -&gt JAVADOC_TAG
1029      *         |--SERIAL_FIELD_LITERAL -&gt @serialField
1030      *         |--WS -&gt
1031      *         |--FIELD_NAME -&gt counter
1032      *         |--WS -&gt
1033      *         |--FIELD_TYPE -&gt Integer
1034      *         |--WS -&gt
1035      *         `--DESCRIPTION -&gt DESCRIPTION
1036      *             |--TEXT -&gt objects counter
1037      *             `--NEWLINE -&gt \n
1038      * }
1039      * </pre>
1040      *
1041      * @see
1042      * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
1043      * Oracle Docs</a>
1044      * @see #SERIAL_FIELD_LITERAL
1045      */
1046     public static final int FIELD_TYPE = JavadocParser.FIELD_TYPE;
1047 
1048     // ------------------------------------------------------------------------------------------ //
1049     // -----------------        HTML TAGS          ---------------------------------------------- //
1050     // ------------------------------------------------------------------------------------------ //
1051 
1052     /**
1053      * Identifier inside HTML tag: tag name or attribute name.
1054      */
1055     public static final int HTML_TAG_NAME = JavadocParser.HTML_TAG_NAME;
1056 
1057     // HTML tag components
1058 
1059     /**
1060      * Start html tag component: {@code '<'}.
1061      */
1062     public static final int START = JavadocParser.START;
1063 
1064     /**
1065      * Slash html tag component: {@code '/'}.
1066      */
1067     public static final int SLASH = JavadocParser.SLASH;
1068 
1069     /**
1070      * End html tag component: {@code '>'}.
1071      */
1072     public static final int END = JavadocParser.END;
1073 
1074     /**
1075      * Slash close html tag component: {@code '/>'}.
1076      */
1077     public static final int SLASH_END = JavadocParser.SLASH_END;
1078 
1079     /**
1080      * Equals html tag component: {@code '='}.
1081      */
1082     public static final int EQUALS = JavadocParser.EQUALS;
1083 
1084     /**
1085      * Attribute value html tag component.
1086      */
1087     public static final int ATTR_VALUE = JavadocParser.ATTR_VALUE;
1088 
1089     /////////////////////// HTML TAGS WITH OPTIONAL END TAG /////////////////////////////////////
1090     /** Paragraph tag name. */
1091     public static final int P_HTML_TAG_NAME = JavadocParser.P_HTML_TAG_NAME;
1092 
1093     /** List item tag name. */
1094     public static final int LI_HTML_TAG_NAME = JavadocParser.LI_HTML_TAG_NAME;
1095 
1096     /** Table row tag name. */
1097     public static final int TR_HTML_TAG_NAME = JavadocParser.TR_HTML_TAG_NAME;
1098 
1099     /** Table cell tag name. */
1100     public static final int TD_HTML_TAG_NAME = JavadocParser.TD_HTML_TAG_NAME;
1101 
1102     /** Table header cell tag name. */
1103     public static final int TH_HTML_TAG_NAME = JavadocParser.TH_HTML_TAG_NAME;
1104 
1105     /** Body tag name. */
1106     public static final int BODY_HTML_TAG_NAME = JavadocParser.BODY_HTML_TAG_NAME;
1107 
1108     /** Colgroup tag name. */
1109     public static final int COLGROUP_HTML_TAG_NAME = JavadocParser.COLGROUP_HTML_TAG_NAME;
1110 
1111     /** Description of a term tag name. */
1112     public static final int DD_HTML_TAG_NAME = JavadocParser.DD_HTML_TAG_NAME;
1113 
1114     /** Description term tag name. */
1115     public static final int DT_HTML_TAG_NAME = JavadocParser.DT_HTML_TAG_NAME;
1116 
1117     /** Head tag name. */
1118     public static final int HEAD_HTML_TAG_NAME = JavadocParser.HEAD_HTML_TAG_NAME;
1119 
1120     /** Html tag name. */
1121     public static final int HTML_HTML_TAG_NAME = JavadocParser.HTML_HTML_TAG_NAME;
1122 
1123     /** Option tag name. */
1124     public static final int OPTION_HTML_TAG_NAME = JavadocParser.OPTION_HTML_TAG_NAME;
1125 
1126     /** Table body tag name. */
1127     public static final int TBODY_HTML_TAG_NAME = JavadocParser.TBODY_HTML_TAG_NAME;
1128 
1129     /** Table foot tag name. */
1130     public static final int TFOOT_HTML_TAG_NAME = JavadocParser.TFOOT_HTML_TAG_NAME;
1131 
1132     /** Table head tag name. */
1133     public static final int THEAD_HTML_TAG_NAME = JavadocParser.THEAD_HTML_TAG_NAME;
1134 
1135     /** `optgroup` tag name. */
1136     public static final int OPTGROUP_HTML_TAG_NAME = JavadocParser.OPTGROUP_HTML_TAG_NAME;
1137 
1138     /** `rb` tag name. */
1139     public static final int RB_HTML_TAG_NAME = JavadocParser.RB_HTML_TAG_NAME;
1140 
1141     /** `rt` tag name. */
1142     public static final int RT_HTML_TAG_NAME = JavadocParser.RT_HTML_TAG_NAME;
1143 
1144     /** `rtc` tag name. */
1145     public static final int RTC_HTML_TAG_NAME = JavadocParser.RTC_HTML_TAG_NAME;
1146 
1147     /** `rp` tag name. */
1148     public static final int RP_HTML_TAG_NAME = JavadocParser.RP_HTML_TAG_NAME;
1149     ///////////////////////////////////////////////////////////////////////////////////////////////
1150 
1151     /////////////////////// SINGLETON HTML TAGS  //////////////////////////////////////////////////
1152     /** Area tag name. */
1153     public static final int AREA_HTML_TAG_NAME = JavadocParser.AREA_HTML_TAG_NAME;
1154 
1155     /** Base tag name. */
1156     public static final int BASE_HTML_TAG_NAME = JavadocParser.BASE_HTML_TAG_NAME;
1157 
1158     /** Basefont tag name. */
1159     public static final int BASEFONT_HTML_TAG_NAME = JavadocParser.BASEFONT_HTML_TAG_NAME;
1160 
1161     /**
1162      * Br tag name.
1163      *
1164      * <p><b>Example:</b></p>
1165      * <pre>{@code text before break &lt br &gt text after break}</pre>
1166      * <b>Tree:</b>
1167      * <pre>
1168      * {@code
1169      *   JAVADOC -&gt; JAVADOC
1170      *        |--NEWLINE -&gt; \r\n
1171      *        |--LEADING_ASTERISK -&gt;  *
1172      *        |--TEXT -&gt;  text before break
1173      *        |--HTML_ELEMENT -&gt; HTML_ELEMENT
1174      *        |   `--SINGLETON_ELEMENT -&gt; SINGLETON_ELEMENT
1175      *        |       `--BR_TAG -&gt; BR_TAG
1176      *        |           |--START -&gt; -&lt;
1177      *        |           |--BR_HTML_TAG_NAME -&gt; br
1178      *        |           `--END -&gt; &gt;
1179      *        |--TEXT -&gt;  text after break
1180      *        |--NEWLINE -&gt; \r\n
1181      *        |--TEXT -&gt;
1182      * }
1183      * </pre>
1184      */
1185 
1186     public static final int BR_HTML_TAG_NAME = JavadocParser.BR_HTML_TAG_NAME;
1187 
1188     /** Col tag name. */
1189     public static final int COL_HTML_TAG_NAME = JavadocParser.COL_HTML_TAG_NAME;
1190 
1191     /** Frame tag name. */
1192     public static final int FRAME_HTML_TAG_NAME = JavadocParser.FRAME_HTML_TAG_NAME;
1193 
1194     /** Hr tag name. */
1195     public static final int HR_HTML_TAG_NAME = JavadocParser.HR_HTML_TAG_NAME;
1196 
1197     /** Img tag name. */
1198     public static final int IMG_HTML_TAG_NAME = JavadocParser.IMG_HTML_TAG_NAME;
1199 
1200     /** Input tag name. */
1201     public static final int INPUT_HTML_TAG_NAME = JavadocParser.INPUT_HTML_TAG_NAME;
1202 
1203     /** Isindex tag name. */
1204     public static final int ISINDEX_HTML_TAG_NAME = JavadocParser.ISINDEX_HTML_TAG_NAME;
1205 
1206     /** Link tag name. */
1207     public static final int LINK_HTML_TAG_NAME = JavadocParser.LINK_HTML_TAG_NAME;
1208 
1209     /** Meta tag name. */
1210     public static final int META_HTML_TAG_NAME = JavadocParser.META_HTML_TAG_NAME;
1211 
1212     /** Param tag name. */
1213     public static final int PARAM_HTML_TAG_NAME = JavadocParser.PARAM_HTML_TAG_NAME;
1214     /** "embed" tag name. */
1215     public static final int EMBED_HTML_TAG_NAME = JavadocParser.EMBED_HTML_TAG_NAME;
1216     /** "keygen" tag name. */
1217     public static final int KEYGEN_HTML_TAG_NAME = JavadocParser.KEYGEN_HTML_TAG_NAME;
1218     /** "source" tag name. */
1219     public static final int SOURCE_HTML_TAG_NAME = JavadocParser.SOURCE_HTML_TAG_NAME;
1220     /** "track" tag name. */
1221     public static final int TRACK_HTML_TAG_NAME = JavadocParser.TRACK_HTML_TAG_NAME;
1222     /** "wbr" tag name. */
1223     public static final int WBR_HTML_TAG_NAME = JavadocParser.WBR_HTML_TAG_NAME;
1224     ///////////////////////////////////////////////////////////////////////////////////////////////
1225 
1226     /**
1227      * HTML comment start symbol '&lt;&#33;--'.
1228      */
1229     public static final int HTML_COMMENT_START = JavadocParser.HTML_COMMENT_START;
1230 
1231     /**
1232      * HTML comment end symbol '--&gt;'.
1233      */
1234     public static final int HTML_COMMENT_END = JavadocParser.HTML_COMMENT_END;
1235 
1236     // ------------------------------------------------------------------------------------------ //
1237     // -----------------        OTHER          -------------------------------------------------- //
1238     // ------------------------------------------------------------------------------------------ //
1239 
1240     /** Leading asterisk. */
1241     public static final int LEADING_ASTERISK = JavadocParser.LEADING_ASTERISK;
1242 
1243     /**
1244      * Newline symbol - '\n'.
1245      */
1246     public static final int NEWLINE = JavadocParser.NEWLINE;
1247 
1248     /**
1249      * Any other symbol.
1250      */
1251     public static final int CHAR = JavadocParser.CHAR;
1252 
1253     /**
1254      * Whitespace or tab ('\t') symbol.
1255      */
1256     public static final int WS = JavadocParser.WS;
1257 
1258     /**
1259      * End Of File symbol. Copied from
1260      * {@link org.antlr.v4.runtime.Recognizer#EOF} to avoid ANTLR dependency in
1261      * API.
1262      */
1263     public static final int EOF = -1;
1264 
1265     // ------------------------------------------------------------------------------------------ //
1266     // ------ JAVADOC TAGS DEPENDING ON RULE TYPES OFFSET --------------------------------------- //
1267     // ------------------------------------------------------------------------------------------ //
1268 
1269     /**
1270      * Rule types offset.
1271      * RULE_TYPES_OFFSET constant is used to split lexer tokens types and parser rules types.
1272      * We need unique numbers for all tokens,
1273      * ANTLR do not need this and that is why these types are mixed by used values.
1274      * All values we can take a look at
1275      * target/generated-sources/antlr/com/puppycrawl/tools/checkstyle/grammar/javadoc/JavadocParser.java
1276      * For example: LEADING_ASTERISK=1 and RULE_htmlElement = 1.
1277      * RULE_TYPES_OFFSET required to shift parser rules,
1278      * to let them not overlap with types that have prefix "RULE_".
1279      */
1280     private static final int RULE_TYPES_OFFSET = 10000;
1281 
1282     /**
1283      * Root node of any Javadoc comment.
1284      * Last child is always {@link #EOF}.
1285      *
1286      * <p><b>Tree for example:</b></p>
1287      * <pre>{@code
1288      * JAVADOC[3x0]
1289      *   |--NEWLINE[3x0] : [\n]
1290      *   |--LEADING_ASTERISK[4x0] : [ *]
1291      *   |--WS[4x2] : [ ]
1292      *   |--JAVADOC_TAG[4x3] : [@param T The bar.\n ]
1293      *       |--PARAM_LITERAL[4x3] : [@param]
1294      *       |--WS[4x9] : [ ]
1295      *       |--PARAMETER_NAME[4x10] : [T]
1296      *       |--WS[4x11] : [ ]
1297      *       |--DESCRIPTION[4x12] : [The bar.\n ]
1298      *           |--TEXT[4x12] : [The bar.]
1299      *           |--NEWLINE[4x20] : [\n]
1300      *           |--TEXT[5x0] : [ ]
1301      *   |--EOF[5x1] : [<EOF>]
1302      * }</pre>
1303      */
1304     public static final int JAVADOC = JavadocParser.RULE_javadoc + RULE_TYPES_OFFSET;
1305 
1306     /**
1307      * Javadoc tag.
1308      *
1309      * <p>Type of Javadoc tag is resolved by literal node that is first child of this node.</p>
1310      *
1311      * <p>As literal could be:</p>
1312      * <ul>
1313      * <li>{@link #RETURN_LITERAL}</li>
1314      * <li>{@link #DEPRECATED_LITERAL}</li>
1315      * <li>{@link #SINCE_LITERAL}</li>
1316      * <li>{@link #SERIAL_DATA_LITERAL}</li>
1317      * <li>{@link #SERIAL_FIELD_LITERAL}</li>
1318      * <li>{@link #PARAM_LITERAL}</li>
1319      * <li>{@link #SEE_LITERAL}</li>
1320      * <li>{@link #SERIAL_LITERAL}</li>
1321      * <li>{@link #VERSION_LITERAL}</li>
1322      * <li>{@link #EXCEPTION_LITERAL}</li>
1323      * <li>{@link #THROWS_LITERAL}</li>
1324      * <li>{@link #AUTHOR_LITERAL}</li>
1325      * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc tag.</li>
1326      * </ul>
1327      *
1328      * <p><b>Example</b></p>
1329      * <pre>{@code &#64;param T The bar.}</pre>
1330      * <b>Tree</b>
1331      * <pre>{@code
1332      * JAVADOC_TAG -&gt JAVADOC_TAG
1333      *  |--PARAM_LITERAL -&gt @param
1334      *  |--WS -&gt
1335      *  |--PARAMETER_NAME -&gt T
1336      *  |--WS -&gt
1337      *  `--DESCRIPTION -&gt DESCRIPTION
1338      *      |--TEXT -&gt The bar.
1339      *      |--NEWLINE -&gt \r\n
1340      *      `--TEXT -&gt
1341      * }</pre>
1342      */
1343 
1344     public static final int JAVADOC_TAG = JavadocParser.RULE_javadocTag + RULE_TYPES_OFFSET;
1345     /**
1346      * Javadoc inline tag.
1347      *
1348      * <p>Type of Javadoc inline tag is resolved by literal node that is second child of this node.
1349      * First child is always {@link #JAVADOC_INLINE_TAG_START} and last node is always
1350      * {@link #JAVADOC_INLINE_TAG_END}.</p>
1351      *
1352      * <p>As literal could be:</p>
1353      * <ul>
1354      * <li>{@link #CODE_LITERAL}</li>
1355      * <li>{@link #DOC_ROOT_LITERAL}</li>
1356      * <li>{@link #LINK_LITERAL}</li>
1357      * <li>{@link #INHERIT_DOC_LITERAL}</li>
1358      * <li>{@link #LINKPLAIN_LITERAL}</li>
1359      * <li>{@link #LITERAL_LITERAL}</li>
1360      * <li>{@link #VALUE_LITERAL}</li>
1361      * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc inline tag.</li>
1362      * </ul>
1363      *
1364      * <p><b>Example:</b></p>
1365      * <pre><code>{&#64;link String}</code></pre>
1366      * <b>Tree:</b>
1367      * <pre>
1368      * {@code
1369      *  JAVADOC_INLINE_TAG -> JAVADOC_INLINE_TAG
1370      *      |--JAVADOC_INLINE_TAG_START -> {
1371      *      |--LINK_LITERAL -> @link
1372      *      |--WS ->
1373      *      |--REFERENCE -> REFERENCE
1374      *          `--PACKAGE_CLASS -> String
1375      *      `--JAVADOC_INLINE_TAG_END -> }
1376      * }
1377      * </pre>
1378      *
1379      * @noinspection HtmlTagCanBeJavadocTag
1380      * @noinspection HtmlTagCanBeJavadocTag
1381      * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
1382      *      replaced with Javadoc tag
1383      */
1384     public static final int JAVADOC_INLINE_TAG = JavadocParser.RULE_javadocInlineTag
1385             + RULE_TYPES_OFFSET;
1386 
1387     /**
1388      * Parameter of the Javadoc tags listed below.
1389      * <ul>
1390      * <li>{@link #SEE_LITERAL @see}</li>
1391      * <li>{@link #LINK_LITERAL &#123;&#64;link&#125;}</li>
1392      * <li>{@link #LINKPLAIN_LITERAL &#123;&#64;linkplain&#125;}</li>
1393      * <li>{@link #VALUE_LITERAL &#123;&#64;value&#125;}</li>
1394      * </ul>
1395      */
1396     public static final int REFERENCE = JavadocParser.RULE_reference + RULE_TYPES_OFFSET;
1397 
1398     /**
1399      * Parameters part in {@link #REFERENCE}.
1400      * It is used to specify parameters for {@link #MEMBER method}.
1401      * Always contains {@link #LEFT_BRACE} as first child and {@link #RIGHT_BRACE} as last child.
1402      * Each parameter is represented by {@link #ARGUMENT} node.
1403      * Arguments in braces are separated by {@link #COMMA} (and optional {@link #WS}).
1404      *
1405      * <p><b>Example:</b></p>
1406      * <pre>{@code @see #method(Processor, String)}</pre>
1407      * <b>Tree:</b>
1408      * <pre>
1409      * {@code
1410      *      JAVADOC_TAG -> JAVADOC_TAG
1411      *          |--SEE_LITERAL -> @see
1412      *          |--WS ->
1413      *          |--REFERENCE -> REFERENCE
1414      *              |--HASH -> #
1415      *              |--MEMBER -> method
1416      *              `--PARAMETERS -> PARAMETERS
1417      *                  |--LEFT_BRACE -> (
1418      *                  |--ARGUMENT -> Processor
1419      *                  |--COMMA -> ,
1420      *                  |--WS ->
1421      *                  |--ARGUMENT -> String
1422      *                  `--RIGHT_BRACE -> )
1423      * }
1424      * </pre>
1425      */
1426     public static final int PARAMETERS = JavadocParser.RULE_parameters + RULE_TYPES_OFFSET;
1427 
1428     /**
1429      * Description node. It contains:
1430      * <ul>
1431      * <li>{@link #TEXT}</li>
1432      * <li>{@link #WS}</li>
1433      * <li>{@link #NEWLINE}</li>
1434      * <li>{@link #HTML_ELEMENT}</li>
1435      * </ul>
1436      *
1437      * <p>It is argument for many Javadoc tags and inline tags.</p>
1438      *
1439      * <p><b>Example:</b></p>
1440      * <pre>{@code @throws IOException if <b>connection</b> problems occur}</pre>
1441      * <b>Tree:</b>
1442      * <pre>
1443      * {@code
1444      *   JAVADOC_TAG -&gt; JAVADOC_TAG
1445      *        |--THROWS_LITERAL -&gt; @throws
1446      *        |--WS -&gt;
1447      *        |--CLASS_NAME -&gt; IOException
1448      *        |--WS -&gt;
1449      *        `--DESCRIPTION -&gt; DESCRIPTION
1450      *            |--TEXT -&gt; if
1451      *            |--HTML_ELEMENT -&gt; HTML_ELEMENT
1452      *            |    `--HTML_TAG -&gt; HTML_TAG
1453      *            |        |--HTML_ELEMENT_START -&gt; HTML_ELEMENT_START
1454      *            |        |    |--START -&gt; &lt;
1455      *            |        |    |--HTML_TAG_NAME -&gt; b
1456      *            |        |    `--END -&gt; &gt;
1457      *            |        |--TEXT -&gt; connection
1458      *            |        `--HTML_ELEMENT_END -&gt; HTML_ELEMENT_END
1459      *            |            |--START -&gt; -&lt;
1460      *            |            |--SLASH -&gt; /
1461      *            |            |--HTML_TAG_NAME -&gt; b
1462      *            |            `--END -&gt; -&gt;
1463      *            |--TEXT -&gt;  problems occur
1464      * }
1465      * </pre>
1466      */
1467     public static final int DESCRIPTION = JavadocParser.RULE_description + RULE_TYPES_OFFSET;
1468 
1469     // ------------------------------------------------------------------------------------------ //
1470     // -------- HTML TAGS DEPENDING ON RULE TYPES OFFSET ---------------------------------------- //
1471     // ------------------------------------------------------------------------------------------ //
1472 
1473     /**
1474      * Parent node for all html tags.
1475      */
1476     public static final int HTML_ELEMENT = JavadocParser.RULE_htmlElement
1477             + RULE_TYPES_OFFSET;
1478 
1479     /**
1480      * Start html tag: &lt;XXXX&gt;.
1481      */
1482     public static final int HTML_ELEMENT_START = JavadocParser.RULE_htmlElementStart
1483             + RULE_TYPES_OFFSET;
1484 
1485     /**
1486      * End html tag: &lt;XXXX&gt;.
1487      */
1488     public static final int HTML_ELEMENT_END = JavadocParser.RULE_htmlElementEnd
1489             + RULE_TYPES_OFFSET;
1490 
1491     /**
1492      * Non-special HTML tag.
1493      */
1494     public static final int HTML_TAG = JavadocParser.RULE_htmlTag + RULE_TYPES_OFFSET;
1495 
1496     /**
1497      * Html tag attribute. Parent node for: {@code HTML_TAG_IDENT, EQUALS, ATTR_VALUE}.
1498      */
1499     public static final int ATTRIBUTE = JavadocParser.RULE_attribute
1500             + RULE_TYPES_OFFSET;
1501 
1502     /////////////////////// HTML TAGS WITH OPTIONAL END TAG /////////////////////////////////////
1503     /** Paragraph html tag: {@code <p></p>}. */
1504     public static final int PARAGRAPH = JavadocParser.RULE_paragraph + RULE_TYPES_OFFSET;
1505     /** Start paragraph tag. */
1506     public static final int P_TAG_START = JavadocParser.RULE_pTagStart + RULE_TYPES_OFFSET;
1507     /** End paragraph tag. */
1508     public static final int P_TAG_END = JavadocParser.RULE_pTagEnd + RULE_TYPES_OFFSET;
1509     /** List item html tag: {@code <li></li>}. */
1510 
1511     public static final int LI = JavadocParser.RULE_li + RULE_TYPES_OFFSET;
1512     /** Start list item tag. */
1513     public static final int LI_TAG_START = JavadocParser.RULE_liTagStart + RULE_TYPES_OFFSET;
1514     /** End list item tag. */
1515     public static final int LI_TAG_END = JavadocParser.RULE_liTagEnd + RULE_TYPES_OFFSET;
1516 
1517     /**
1518      * Table row html tag.
1519      *
1520      * <p><b>Example:</b></p>
1521      * <pre>{@code <tr></tr>}</pre>
1522      * <b>Tree:</b>
1523      * <pre>
1524      * {@code
1525      *   JAVADOC -> JAVADOC
1526      *        |--NEWLINE -&gt \r\n
1527      *        |--LEADING_ASTERISK -&gt  *
1528      *        |--TEXT -&gt
1529      *        |--HTML_ELEMENT -&gt HTML_ELEMENT
1530      *        |   `--TR -&gt TR
1531      *        |       |--TR_TAG_START -&gt TR_TAG_START
1532      *        |       |   |--START -&gt &lt
1533      *        |       |   |--TR_HTML_TAG_NAME -&gt tr
1534      *        |       |   `--END -&gt &gt
1535      *        |       `--TR_TAG_END -&gt TR_TAG_END
1536      *        |           |--START -&gt &lt
1537      *        |           |--SLASH -&gt /
1538      *        |           |--TR_HTML_TAG_NAME -&gt tr
1539      *        |           `--END -&gt &gt
1540      *        |--NEWLINE -&gt \r\n
1541      *        |--TEXT -&gt
1542      * }
1543      * </pre>
1544      */
1545     public static final int TR = JavadocParser.RULE_tr + RULE_TYPES_OFFSET;
1546     /** Start table row tag. */
1547     public static final int TR_TAG_START = JavadocParser.RULE_trTagStart + RULE_TYPES_OFFSET;
1548     /** End table row tag. */
1549     public static final int TR_TAG_END = JavadocParser.RULE_trTagEnd + RULE_TYPES_OFFSET;
1550 
1551     /** Table cell html tag: {@code <td></td>}. */
1552     public static final int TD = JavadocParser.RULE_td + RULE_TYPES_OFFSET;
1553     /** Start table cell tag. */
1554     public static final int TD_TAG_START = JavadocParser.RULE_tdTagStart + RULE_TYPES_OFFSET;
1555     /** End table cell tag. */
1556     public static final int TD_TAG_END = JavadocParser.RULE_tdTagEnd + RULE_TYPES_OFFSET;
1557 
1558     /** Table header cell html tag: {@code <th></th>}. */
1559     public static final int TH = JavadocParser.RULE_th + RULE_TYPES_OFFSET;
1560     /** Start table header cell tag. */
1561     public static final int TH_TAG_START = JavadocParser.RULE_thTagStart + RULE_TYPES_OFFSET;
1562     /** End table header cell tag. */
1563     public static final int TH_TAG_END = JavadocParser.RULE_thTagEnd + RULE_TYPES_OFFSET;
1564 
1565     /** Body html tag. */
1566     public static final int BODY = JavadocParser.RULE_body + RULE_TYPES_OFFSET;
1567     /** Start body tag. */
1568     public static final int BODY_TAG_START = JavadocParser.RULE_bodyTagStart + RULE_TYPES_OFFSET;
1569     /** End body tag. */
1570     public static final int BODY_TAG_END = JavadocParser.RULE_bodyTagEnd + RULE_TYPES_OFFSET;
1571 
1572     /** Colgroup html tag. */
1573     public static final int COLGROUP = JavadocParser.RULE_colgroup + RULE_TYPES_OFFSET;
1574     /** Start colgroup tag. */
1575     public static final int COLGROUP_TAG_START = JavadocParser.RULE_colgroupTagStart
1576             + RULE_TYPES_OFFSET;
1577     /** End colgroup tag. */
1578     public static final int COLGROUP_TAG_END = JavadocParser.RULE_colgroupTagEnd
1579             + RULE_TYPES_OFFSET;
1580 
1581     /** Description of a term html tag: {@code <dd></dd>}. */
1582     public static final int DD = JavadocParser.RULE_dd + RULE_TYPES_OFFSET;
1583     /** Start description of a term tag. */
1584     public static final int DD_TAG_START = JavadocParser.RULE_ddTagStart + RULE_TYPES_OFFSET;
1585     /** End description of a term tag. */
1586     public static final int DD_TAG_END = JavadocParser.RULE_ddTagEnd + RULE_TYPES_OFFSET;
1587 
1588     /** Description term html tag: {@code <dt></dt>}. */
1589     public static final int DT = JavadocParser.RULE_dt + RULE_TYPES_OFFSET;
1590     /** Start description term tag. */
1591     public static final int DT_TAG_START = JavadocParser.RULE_dtTagStart + RULE_TYPES_OFFSET;
1592     /** End description term tag. */
1593     public static final int DT_TAG_END = JavadocParser.RULE_dtTagEnd + RULE_TYPES_OFFSET;
1594 
1595     /** Head html tag. */
1596     public static final int HEAD = JavadocParser.RULE_head + RULE_TYPES_OFFSET;
1597     /** Start head tag. */
1598     public static final int HEAD_TAG_START = JavadocParser.RULE_headTagStart + RULE_TYPES_OFFSET;
1599     /** End head tag. */
1600     public static final int HEAD_TAG_END = JavadocParser.RULE_headTagEnd + RULE_TYPES_OFFSET;
1601 
1602     /** Html html tag. */
1603     public static final int HTML = JavadocParser.RULE_html + RULE_TYPES_OFFSET;
1604     /** Start html tag. */
1605     public static final int HTML_TAG_START = JavadocParser.RULE_htmlTagStart + RULE_TYPES_OFFSET;
1606     /** End html tag. */
1607     public static final int HTML_TAG_END = JavadocParser.RULE_htmlTagEnd + RULE_TYPES_OFFSET;
1608 
1609     /** Option html tag. */
1610     public static final int OPTION = JavadocParser.RULE_option + RULE_TYPES_OFFSET;
1611     /** Start option tag. */
1612     public static final int OPTION_TAG_START =
1613             JavadocParser.RULE_optionTagStart + RULE_TYPES_OFFSET;
1614     /** End option tag. */
1615     public static final int OPTION_TAG_END = JavadocParser.RULE_optionTagEnd
1616             + RULE_TYPES_OFFSET;
1617 
1618     /** Table body html tag. */
1619     public static final int TBODY = JavadocParser.RULE_tbody + RULE_TYPES_OFFSET;
1620     /** Start table body tag. */
1621     public static final int TBODY_TAG_START = JavadocParser.RULE_tbodyTagStart + RULE_TYPES_OFFSET;
1622     /** End table body tag. */
1623     public static final int TBODY_TAG_END = JavadocParser.RULE_tbodyTagEnd + RULE_TYPES_OFFSET;
1624 
1625     /** Table foot html tag. */
1626     public static final int TFOOT = JavadocParser.RULE_tfoot + RULE_TYPES_OFFSET;
1627     /** Start table foot tag. */
1628     public static final int TFOOT_TAG_START = JavadocParser.RULE_tfootTagStart + RULE_TYPES_OFFSET;
1629     /** End table foot tag. */
1630     public static final int TFOOT_TAG_END = JavadocParser.RULE_tfootTagEnd + RULE_TYPES_OFFSET;
1631 
1632     /** Table head html tag. */
1633     public static final int THEAD = JavadocParser.RULE_thead + RULE_TYPES_OFFSET;
1634     /** Start table head tag. */
1635     public static final int THEAD_TAG_START = JavadocParser.RULE_theadTagStart + RULE_TYPES_OFFSET;
1636     /** End table head tag. */
1637     public static final int THEAD_TAG_END = JavadocParser.RULE_theadTagEnd + RULE_TYPES_OFFSET;
1638 
1639     /** `optgroup` html tag. */
1640     public static final int OPTGROUP = JavadocParser.RULE_optgroup + RULE_TYPES_OFFSET;
1641     /** `optgroup` tag start. */
1642     public static final int OPTGROUP_TAG_START =
1643             JavadocParser.RULE_optgroupTagStart + RULE_TYPES_OFFSET;
1644     /** `optgroup` tag end. */
1645     public static final int OPTGROUP_TAG_END =
1646             JavadocParser.RULE_optgroupTagEnd + RULE_TYPES_OFFSET;
1647 
1648     /** `rb` html tag. */
1649     public static final int RB = JavadocParser.RULE_rb + RULE_TYPES_OFFSET;
1650     /** `rb` tag start. */
1651     public static final int RB_TAG_START =
1652             JavadocParser.RULE_rbTagStart + RULE_TYPES_OFFSET;
1653     /** `rb` tag end. */
1654     public static final int RB_TAG_END =
1655             JavadocParser.RULE_rbTagEnd + RULE_TYPES_OFFSET;
1656 
1657     /** `rt` html tag. */
1658     public static final int RT = JavadocParser.RULE_rt + RULE_TYPES_OFFSET;
1659     /** `rt` tag start. */
1660     public static final int RT_TAG_START =
1661             JavadocParser.RULE_rtTagStart + RULE_TYPES_OFFSET;
1662     /** `rt` tag end. */
1663     public static final int RT_TAG_END =
1664             JavadocParser.RULE_rtTagEnd + RULE_TYPES_OFFSET;
1665 
1666     /** `rtc` html tag. */
1667     public static final int RTC = JavadocParser.RULE_rtc + RULE_TYPES_OFFSET;
1668     /** `rtc` tag start. */
1669     public static final int RTC_TAG_START =
1670             JavadocParser.RULE_rtcTagStart + RULE_TYPES_OFFSET;
1671     /** `rtc` tag end. */
1672     public static final int RTC_TAG_END =
1673             JavadocParser.RULE_rtcTagEnd + RULE_TYPES_OFFSET;
1674 
1675     /** `rp` html tag. */
1676     public static final int RP = JavadocParser.RULE_rp + RULE_TYPES_OFFSET;
1677     /** `rp` tag start. */
1678     public static final int RP_TAG_START =
1679             JavadocParser.RULE_rpTagStart + RULE_TYPES_OFFSET;
1680     /** `rp` tag end. */
1681     public static final int RP_TAG_END =
1682             JavadocParser.RULE_rpTagEnd + RULE_TYPES_OFFSET;
1683 
1684     /////////////////////// SINGLETON HTML TAGS  //////////////////////////////////////////////////
1685     /**
1686      * Parent node for all singleton html tags.
1687      */
1688     public static final int SINGLETON_ELEMENT = JavadocParser.RULE_singletonElement
1689             + RULE_TYPES_OFFSET;
1690 
1691     /**
1692      * Non-special empty html tag.
1693      */
1694     public static final int EMPTY_TAG = JavadocParser.RULE_emptyTag
1695             + RULE_TYPES_OFFSET;
1696 
1697     /** Area html tag. */
1698     public static final int AREA_TAG = JavadocParser.RULE_areaTag + RULE_TYPES_OFFSET;
1699 
1700     /** Base html tag. */
1701     public static final int BASE_TAG = JavadocParser.RULE_baseTag + RULE_TYPES_OFFSET;
1702 
1703     /** Basefont html tag. */
1704     public static final int BASEFONT_TAG = JavadocParser.RULE_basefontTag + RULE_TYPES_OFFSET;
1705 
1706     /** Br html tag. */
1707     public static final int BR_TAG = JavadocParser.RULE_brTag + RULE_TYPES_OFFSET;
1708 
1709     /** Col html tag. */
1710     public static final int COL_TAG = JavadocParser.RULE_colTag + RULE_TYPES_OFFSET;
1711 
1712     /** Frame html tag. */
1713     public static final int FRAME_TAG = JavadocParser.RULE_frameTag + RULE_TYPES_OFFSET;
1714 
1715     /** Hr html tag. */
1716     public static final int HR_TAG = JavadocParser.RULE_hrTag + RULE_TYPES_OFFSET;
1717 
1718     /** Img html tag. */
1719     public static final int IMG_TAG = JavadocParser.RULE_imgTag + RULE_TYPES_OFFSET;
1720 
1721     /** Input html tag. */
1722     public static final int INPUT_TAG = JavadocParser.RULE_inputTag + RULE_TYPES_OFFSET;
1723 
1724     /** Isindex html tag. */
1725     public static final int ISINDEX_TAG = JavadocParser.RULE_isindexTag + RULE_TYPES_OFFSET;
1726 
1727     /** Link html tag. */
1728     public static final int LINK_TAG = JavadocParser.RULE_linkTag + RULE_TYPES_OFFSET;
1729 
1730     /** Meta html tag. */
1731     public static final int META_TAG = JavadocParser.RULE_metaTag + RULE_TYPES_OFFSET;
1732 
1733     /** Param html tag. */
1734     public static final int PARAM_TAG = JavadocParser.RULE_paramTag + RULE_TYPES_OFFSET;
1735 
1736     /**
1737      * HTML void element {@code <embed>}.
1738      *
1739      * @see #SINGLETON_ELEMENT
1740      * @see <a href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-embed">
1741      *     W3 docs</a>
1742      */
1743     public static final int EMBED_TAG = JavadocParser.RULE_embedTag + RULE_TYPES_OFFSET;
1744 
1745     /**
1746      * HTML void element {@code <keygen>}.
1747      *
1748      * @see #SINGLETON_ELEMENT
1749      * @see <a href="https://www.w3.org/TR/html51/sec-forms.html#elementdef-keygen">
1750      *     W3 docs</a>
1751      */
1752     public static final int KEYGEN_TAG = JavadocParser.RULE_keygenTag + RULE_TYPES_OFFSET;
1753 
1754     /**
1755      * HTML void element {@code <source>}.
1756      *
1757      * @see #SINGLETON_ELEMENT
1758      * @see <a href=
1759      *     "https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-media-source">
1760      *     W3 docs</a>
1761      */
1762     public static final int SOURCE_TAG = JavadocParser.RULE_sourceTag + RULE_TYPES_OFFSET;
1763 
1764     /**
1765      * HTML void element {@code <track>}.
1766      *
1767      * @see #SINGLETON_ELEMENT
1768      * @see <a
1769      *     href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-track">
1770      *     W3 docs</a>
1771      */
1772     public static final int TRACK_TAG = JavadocParser.RULE_trackTag + RULE_TYPES_OFFSET;
1773 
1774     /**
1775      * HTML void element {@code <wbr>}.
1776      *
1777      * @see #SINGLETON_ELEMENT
1778      * @see <a href="https://www.w3.org/TR/html51/textlevel-semantics.html#elementdef-wbr">
1779      *     W3 docs</a>
1780      */
1781     public static final int WBR_TAG = JavadocParser.RULE_wbrTag + RULE_TYPES_OFFSET;
1782 
1783     ///////////////////////////////////////////////////////////////////////////////////////////////
1784 
1785     /**
1786      * Html comment: <code>&lt;&#33;-- --&gt;</code>.
1787      *
1788      * @noinspection HtmlTagCanBeJavadocTag
1789      * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
1790      *      replaced with Javadoc tag
1791      */
1792     public static final int HTML_COMMENT = JavadocParser.RULE_htmlComment
1793             + RULE_TYPES_OFFSET;
1794     /**
1795      * CHAR and WS sequence.
1796      */
1797     public static final int TEXT = JavadocParser.RULE_text + RULE_TYPES_OFFSET;
1798 
1799     /** Empty private constructor of the current class. */
1800     private JavadocTokenTypes() {
1801     }
1802 
1803 }