001///////////////////////////////////////////////////////////////////////////////////////////////
002// checkstyle: Checks Java source code and other text files for adherence to a set of rules.
003// Copyright (C) 2001-2024 the original author or authors.
004//
005// This library is free software; you can redistribute it and/or
006// modify it under the terms of the GNU Lesser General Public
007// License as published by the Free Software Foundation; either
008// version 2.1 of the License, or (at your option) any later version.
009//
010// This library is distributed in the hope that it will be useful,
011// but WITHOUT ANY WARRANTY; without even the implied warranty of
012// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
013// Lesser General Public License for more details.
014//
015// You should have received a copy of the GNU Lesser General Public
016// License along with this library; if not, write to the Free Software
017// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
018///////////////////////////////////////////////////////////////////////////////////////////////
019
020package com.puppycrawl.tools.checkstyle.api;
021
022import com.puppycrawl.tools.checkstyle.grammar.javadoc.JavadocParser;
023
024/**
025 * Contains the constants for all the tokens contained in the Abstract
026 * Syntax Tree for the javadoc grammar.
027 *
028 * @see <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html">
029 * javadoc - The Java API Documentation Generator</a>
030 */
031public final class JavadocTokenTypes {
032
033    // ------------------------------------------------------------------------------------------ //
034    // -----------------        JAVADOC TAGS          ------------------------------------------- //
035    // ------------------------------------------------------------------------------------------ //
036
037    /**
038     * '@return' literal in {@code @return} Javadoc tag.
039     *
040     * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p>
041     *
042     * <p><b>Example:</b></p>
043     * <pre>{@code @return true if file exists}</pre>
044     * <b>Tree:</b>
045     * <pre>{@code
046     * JAVADOC_TAG -> JAVADOC_TAG
047     *  |--RETURN_LITERAL -> @return
048     *  |--WS ->
049     *  `--DESCRIPTION -> DESCRIPTION
050     *      |--TEXT -> true if file exists
051     * }</pre>
052     *
053     * @see
054     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCDBGG">
055     * Oracle Docs</a>
056     * @see #JAVADOC_TAG
057     */
058    public static final int RETURN_LITERAL = JavadocParser.RETURN_LITERAL;
059
060    /**
061     * '{@literal @}deprecated' literal in {@literal @}deprecated Javadoc tag.
062     *
063     * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p>
064     *
065     * <p><b>Example:</b></p>
066     * <pre>{@code @deprecated It is deprecated method}</pre>
067     * <b>Tree:</b>
068     * <pre>{@code
069     * JAVADOC_TAG -> JAVADOC_TAG
070     *  |--DEPRECATED_LITERAL -> @deprecated
071     *  |--WS ->
072     *  `--DESCRIPTION -> DESCRIPTION
073     *      |--TEXT -> It is deprecated method
074     * }</pre>
075     *
076     * @see
077     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#deprecated">
078     * Oracle Docs</a>
079     * @see #JAVADOC_TAG
080     */
081    public static final int DEPRECATED_LITERAL = JavadocParser.DEPRECATED_LITERAL;
082
083    /**
084     * '@since' literal in {@code @since} Javadoc tag.
085     *
086     * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p>
087     *
088     * <p><b>Example:</b></p>
089     * <pre>{@code @since 3.4 RELEASE}</pre>
090     * <b>Tree:</b>
091     * <pre>{@code
092     * JAVADOC_TAG -> JAVADOC_TAG
093     *  |--SINCE_LITERAL -> @since
094     *  |--WS ->
095     *  `--DESCRIPTION -> DESCRIPTION
096     *      |--TEXT -> 3.4 RELEASE
097     * }</pre>
098     *
099     * @see
100     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHGJGD">
101     * Oracle Docs</a>
102     * @see #JAVADOC_TAG
103     */
104    public static final int SINCE_LITERAL = JavadocParser.SINCE_LITERAL;
105
106    /**
107     * '@serialData' literal in {@code @serialData} Javadoc tag.
108     *
109     * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p>
110     *
111     * <p><b>Example:</b></p>
112     * <pre>{@code @serialData Two values of Integer type}</pre>
113     * <b>Tree:</b>
114     * <pre>{@code
115     * JAVADOC_TAG -> JAVADOC_TAG
116     *  |--SERIAL_DATA_LITERAL -> @serialData
117     *  |--WS ->
118     *  `--DESCRIPTION -> DESCRIPTION
119     *      |--TEXT -> Two values of Integer type
120     * }
121     * </pre>
122     *
123     * @see
124     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDJBFDB">
125     * Oracle Docs</a>
126     * @see #JAVADOC_TAG
127     */
128    public static final int SERIAL_DATA_LITERAL = JavadocParser.SERIAL_DATA_LITERAL;
129
130    /**
131     * '@serialField' literal in {@code @serialField} Javadoc tag.
132     *
133     * <p>Such Javadoc tag can have three arguments:</p>
134     * <ol>
135     * <li>{@link #FIELD_NAME}</li>
136     * <li>{@link #FIELD_TYPE}</li>
137     * <li>{@link #DESCRIPTION}</li>
138     * </ol>
139     *
140     * <p><b>Example:</b></p>
141     * <pre>{@code @serialField counter Integer objects counter}</pre>
142     * <b>Tree:</b>
143     * <pre>{@code
144     * JAVADOC_TAG -> JAVADOC_TAG
145     *  |--SERIAL_FIELD_LITERAL -> @serialField
146     *  |--WS ->
147     *  |--FIELD_NAME -> counter
148     *  |--WS ->
149     *  |--FIELD_TYPE -> Integer
150     *  |--WS ->
151     *  `--DESCRIPTION -> DESCRIPTION
152     *      |--TEXT -> objects counter
153     * }</pre>
154     *
155     * @see
156     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDGHIDG">
157     * Oracle Docs</a>
158     * @see #JAVADOC_TAG
159     */
160    public static final int SERIAL_FIELD_LITERAL = JavadocParser.SERIAL_FIELD_LITERAL;
161
162    /**
163     * '@param' literal in {@code @param} Javadoc tag.
164     *
165     * <p>Such Javadoc tag can have two arguments:</p>
166     * <ol>
167     * <li>{@link #PARAMETER_NAME}</li>
168     * <li>{@link #DESCRIPTION}</li>
169     * </ol>
170     *
171     * <p><b>Example:</b></p>
172     * <pre>{@code @param value The parameter of method.}</pre>
173     * <b>Tree:</b>
174     * <pre>{@code
175     * JAVADOC_TAG -> JAVADOC_TAG
176     *  |--PARAM_LITERAL -> @param
177     *  |--WS ->
178     *  |--PARAMETER_NAME -> value
179     *  |--WS ->
180     *  `--DESCRIPTION -> DESCRIPTION
181     *      |--TEXT -> The parameter of method.
182     * }</pre>
183     *
184     * @see
185     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHJECF">
186     * Oracle Docs</a>
187     * @see #JAVADOC_TAG
188     */
189    public static final int PARAM_LITERAL = JavadocParser.PARAM_LITERAL;
190
191    /**
192     * '@see' literal in {@code @see} Javadoc tag.
193     *
194     * <p>Such Javadoc tag can have one argument - {@link #REFERENCE}</p>
195     *
196     * <p><b>Example:</b></p>
197     * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre>
198     * <b>Tree:</b>
199     * <pre>{@code
200     *   JAVADOC_TAG -> JAVADOC_TAG
201     *    |--SEE_LITERAL -> @see
202     *    |--WS ->
203     *    |--REFERENCE -> REFERENCE
204     *        |--PACKAGE_CLASS -> org.apache.utils.Lists.Comparator
205     *        |--HASH -> #
206     *        |--MEMBER -> compare
207     *        `--PARAMETERS -> PARAMETERS
208     *            |--LEFT_BRACE -> (
209     *            |--ARGUMENT -> Object
210     *            `--RIGHT_BRACE -> )
211     * }</pre>
212     *
213     * @see
214     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDIEDI">
215     * Oracle Docs</a>
216     * @see #JAVADOC_TAG
217     */
218    public static final int SEE_LITERAL = JavadocParser.SEE_LITERAL;
219
220    /**
221     * '@serial' literal in {@code @serial} Javadoc tag.
222     *
223     * <p>Such Javadoc tag can have one argument - {@link #REFERENCE} or {@link #LITERAL_EXCLUDE}
224     * or {@link #LITERAL_INCLUDE}</p>
225     *
226     * <p><b>Example:</b></p>
227     * <pre>{@code @serial include}</pre>
228     * <b>Tree:</b>
229     * <pre>{@code
230     *   |--JAVADOC_TAG[3x0] : [@serial include]
231     *       |--SERIAL_LITERAL[3x0] : [@serial]
232     *       |--WS[3x7] : [ ]
233     *       |--LITERAL_INCLUDE[3x8] : [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[3x0] : [@serial serialized company name]
241     *       |--SERIAL_LITERAL[3x0] : [@serial]
242     *       |--WS[3x7] : [ ]
243     *       |--DESCRIPTION[3x8] : [serialized company name]
244     *           |--TEXT[3x8] : [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[3x0] : [@throws SQLException if query is not correct]
312     *       |--THROWS_LITERAL[3x0] : [@throws]
313     *       |--WS[3x7] : [ ]
314     *       |--CLASS_NAME[3x8] : [SQLException]
315     *       |--WS[3x20] : [ ]
316     *       |--DESCRIPTION[3x21] : [if query is not correct]
317     *           |--TEXT[3x21] : [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[3x0] : [@myJavadocTag some magic]
361     *       |--CUSTOM_NAME[3x0] : [@myJavadocTag]
362     *       |--WS[3x13] : [ ]
363     *       |--DESCRIPTION[3x14] : [some magic]
364     *           |--TEXT[3x14] : [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[3x0] : [{&#64;code Comparable&lt;E&gt;}]
377     *         |--JAVADOC_INLINE_TAG_START[3x0] : [{]
378     *         |--CODE_LITERAL[3x1] : [@code]
379     *         |--WS[3x6] : [ ]
380     *         |--TEXT[3x7] : [Comparable&lt;E&gt;]
381     *         |--JAVADOC_INLINE_TAG_END[3x21] : [}]
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[3x0] : [{&#64;code Comparable&lt;E&gt;}]
399     *         |--JAVADOC_INLINE_TAG_START[3x0] : [{]
400     *         |--CODE_LITERAL[3x1] : [@code]
401     *         |--WS[3x6] : [ ]
402     *         |--TEXT[3x7] : [Comparable&lt;E&gt;]
403     *         |--JAVADOC_INLINE_TAG_END[3x21] : [}]
404     * </code>
405     * </pre>
406     *
407     * @noinspection HtmlTagCanBeJavadocTag
408     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
409     *      replaced with Javadoc tag
410     */
411    public static final int JAVADOC_INLINE_TAG_END = JavadocParser.JAVADOC_INLINE_TAG_END;
412
413    /**
414     * '@code' literal in {&#64;code} Javadoc inline tag.
415     *
416     * <p>Such Javadoc inline tag can have such child nodes:</p>
417     * <ul>
418     * <li>{@link #NEWLINE}</li>
419     * <li>{@link #WS}</li>
420     * <li>{@link #TEXT}</li>
421     * </ul>
422     *
423     * <p><b>Example:</b></p>
424     * <pre><code>{&#64;code Comparable&lt;E&gt;}</code></pre>
425     * <b>Tree:</b>
426     * <pre>
427     * <code> |--JAVADOC_INLINE_TAG[3x0] : [{&#64;code Comparable&lt;E&gt;}]
428     *         |--JAVADOC_INLINE_TAG_START[3x0] : [{]
429     *         |--CODE_LITERAL[3x1] : [@code]
430     *         |--WS[3x6] : [ ]
431     *         |--TEXT[3x7] : [Comparable&lt;E&gt;]
432     *         |--JAVADOC_INLINE_TAG_END[3x21] : [}]
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     * <p>Such Javadoc inline tag can have one argument - {@link #REFERENCE}</p>
493     * <p><b>Example:</b></p>
494     * <pre><code>{&#64;link org.apache.utils.Lists.Comparator#compare(Object)}</code></pre>
495     * <p><b>Tree:</b></p>
496     * <pre>
497     * <code> |--JAVADOC_INLINE_TAG[1x0] :
498     *               [{&#64;link org.apache.utils.Lists.Comparator#compare(Object)}]
499     *        |--JAVADOC_INLINE_TAG_START[1x0] : [{]
500     *        |--LINK_LITERAL[1x1] : [@link]
501     *        |--WS[1x6] : [ ]
502     *        |--REFERENCE[1x7] : [org.apache.utils.Lists.Comparator#compare(Object)]
503     *            |--PACKAGE_CLASS[1x7] : [org.apache.utils]
504     *            |--DOT[1x23] : [.]
505     *            |--CLASS[1x24] : [Lists]
506     *            |--DOT[1x29] : [.]
507     *            |--CLASS[1x30] : [Comparator]
508     *            |--HASH[1x40] : [#]
509     *            |--MEMBER[1x41] : [compare]
510     *            |--PARAMETERS[1x48] : [(Object)]
511     *                |--LEFT_BRACE[1x48] : [(]
512     *                |--ARGUMENT[1x49] : [Object]
513     *                |--RIGHT_BRACE[1x55] : [)]
514     *        |--JAVADOC_INLINE_TAG_END[1x56] : [}]
515     * </code>
516     * </pre>
517     *
518     * @see
519     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDIECH">
520     * Oracle Docs</a>
521     * @see #JAVADOC_INLINE_TAG
522     * @noinspection HtmlTagCanBeJavadocTag
523     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
524     *      replaced with Javadoc tag
525     */
526    public static final int LINK_LITERAL = JavadocParser.LINK_LITERAL;
527
528    /**
529     * '@inheritDoc' literal in {&#64;inheritDoc} Javadoc inline tag.
530     *
531     * <p>Such Javadoc inline tag does not have any arguments and can have such child nodes:</p>
532     * <ul>
533     * <li>{@link #NEWLINE}</li>
534     * <li>{@link #WS}</li>
535     * </ul>
536     *
537     * <p><b>Example:</b></p>
538     * <pre><code>{&#64;inheritDoc}</code></pre>
539     * <b>Tree:</b>
540     * <pre>
541     * <code>  |--JAVADOC_INLINE_TAG[1x0] : [{&#64;inheritDoc}]
542     *            |--JAVADOC_INLINE_TAG_START[1x0] : [{]
543     *            |--INHERIT_DOC_LITERAL[1x1] : [@inheritDoc]
544     *            |--JAVADOC_INLINE_TAG_END[1x12] : [}]
545     * </code>
546     * </pre>
547     *
548     * @see
549     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDGJCHC">
550     * Oracle Docs</a>
551     * @see #JAVADOC_INLINE_TAG
552     * @noinspection HtmlTagCanBeJavadocTag
553     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
554     *      replaced with Javadoc tag
555     */
556    public static final int INHERIT_DOC_LITERAL = JavadocParser.INHERIT_DOC_LITERAL;
557
558    /**
559     * '@linkplain' literal in {&#64;linkplain} Javadoc inline tag.
560     *
561     * <p>Such Javadoc inline tag can have one argument - {@link #REFERENCE}</p>
562     *
563     * <p><b>Example:</b></p>
564     * <pre><code>{&#64;linkplain org.apache.utils.Lists.Comparator#compare(Object) compare}</code>
565     * </pre>
566     * <b>Tree:</b>
567     * <pre>
568     * <code> |--JAVADOC_INLINE_TAG[1x0] :
569     *               [{&#64;linkplain org.apache.utils.Lists.Comparator#compare(Object) compare}]
570     *        |--JAVADOC_INLINE_TAG_START[1x0] : [{]
571     *        |--LINKPLAIN_LITERAL[1x1] : [@linkplain]
572     *        |--WS[1x11] : [ ]
573     *        |--REFERENCE[1x12] : [org.apache.utils.Lists.Comparator#compare(Object)]
574     *            |--PACKAGE_CLASS[1x12] : [org.apache.utils]
575     *            |--DOT[1x28] : [.]
576     *            |--CLASS[1x29] : [Lists]
577     *            |--DOT[1x34] : [.]
578     *            |--CLASS[1x35] : [Comparator]
579     *            |--HASH[1x45] : [#]
580     *            |--MEMBER[1x46] : [compare]
581     *            |--PARAMETERS[1x53] : [(Object)]
582     *                |--LEFT_BRACE[1x53] : [(]
583     *                |--ARGUMENT[1x54] : [Object]
584     *                |--RIGHT_BRACE[1x60] : [)]
585     *        |--DESCRIPTION[1x61] : [ compare]
586     *            |--TEXT[1x61] : [ compare]
587     *        |--JAVADOC_INLINE_TAG_END[1x69] : [}]
588     * </code>
589     * </pre>
590     *
591     * @see
592     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDGBICD">
593     * Oracle Docs</a>
594     * @see #JAVADOC_INLINE_TAG
595     * @noinspection HtmlTagCanBeJavadocTag
596     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
597     *      replaced with Javadoc tag
598     */
599    public static final int LINKPLAIN_LITERAL = JavadocParser.LINKPLAIN_LITERAL;
600
601    /**
602     * '@literal' literal in {&#64;literal} Javadoc inline tag.
603     *
604     * <p>Such Javadoc inline tag can have such child nodes:</p>
605     * <ul>
606     * <li>{@link #NEWLINE}</li>
607     * <li>{@link #WS}</li>
608     * <li>{@link #TEXT}</li>
609     * </ul>
610     *
611     * <p><b>Example:</b></p>
612     * <pre><code>{&#64;literal #compare(Object)}</code></pre>
613     * <b>Tree:</b>
614     * <pre>
615     * <code> |--JAVADOC_INLINE_TAG[1x0] : [{&#64;literal #compare(Object)}]
616     *        |--JAVADOC_INLINE_TAG_START[1x0] : [{]
617     *        |--LITERAL_LITERAL[1x1] : [@literal]
618     *        |--WS[1x9] : [ ]
619     *        |--TEXT[1x10] : [#compare(Object)]
620     *        |--JAVADOC_INLINE_TAG_END[1x27] : [}]
621     * </code>
622     * </pre>
623     *
624     * @see
625     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCFJDG">
626     * Oracle Docs</a>
627     * @see #JAVADOC_INLINE_TAG
628     * @noinspection HtmlTagCanBeJavadocTag
629     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
630     *      replaced with Javadoc tag
631     */
632    public static final int LITERAL_LITERAL = JavadocParser.LITERAL_LITERAL;
633
634    /**
635     * '@value' literal in {&#64;value} Javadoc inline tag.
636     *
637     * <p>Such Javadoc inline tag has one argument {@link #REFERENCE}
638     * and can have such child nodes:</p>
639     * <ul>
640     * <li>{@link #NEWLINE}</li>
641     * <li>{@link #WS}</li>
642     * </ul>
643     *
644     * <p><b>Example:</b></p>
645     * <pre><code>{&#64;value Integer#MAX_VALUE}</code></pre>
646     * <b>Tree:</b>
647     * <pre>
648     * <code> |--JAVADOC_INLINE_TAG[1x0] : [&#64;value Integer#MAX_VALUE}]
649     *        |--JAVADOC_INLINE_TAG_START[1x0] : [{]
650     *        |--VALUE_LITERAL[1x1] : [@value]
651     *        |--WS[1x7] : [ ]
652     *        |--REFERENCE[1x8] : [Integer#MAX_VALUE]
653     *            |--CLASS[1x8] : [Integer]
654     *            |--HASH[1x15] : [#]
655     *            |--MEMBER[1x16] : [MAX_VALUE]
656     *        |--JAVADOC_INLINE_TAG_END[1x25] : [}]
657     * </code>
658     * </pre>
659     *
660     * @see
661     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDCDHH">
662     * Oracle Docs</a>
663     * @see #JAVADOC_INLINE_TAG
664     * @noinspection HtmlTagCanBeJavadocTag
665     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
666     *      replaced with Javadoc tag
667     */
668    public static final int VALUE_LITERAL = JavadocParser.VALUE_LITERAL;
669
670    /**
671     * PACKAGE_CLASS represents the package or class which has been referenced in the `@see`,
672     * `@link`, `@linkplain` or `@value` javadoc tags. In the javadoc tree it shall be a child
673     * of {@link #REFERENCE}.
674     * <br>
675     * <strong>IMPORTANT:</strong> Constructs like
676     * {@code package.Class.NestedClassAtDepth1.NestedClassAtDepth2#member} are recognized by
677     * the javadoc tool from oracle, and no assumptions like, package names wouldn't consist of
678     * uppercase characters or class names begin with an uppercase character, are made.
679     * Also, <i>the reference</i> in a javadoc tag can consist just a package name or a
680     * simple class name or even a full class name. Thus, PACKAGE_CLASS can represent a
681     * package name or a simple class name or a full class name i.e. checkstyle doesn't
682     * resolve references at present.
683     *
684     * <p><b>Example:</b></p>
685     * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre>
686     * <b>Tree:</b>
687     * <pre>
688     * {@code |--JAVADOC_TAG[3x0] : [@see org.apache.utils.Lists.Comparator#compare(Object)]
689     *        |--SEE_LITERAL[3x0] : [@see]
690     *        |--WS[3x4] : [ ]
691     *        |--REFERENCE[3x5] : [org.apache.utils.Lists.Comparator#compare(Object)]
692     *            |--PACKAGE_CLASS[3x5] : [org.apache.utils]
693     *            |--DOT[3x21] : [.]
694     *            |--CLASS[3x22] : [Lists]
695     *            |--DOT[3x27] : [.]
696     *            |--CLASS[3x28] : [Comparator]
697     *            |--HASH[3x38] : [#]
698     *            |--MEMBER[3x39] : [compare]
699     *            |--PARAMETERS[3x46] : [(Object)]
700     *                |--LEFT_BRACE[3x46] : [(]
701     *                |--ARGUMENT[3x47] : [Object]
702     *                |--RIGHT_BRACE[3x53] : [)]
703     * }
704     * </pre>
705     */
706    public static final int PACKAGE_CLASS = JavadocParser.PACKAGE_CLASS;
707
708    /**
709     * Hash character in {@link #REFERENCE}.
710     * Hash character is used before specifying a class member.
711     *
712     * <p><b>Example:</b></p>
713     * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre>
714     * <b>Tree:</b>
715     * <pre>
716     * {@code |--JAVADOC_TAG[3x0] : [@see org.apache.utils.Lists.Comparator#compare(Object)]
717     *        |--SEE_LITERAL[3x0] : [@see]
718     *        |--WS[3x4] : [ ]
719     *        |--REFERENCE[3x5] : [org.apache.utils.Lists.Comparator#compare(Object)]
720     *            |--PACKAGE_CLASS[3x5] : [org.apache.utils]
721     *            |--DOT[3x21] : [.]
722     *            |--CLASS[3x22] : [Lists]
723     *            |--DOT[3x27] : [.]
724     *            |--CLASS[3x28] : [Comparator]
725     *            |--HASH[3x38] : [#]
726     *            |--MEMBER[3x39] : [compare]
727     *            |--PARAMETERS[3x46] : [(Object)]
728     *                |--LEFT_BRACE[3x46] : [(]
729     *                |--ARGUMENT[3x47] : [Object]
730     *                |--RIGHT_BRACE[3x53] : [)]
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 |--JAVADOC_TAG[3x0] : [@see org.apache.utils.Lists.Comparator#compare(Object)]
745     *        |--SEE_LITERAL[3x0] : [@see]
746     *        |--WS[3x4] : [ ]
747     *        |--REFERENCE[3x5] : [org.apache.utils.Lists.Comparator#compare(Object)]
748     *            |--PACKAGE_CLASS[3x5] : [org.apache.utils]
749     *            |--DOT[3x21] : [.]
750     *            |--CLASS[3x22] : [Lists]
751     *            |--DOT[3x27] : [.]
752     *            |--CLASS[3x28] : [Comparator]
753     *            |--HASH[3x38] : [#]
754     *            |--MEMBER[3x39] : [compare]
755     *            |--PARAMETERS[3x46] : [(Object)]
756     *                |--LEFT_BRACE[3x46] : [(]
757     *                |--ARGUMENT[3x47] : [Object]
758     *                |--RIGHT_BRACE[3x53] : [)]
759     * }
760     * </pre>
761     */
762    public static final int MEMBER = JavadocParser.MEMBER;
763
764    /**
765     * Left brace in {@link #PARAMETERS} part of {@link #REFERENCE}.
766     *
767     * <p><b>Example:</b></p>
768     * <pre>{@code @see #method(Processor, String)}</pre>
769     * <b>Tree:</b>
770     * <pre>
771     * {@code |--JAVADOC_TAG[1x0] : [@see #method(Processor, String)]
772     *        |--SEE_LITERAL[1x0] : [@see]
773     *        |--WS[1x4] : [ ]
774     *        |--REFERENCE[1x5] : [#method(Processor, String)]
775     *            |--HASH[1x5] : [#]
776     *            |--MEMBER[1x6] : [method]
777     *            |--PARAMETERS[1x12] : [(Processor, String)]
778     *                |--LEFT_BRACE[1x12] : [(]
779     *                |--ARGUMENT[1x13] : [Processor]
780     *                |--COMMA[1x22] : [,]
781     *                |--WS[1x23] : [ ]
782     *                |--ARGUMENT[1x24] : [String]
783     *                |--RIGHT_BRACE[1x30] : [)]
784     * }
785     * </pre>
786     */
787    public static final int LEFT_BRACE = JavadocParser.LEFT_BRACE;
788
789    /**
790     * Right brace in {@link #PARAMETERS} part of {@link #REFERENCE}.
791     *
792     * <p><b>Example:</b></p>
793     * <pre>{@code @see #method(Processor, String)}</pre>
794     * <b>Tree:</b>
795     * <pre>
796     * {@code |--JAVADOC_TAG[1x0] : [@see #method(Processor, String)]
797     *        |--SEE_LITERAL[1x0] : [@see]
798     *        |--WS[1x4] : [ ]
799     *        |--REFERENCE[1x5] : [#method(Processor, String)]
800     *            |--HASH[1x5] : [#]
801     *            |--MEMBER[1x6] : [method]
802     *            |--PARAMETERS[1x12] : [(Processor, String)]
803     *                |--LEFT_BRACE[1x12] : [(]
804     *                |--ARGUMENT[1x13] : [Processor]
805     *                |--COMMA[1x22] : [,]
806     *                |--WS[1x23] : [ ]
807     *                |--ARGUMENT[1x24] : [String]
808     *                |--RIGHT_BRACE[1x30] : [)]
809     * }
810     * </pre>
811     */
812    public static final int RIGHT_BRACE = JavadocParser.RIGHT_BRACE;
813
814    /**
815     * Argument definition in {@link #PARAMETERS} part of {@link #REFERENCE}.
816     *
817     * <p><b>Example:</b></p>
818     * <pre>{@code @see #method(Processor, String)}</pre>
819     * <b>Tree:</b>
820     * <pre>
821     * {@code |--JAVADOC_TAG[1x0] : [@see #method(Processor, String)]
822     *        |--SEE_LITERAL[1x0] : [@see]
823     *        |--WS[1x4] : [ ]
824     *        |--REFERENCE[1x5] : [#method(Processor, String)]
825     *            |--HASH[1x5] : [#]
826     *            |--MEMBER[1x6] : [method]
827     *            |--PARAMETERS[1x12] : [(Processor, String)]
828     *                |--LEFT_BRACE[1x12] : [(]
829     *                |--ARGUMENT[1x13] : [Processor]
830     *                |--COMMA[1x22] : [,]
831     *                |--WS[1x23] : [ ]
832     *                |--ARGUMENT[1x24] : [String]
833     *                |--RIGHT_BRACE[1x30] : [)]
834     * }
835     * </pre>
836     */
837    public static final int ARGUMENT = JavadocParser.ARGUMENT;
838
839    /**
840     * Comma separator between parameters in {@link #PARAMETERS} part of {@link #REFERENCE}.
841     *
842     * <p><b>Example:</b></p>
843     * <pre>{@code @see #method(Processor, String)}</pre>
844     * <b>Tree:</b>
845     * <pre>
846     * {@code |--JAVADOC_TAG[1x0] : [@see #method(Processor, String)]
847     *        |--SEE_LITERAL[1x0] : [@see]
848     *        |--WS[1x4] : [ ]
849     *        |--REFERENCE[1x5] : [#method(Processor, String)]
850     *            |--HASH[1x5] : [#]
851     *            |--MEMBER[1x6] : [method]
852     *            |--PARAMETERS[1x12] : [(Processor, String)]
853     *                |--LEFT_BRACE[1x12] : [(]
854     *                |--ARGUMENT[1x13] : [Processor]
855     *                |--COMMA[1x22] : [,]
856     *                |--WS[1x23] : [ ]
857     *                |--ARGUMENT[1x24] : [String]
858     *                |--RIGHT_BRACE[1x30] : [)]
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 |--JAVADOC_TAG[1x0] : [@see "Spring Framework"]
877     *        |--SEE_LITERAL[1x0] : [@see]
878     *        |--WS[1x4] : [ ]
879     *        |--STRING[1x5] : ["Spring Framework"]
880     * }
881     * </pre>
882     *
883     * @see #SEE_LITERAL
884     */
885    public static final int STRING = JavadocParser.STRING;
886
887    /**
888     * Exception class name. First argument in {@link #THROWS_LITERAL @throws} and
889     * {@link #EXCEPTION_LITERAL @exception} Javadoc tags.
890     *
891     * <p><b>Example:</b></p>
892     * <pre>{@code @throws IOException connection problems}</pre>
893     * <b>Tree:</b>
894     * <pre>
895     * {@code |--JAVADOC_TAG[1x0] : [@throws IOException connection problems]
896     *        |--THROWS_LITERAL[1x0] : [@throws]
897     *        |--WS[1x7] : [ ]
898     *        |--CLASS_NAME[1x8] : [IOException]
899     *        |--WS[1x19] : [ ]
900     *        |--DESCRIPTION[1x20] : [connection problems]
901     *            |--TEXT[1x20] : [connection problems]
902     * }
903     * </pre>
904     *
905     * @see #EXCEPTION_LITERAL
906     * @see #THROWS_LITERAL
907     */
908    public static final int CLASS_NAME = JavadocParser.CLASS_NAME;
909
910    /**
911     * First argument in {@link #PARAM_LITERAL @param} Javadoc tag.
912     *
913     * <p><b>Example:</b></p>
914     * <pre>{@code @param T The bar.}</pre>
915     * <b>Tree:</b>
916     * <pre>
917     * {@code |--JAVADOC_TAG[4x3] : [@param T The bar.]
918     *        |--PARAM_LITERAL[4x3] : [@param]
919     *        |--WS[4x9] : [ ]
920     *        |--PARAMETER_NAME[4x10] : [T]
921     *        |--WS[4x11] : [ ]
922     *        |--DESCRIPTION[4x12] : [The bar.]
923     *            |--TEXT[4x12] : [The bar.]
924     * }
925     * </pre>
926     *
927     * @see
928     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHJECF">
929     * Oracle Docs</a>
930     * @see #PARAM_LITERAL
931     */
932    public static final int PARAMETER_NAME = JavadocParser.PARAMETER_NAME;
933
934    /**
935     * 'exclude' literal.
936     * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments.
937     *
938     * <p><b>Example:</b></p>
939     * <pre>{@code @serial exclude}</pre>
940     * <b>Tree:</b>
941     * <pre>
942     * {@code |--JAVADOC_TAG[1x0] : [@serial exclude]
943     *        |--SERIAL_LITERAL[1x0] : [@serial]
944     *        |--WS[1x7] : [ ]
945     *        |--LITERAL_EXCLUDE[1x8] : [exclude]
946     * }
947     * </pre>
948     *
949     * @see
950     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
951     * Oracle Docs</a>
952     * @see #SERIAL_LITERAL
953     */
954    public static final int LITERAL_EXCLUDE = JavadocParser.LITERAL_EXCLUDE;
955
956    /**
957     * 'include' literal.
958     * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments.
959     *
960     * <p><b>Example:</b></p>
961     * <pre>{@code @serial include}</pre>
962     * <b>Tree:</b>
963     * <pre>
964     * {@code |--JAVADOC_TAG[1x0] : [@serial include]
965     *        |--SERIAL_LITERAL[1x0] : [@serial]
966     *        |--WS[1x7] : [ ]
967     *        |--LITERAL_INCLUDE[1x8] : [include]
968     * }
969     * </pre>
970     *
971     * @see
972     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
973     * Oracle Docs</a>
974     * @see #SERIAL_LITERAL
975     */
976    public static final int LITERAL_INCLUDE = JavadocParser.LITERAL_INCLUDE;
977
978    /**
979     * Field name. First argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag.
980     *
981     * <p><b>Example:</b></p>
982     * <pre>{@code @serialField counter Integer objects counter}</pre>
983     * <b>Tree:</b>
984     * <pre>
985     * {@code |--JAVADOC_TAG[3x0] : [@serialField counter Integer objects counter]
986     *        |--SERIAL_FIELD_LITERAL[3x0] : [@serialField]
987     *        |--WS[3x12] : [ ]
988     *        |--FIELD_NAME[3x13] : [counter]
989     *        |--WS[3x20] : [ ]
990     *        |--FIELD_TYPE[3x21] : [Integer]
991     *        |--WS[3x28] : [ ]
992     *        |--DESCRIPTION[3x29] : [objects counter]
993     *            |--TEXT[3x29] : [objects counter]
994     * }
995     * </pre>
996     *
997     * @see
998     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
999     * Oracle Docs</a>
1000     * @see #SERIAL_FIELD_LITERAL
1001     */
1002    public static final int FIELD_NAME = JavadocParser.FIELD_NAME;
1003
1004    /**
1005     * Field type. Second argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag.
1006     *
1007     * <p><b>Example:</b></p>
1008     * <pre>{@code @serialField counter Integer objects counter}</pre>
1009     * <b>Tree:</b>
1010     * <pre>
1011     * {@code |--JAVADOC_TAG[3x0] : [@serialField counter Integer objects counter]
1012     *        |--SERIAL_FIELD_LITERAL[3x0] : [@serialField]
1013     *        |--WS[3x12] : [ ]
1014     *        |--FIELD_NAME[3x13] : [counter]
1015     *        |--WS[3x20] : [ ]
1016     *        |--FIELD_TYPE[3x21] : [Integer]
1017     *        |--WS[3x28] : [ ]
1018     *        |--DESCRIPTION[3x29] : [objects counter]
1019     *            |--TEXT[3x29] : [objects counter]
1020     * }
1021     * </pre>
1022     *
1023     * @see
1024     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
1025     * Oracle Docs</a>
1026     * @see #SERIAL_FIELD_LITERAL
1027     */
1028    public static final int FIELD_TYPE = JavadocParser.FIELD_TYPE;
1029
1030    // ------------------------------------------------------------------------------------------ //
1031    // -----------------        HTML TAGS          ---------------------------------------------- //
1032    // ------------------------------------------------------------------------------------------ //
1033
1034    /**
1035     * Identifier inside HTML tag: tag name or attribute name.
1036     */
1037    public static final int HTML_TAG_NAME = JavadocParser.HTML_TAG_NAME;
1038
1039    // HTML tag components
1040
1041    /**
1042     * Start html tag component: {@code '<'}.
1043     */
1044    public static final int START = JavadocParser.START;
1045
1046    /**
1047     * Slash html tag component: {@code '/'}.
1048     */
1049    public static final int SLASH = JavadocParser.SLASH;
1050
1051    /**
1052     * End html tag component: {@code '>'}.
1053     */
1054    public static final int END = JavadocParser.END;
1055
1056    /**
1057     * Slash close html tag component: {@code '/>'}.
1058     */
1059    public static final int SLASH_END = JavadocParser.SLASH_END;
1060
1061    /**
1062     * Equals html tag component: {@code '='}.
1063     */
1064    public static final int EQUALS = JavadocParser.EQUALS;
1065
1066    /**
1067     * Attribute value html tag component.
1068     */
1069    public static final int ATTR_VALUE = JavadocParser.ATTR_VALUE;
1070
1071    /////////////////////// HTML TAGS WITH OPTIONAL END TAG /////////////////////////////////////
1072    /** Paragraph tag name. */
1073    public static final int P_HTML_TAG_NAME = JavadocParser.P_HTML_TAG_NAME;
1074
1075    /** List item tag name. */
1076    public static final int LI_HTML_TAG_NAME = JavadocParser.LI_HTML_TAG_NAME;
1077
1078    /** Table row tag name. */
1079    public static final int TR_HTML_TAG_NAME = JavadocParser.TR_HTML_TAG_NAME;
1080
1081    /** Table cell tag name. */
1082    public static final int TD_HTML_TAG_NAME = JavadocParser.TD_HTML_TAG_NAME;
1083
1084    /** Table header cell tag name. */
1085    public static final int TH_HTML_TAG_NAME = JavadocParser.TH_HTML_TAG_NAME;
1086
1087    /** Body tag name. */
1088    public static final int BODY_HTML_TAG_NAME = JavadocParser.BODY_HTML_TAG_NAME;
1089
1090    /** Colgroup tag name. */
1091    public static final int COLGROUP_HTML_TAG_NAME = JavadocParser.COLGROUP_HTML_TAG_NAME;
1092
1093    /** Description of a term tag name. */
1094    public static final int DD_HTML_TAG_NAME = JavadocParser.DD_HTML_TAG_NAME;
1095
1096    /** Description term tag name. */
1097    public static final int DT_HTML_TAG_NAME = JavadocParser.DT_HTML_TAG_NAME;
1098
1099    /** Head tag name. */
1100    public static final int HEAD_HTML_TAG_NAME = JavadocParser.HEAD_HTML_TAG_NAME;
1101
1102    /** Html tag name. */
1103    public static final int HTML_HTML_TAG_NAME = JavadocParser.HTML_HTML_TAG_NAME;
1104
1105    /** Option tag name. */
1106    public static final int OPTION_HTML_TAG_NAME = JavadocParser.OPTION_HTML_TAG_NAME;
1107
1108    /** Table body tag name. */
1109    public static final int TBODY_HTML_TAG_NAME = JavadocParser.TBODY_HTML_TAG_NAME;
1110
1111    /** Table foot tag name. */
1112    public static final int TFOOT_HTML_TAG_NAME = JavadocParser.TFOOT_HTML_TAG_NAME;
1113
1114    /** Table head tag name. */
1115    public static final int THEAD_HTML_TAG_NAME = JavadocParser.THEAD_HTML_TAG_NAME;
1116
1117    /** `optgroup` tag name. */
1118    public static final int OPTGROUP_HTML_TAG_NAME = JavadocParser.OPTGROUP_HTML_TAG_NAME;
1119
1120    /** `rb` tag name. */
1121    public static final int RB_HTML_TAG_NAME = JavadocParser.RB_HTML_TAG_NAME;
1122
1123    /** `rt` tag name. */
1124    public static final int RT_HTML_TAG_NAME = JavadocParser.RT_HTML_TAG_NAME;
1125
1126    /** `rtc` tag name. */
1127    public static final int RTC_HTML_TAG_NAME = JavadocParser.RTC_HTML_TAG_NAME;
1128
1129    /** `rp` tag name. */
1130    public static final int RP_HTML_TAG_NAME = JavadocParser.RP_HTML_TAG_NAME;
1131    ///////////////////////////////////////////////////////////////////////////////////////////////
1132
1133    /////////////////////// SINGLETON HTML TAGS  //////////////////////////////////////////////////
1134    /** Area tag name. */
1135    public static final int AREA_HTML_TAG_NAME = JavadocParser.AREA_HTML_TAG_NAME;
1136
1137    /** Base tag name. */
1138    public static final int BASE_HTML_TAG_NAME = JavadocParser.BASE_HTML_TAG_NAME;
1139
1140    /** Basefont tag name. */
1141    public static final int BASEFONT_HTML_TAG_NAME = JavadocParser.BASEFONT_HTML_TAG_NAME;
1142
1143    /** Br tag name. */
1144    public static final int BR_HTML_TAG_NAME = JavadocParser.BR_HTML_TAG_NAME;
1145
1146    /** Col tag name. */
1147    public static final int COL_HTML_TAG_NAME = JavadocParser.COL_HTML_TAG_NAME;
1148
1149    /** Frame tag name. */
1150    public static final int FRAME_HTML_TAG_NAME = JavadocParser.FRAME_HTML_TAG_NAME;
1151
1152    /** Hr tag name. */
1153    public static final int HR_HTML_TAG_NAME = JavadocParser.HR_HTML_TAG_NAME;
1154
1155    /** Img tag name. */
1156    public static final int IMG_HTML_TAG_NAME = JavadocParser.IMG_HTML_TAG_NAME;
1157
1158    /** Input tag name. */
1159    public static final int INPUT_HTML_TAG_NAME = JavadocParser.INPUT_HTML_TAG_NAME;
1160
1161    /** Isindex tag name. */
1162    public static final int ISINDEX_HTML_TAG_NAME = JavadocParser.ISINDEX_HTML_TAG_NAME;
1163
1164    /** Link tag name. */
1165    public static final int LINK_HTML_TAG_NAME = JavadocParser.LINK_HTML_TAG_NAME;
1166
1167    /** Meta tag name. */
1168    public static final int META_HTML_TAG_NAME = JavadocParser.META_HTML_TAG_NAME;
1169
1170    /** Param tag name. */
1171    public static final int PARAM_HTML_TAG_NAME = JavadocParser.PARAM_HTML_TAG_NAME;
1172    /** "embed" tag name. */
1173    public static final int EMBED_HTML_TAG_NAME = JavadocParser.EMBED_HTML_TAG_NAME;
1174    /** "keygen" tag name. */
1175    public static final int KEYGEN_HTML_TAG_NAME = JavadocParser.KEYGEN_HTML_TAG_NAME;
1176    /** "source" tag name. */
1177    public static final int SOURCE_HTML_TAG_NAME = JavadocParser.SOURCE_HTML_TAG_NAME;
1178    /** "track" tag name. */
1179    public static final int TRACK_HTML_TAG_NAME = JavadocParser.TRACK_HTML_TAG_NAME;
1180    /** "wbr" tag name. */
1181    public static final int WBR_HTML_TAG_NAME = JavadocParser.WBR_HTML_TAG_NAME;
1182    ///////////////////////////////////////////////////////////////////////////////////////////////
1183
1184    /**
1185     * HTML comment start symbol '&lt;&#33;--'.
1186     */
1187    public static final int HTML_COMMENT_START = JavadocParser.HTML_COMMENT_START;
1188
1189    /**
1190     * HTML comment end symbol '--&gt;'.
1191     */
1192    public static final int HTML_COMMENT_END = JavadocParser.HTML_COMMENT_END;
1193
1194    // ------------------------------------------------------------------------------------------ //
1195    // -----------------        OTHER          -------------------------------------------------- //
1196    // ------------------------------------------------------------------------------------------ //
1197
1198    /** Leading asterisk. */
1199    public static final int LEADING_ASTERISK = JavadocParser.LEADING_ASTERISK;
1200
1201    /**
1202     * Newline symbol - '\n'.
1203     */
1204    public static final int NEWLINE = JavadocParser.NEWLINE;
1205
1206    /**
1207     * Any other symbol.
1208     */
1209    public static final int CHAR = JavadocParser.CHAR;
1210
1211    /**
1212     * Whitespace or tab ('\t') symbol.
1213     */
1214    public static final int WS = JavadocParser.WS;
1215
1216    /**
1217     * End Of File symbol. Copied from
1218     * {@link org.antlr.v4.runtime.Recognizer#EOF} to avoid ANTLR dependency in
1219     * API.
1220     */
1221    public static final int EOF = -1;
1222
1223    // ------------------------------------------------------------------------------------------ //
1224    // ------ JAVADOC TAGS DEPENDING ON RULE TYPES OFFSET --------------------------------------- //
1225    // ------------------------------------------------------------------------------------------ //
1226
1227    /**
1228     * Rule types offset.
1229     * RULE_TYPES_OFFSET constant is used to split lexer tokens types and parser rules types.
1230     * We need unique numbers for all tokens,
1231     * ANTLR do not need this and that is why these types are mixed by used values.
1232     * All values we can take a look at
1233     * target/generated-sources/antlr/com/puppycrawl/tools/checkstyle/grammar/javadoc/JavadocParser.java
1234     * For example: LEADING_ASTERISK=1 and RULE_htmlElement = 1.
1235     * RULE_TYPES_OFFSET required to shift parser rules,
1236     * to let them not overlap with types that have prefix "RULE_".
1237     */
1238    private static final int RULE_TYPES_OFFSET = 10000;
1239
1240    /**
1241     * Root node of any Javadoc comment.
1242     * Last child is always {@link #EOF}.
1243     *
1244     * <p><b>Tree for example:</b></p>
1245     * <pre>{@code
1246     * JAVADOC[3x0]
1247     *   |--NEWLINE[3x0] : [\n]
1248     *   |--LEADING_ASTERISK[4x0] : [ *]
1249     *   |--WS[4x2] : [ ]
1250     *   |--JAVADOC_TAG[4x3] : [@param T The bar.\n ]
1251     *       |--PARAM_LITERAL[4x3] : [@param]
1252     *       |--WS[4x9] : [ ]
1253     *       |--PARAMETER_NAME[4x10] : [T]
1254     *       |--WS[4x11] : [ ]
1255     *       |--DESCRIPTION[4x12] : [The bar.\n ]
1256     *           |--TEXT[4x12] : [The bar.]
1257     *           |--NEWLINE[4x20] : [\n]
1258     *           |--TEXT[5x0] : [ ]
1259     *   |--EOF[5x1] : [<EOF>]
1260     * }</pre>
1261     */
1262    public static final int JAVADOC = JavadocParser.RULE_javadoc + RULE_TYPES_OFFSET;
1263
1264    /**
1265     * Javadoc tag.
1266     *
1267     * <p>Type of Javadoc tag is resolved by literal node that is first child of this node.</p>
1268     *
1269     * <p>As literal could be:</p>
1270     * <ul>
1271     * <li>{@link #RETURN_LITERAL}</li>
1272     * <li>{@link #DEPRECATED_LITERAL}</li>
1273     * <li>{@link #SINCE_LITERAL}</li>
1274     * <li>{@link #SERIAL_DATA_LITERAL}</li>
1275     * <li>{@link #SERIAL_FIELD_LITERAL}</li>
1276     * <li>{@link #PARAM_LITERAL}</li>
1277     * <li>{@link #SEE_LITERAL}</li>
1278     * <li>{@link #SERIAL_LITERAL}</li>
1279     * <li>{@link #VERSION_LITERAL}</li>
1280     * <li>{@link #EXCEPTION_LITERAL}</li>
1281     * <li>{@link #THROWS_LITERAL}</li>
1282     * <li>{@link #AUTHOR_LITERAL}</li>
1283     * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc tag.</li>
1284     * </ul>
1285     *
1286     * <p><b>Example</b></p>
1287     * <pre>{@code &#64;param T The bar.}</pre>
1288     * <b>Tree</b>
1289     * <pre>{@code
1290     *   |--JAVADOC_TAG[4x3] : [@param T The bar.]
1291     *       |--PARAM_LITERAL[4x3] : [@param]
1292     *       |--WS[4x9] : [ ]
1293     *       |--PARAMETER_NAME[4x10] : [T]
1294     *       |--WS[4x11] : [ ]
1295     *       |--DESCRIPTION[4x12] : [The bar.]
1296     *           |--TEXT[4x12] : [The bar.]
1297     * }</pre>
1298     */
1299
1300    public static final int JAVADOC_TAG = JavadocParser.RULE_javadocTag + RULE_TYPES_OFFSET;
1301    /**
1302     * Javadoc inline tag.
1303     *
1304     * <p>Type of Javadoc inline tag is resolved by literal node that is second child of this node.
1305     * First child is always {@link #JAVADOC_INLINE_TAG_START} and last node is always
1306     * {@link #JAVADOC_INLINE_TAG_END}.</p>
1307     *
1308     * <p>As literal could be:</p>
1309     * <ul>
1310     * <li>{@link #CODE_LITERAL}</li>
1311     * <li>{@link #DOC_ROOT_LITERAL}</li>
1312     * <li>{@link #LINK_LITERAL}</li>
1313     * <li>{@link #INHERIT_DOC_LITERAL}</li>
1314     * <li>{@link #LINKPLAIN_LITERAL}</li>
1315     * <li>{@link #LITERAL_LITERAL}</li>
1316     * <li>{@link #VALUE_LITERAL}</li>
1317     * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc inline tag.</li>
1318     * </ul>
1319     *
1320     * <p><b>Example:</b></p>
1321     * <pre><code>{&#64;link String}</code></pre>
1322     * <b>Tree:</b>
1323     * <pre>
1324     * <code> |--JAVADOC_INLINE_TAG[4x3] : [&#64;link String}]
1325     *        |--JAVADOC_INLINE_TAG_START[4x3] : [{]
1326     *        |--LINK_LITERAL[4x4] : [@link]
1327     *        |--WS[4x9] : [ ]
1328     *        |--REFERENCE[4x10] : [String]
1329     *            |--CLASS[4x10] : [String]
1330     *        |--JAVADOC_INLINE_TAG_END[4x16] : [}]
1331     * </code>
1332     * </pre>
1333     *
1334     * @noinspection HtmlTagCanBeJavadocTag
1335     * @noinspection HtmlTagCanBeJavadocTag
1336     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
1337     *      replaced with Javadoc tag
1338     */
1339    public static final int JAVADOC_INLINE_TAG = JavadocParser.RULE_javadocInlineTag
1340            + RULE_TYPES_OFFSET;
1341
1342    /**
1343     * Parameter of the Javadoc tags listed below.
1344     * <ul>
1345     * <li>{@link #SEE_LITERAL @see}</li>
1346     * <li>{@link #LINK_LITERAL &#123;&#64;link&#125;}</li>
1347     * <li>{@link #LINKPLAIN_LITERAL &#123;&#64;linkplain&#125;}</li>
1348     * <li>{@link #VALUE_LITERAL &#123;&#64;value&#125;}</li>
1349     * </ul>
1350     */
1351    public static final int REFERENCE = JavadocParser.RULE_reference + RULE_TYPES_OFFSET;
1352
1353    /**
1354     * Parameters part in {@link #REFERENCE}.
1355     * It is used to specify parameters for {@link #MEMBER method}.
1356     * Always contains {@link #LEFT_BRACE} as first child and {@link #RIGHT_BRACE} as last child.
1357     * Each parameter is represented by {@link #ARGUMENT} node.
1358     * Arguments in braces are separated by {@link #COMMA} (and optional {@link #WS}).
1359     *
1360     * <p><b>Example:</b></p>
1361     * <pre>{@code @see #method(Processor, String)}</pre>
1362     * <b>Tree:</b>
1363     * <pre>
1364     * {@code |--JAVADOC_TAG[1x0] : [@see #method(Processor, String)]
1365     *        |--SEE_LITERAL[1x0] : [@see]
1366     *        |--WS[1x4] : [ ]
1367     *        |--REFERENCE[1x5] : [#method(Processor, String)]
1368     *            |--HASH[1x5] : [#]
1369     *            |--MEMBER[1x6] : [method]
1370     *            |--PARAMETERS[1x12] : [(Processor, String)]
1371     *                |--LEFT_BRACE[1x12] : [(]
1372     *                |--ARGUMENT[1x13] : [Processor]
1373     *                |--COMMA[1x22] : [,]
1374     *                |--WS[1x23] : [ ]
1375     *                |--ARGUMENT[1x24] : [String]
1376     *                |--RIGHT_BRACE[1x30] : [)]
1377     * }
1378     * </pre>
1379     */
1380    public static final int PARAMETERS = JavadocParser.RULE_parameters + RULE_TYPES_OFFSET;
1381
1382    /**
1383     * Description node. It contains:
1384     * <ul>
1385     * <li>{@link #TEXT}</li>
1386     * <li>{@link #WS}</li>
1387     * <li>{@link #NEWLINE}</li>
1388     * <li>{@link #HTML_ELEMENT}</li>
1389     * </ul>
1390     *
1391     * <p>It is argument for many Javadoc tags and inline tags.</p>
1392     *
1393     * <p><b>Example:</b></p>
1394     * <pre>{@code @throws IOException if <b>connection</b> problems occur}</pre>
1395     * <b>Tree:</b>
1396     * <pre>
1397     * {@code |--JAVADOC_TAG[1x0] : [@throws IOException if <b>connection</b> problems occur]
1398     *        |--THROWS_LITERAL[1x0] : [@throws]
1399     *        |--WS[1x7] : [ ]
1400     *        |--CLASS_NAME[1x8] : [IOException]
1401     *        |--WS[1x19] : [ ]
1402     *        |--DESCRIPTION[1x20] : [if <b>connection</b> problems occur]
1403     *            |--TEXT[1x20] : [if ]
1404     *            |--HTML_ELEMENT[1x23] : [<b>connection</b>]
1405     *                |--HTML_TAG[1x23] : [<b>connection</b>]
1406     *                    |--HTML_ELEMENT_START[1x23] : [<b>]
1407     *                        |--START[1x23] : [<]
1408     *                        |--HTML_TAG_NAME[1x24] : [b]
1409     *                        |--END[1x25] : [>]
1410     *                    |--TEXT[1x26] : [connection]
1411     *                    |--HTML_ELEMENT_END[1x36] : [</b>]
1412     *                        |--START[1x36] : [<]
1413     *                        |--SLASH[1x37] : [/]
1414     *                        |--HTML_TAG_NAME[1x38] : [b]
1415     *                        |--END[1x39] : [>]
1416     *            |--TEXT[1x40] : [ problems occur]
1417     * }
1418     * </pre>
1419     */
1420    public static final int DESCRIPTION = JavadocParser.RULE_description + RULE_TYPES_OFFSET;
1421
1422    // ------------------------------------------------------------------------------------------ //
1423    // -------- HTML TAGS DEPENDING ON RULE TYPES OFFSET ---------------------------------------- //
1424    // ------------------------------------------------------------------------------------------ //
1425
1426    /**
1427     * Parent node for all html tags.
1428     */
1429    public static final int HTML_ELEMENT = JavadocParser.RULE_htmlElement
1430            + RULE_TYPES_OFFSET;
1431
1432    /**
1433     * Start html tag: &lt;XXXX&gt;.
1434     */
1435    public static final int HTML_ELEMENT_START = JavadocParser.RULE_htmlElementStart
1436            + RULE_TYPES_OFFSET;
1437
1438    /**
1439     * End html tag: &lt;XXXX&gt;.
1440     */
1441    public static final int HTML_ELEMENT_END = JavadocParser.RULE_htmlElementEnd
1442            + RULE_TYPES_OFFSET;
1443
1444    /**
1445     * Non-special HTML tag.
1446     */
1447    public static final int HTML_TAG = JavadocParser.RULE_htmlTag + RULE_TYPES_OFFSET;
1448
1449    /**
1450     * Html tag attribute. Parent node for: {@code HTML_TAG_IDENT, EQUALS, ATTR_VALUE}.
1451     */
1452    public static final int ATTRIBUTE = JavadocParser.RULE_attribute
1453            + RULE_TYPES_OFFSET;
1454
1455    /////////////////////// HTML TAGS WITH OPTIONAL END TAG /////////////////////////////////////
1456    /** Paragraph html tag: {@code <p></p>}. */
1457    public static final int PARAGRAPH = JavadocParser.RULE_paragraph + RULE_TYPES_OFFSET;
1458    /** Start paragraph tag. */
1459    public static final int P_TAG_START = JavadocParser.RULE_pTagStart + RULE_TYPES_OFFSET;
1460    /** End paragraph tag. */
1461    public static final int P_TAG_END = JavadocParser.RULE_pTagEnd + RULE_TYPES_OFFSET;
1462    /** List item html tag: {@code <li></li>}. */
1463
1464    public static final int LI = JavadocParser.RULE_li + RULE_TYPES_OFFSET;
1465    /** Start list item tag. */
1466    public static final int LI_TAG_START = JavadocParser.RULE_liTagStart + RULE_TYPES_OFFSET;
1467    /** End list item tag. */
1468    public static final int LI_TAG_END = JavadocParser.RULE_liTagEnd + RULE_TYPES_OFFSET;
1469
1470    /** Table row html tag: {@code <tr></tr>}. */
1471    public static final int TR = JavadocParser.RULE_tr + RULE_TYPES_OFFSET;
1472    /** Start table row tag. */
1473    public static final int TR_TAG_START = JavadocParser.RULE_trTagStart + RULE_TYPES_OFFSET;
1474    /** End table row tag. */
1475    public static final int TR_TAG_END = JavadocParser.RULE_trTagEnd + RULE_TYPES_OFFSET;
1476
1477    /** Table cell html tag: {@code <td></td>}. */
1478    public static final int TD = JavadocParser.RULE_td + RULE_TYPES_OFFSET;
1479    /** Start table cell tag. */
1480    public static final int TD_TAG_START = JavadocParser.RULE_tdTagStart + RULE_TYPES_OFFSET;
1481    /** End table cell tag. */
1482    public static final int TD_TAG_END = JavadocParser.RULE_tdTagEnd + RULE_TYPES_OFFSET;
1483
1484    /** Table header cell html tag: {@code <th></th>}. */
1485    public static final int TH = JavadocParser.RULE_th + RULE_TYPES_OFFSET;
1486    /** Start table header cell tag. */
1487    public static final int TH_TAG_START = JavadocParser.RULE_thTagStart + RULE_TYPES_OFFSET;
1488    /** End table header cell tag. */
1489    public static final int TH_TAG_END = JavadocParser.RULE_thTagEnd + RULE_TYPES_OFFSET;
1490
1491    /** Body html tag. */
1492    public static final int BODY = JavadocParser.RULE_body + RULE_TYPES_OFFSET;
1493    /** Start body tag. */
1494    public static final int BODY_TAG_START = JavadocParser.RULE_bodyTagStart + RULE_TYPES_OFFSET;
1495    /** End body tag. */
1496    public static final int BODY_TAG_END = JavadocParser.RULE_bodyTagEnd + RULE_TYPES_OFFSET;
1497
1498    /** Colgroup html tag. */
1499    public static final int COLGROUP = JavadocParser.RULE_colgroup + RULE_TYPES_OFFSET;
1500    /** Start colgroup tag. */
1501    public static final int COLGROUP_TAG_START = JavadocParser.RULE_colgroupTagStart
1502            + RULE_TYPES_OFFSET;
1503    /** End colgroup tag. */
1504    public static final int COLGROUP_TAG_END = JavadocParser.RULE_colgroupTagEnd
1505            + RULE_TYPES_OFFSET;
1506
1507    /** Description of a term html tag: {@code <dd></dd>}. */
1508    public static final int DD = JavadocParser.RULE_dd + RULE_TYPES_OFFSET;
1509    /** Start description of a term tag. */
1510    public static final int DD_TAG_START = JavadocParser.RULE_ddTagStart + RULE_TYPES_OFFSET;
1511    /** End description of a term tag. */
1512    public static final int DD_TAG_END = JavadocParser.RULE_ddTagEnd + RULE_TYPES_OFFSET;
1513
1514    /** Description term html tag: {@code <dt></dt>}. */
1515    public static final int DT = JavadocParser.RULE_dt + RULE_TYPES_OFFSET;
1516    /** Start description term tag. */
1517    public static final int DT_TAG_START = JavadocParser.RULE_dtTagStart + RULE_TYPES_OFFSET;
1518    /** End description term tag. */
1519    public static final int DT_TAG_END = JavadocParser.RULE_dtTagEnd + RULE_TYPES_OFFSET;
1520
1521    /** Head html tag. */
1522    public static final int HEAD = JavadocParser.RULE_head + RULE_TYPES_OFFSET;
1523    /** Start head tag. */
1524    public static final int HEAD_TAG_START = JavadocParser.RULE_headTagStart + RULE_TYPES_OFFSET;
1525    /** End head tag. */
1526    public static final int HEAD_TAG_END = JavadocParser.RULE_headTagEnd + RULE_TYPES_OFFSET;
1527
1528    /** Html html tag. */
1529    public static final int HTML = JavadocParser.RULE_html + RULE_TYPES_OFFSET;
1530    /** Start html tag. */
1531    public static final int HTML_TAG_START = JavadocParser.RULE_htmlTagStart + RULE_TYPES_OFFSET;
1532    /** End html tag. */
1533    public static final int HTML_TAG_END = JavadocParser.RULE_htmlTagEnd + RULE_TYPES_OFFSET;
1534
1535    /** Option html tag. */
1536    public static final int OPTION = JavadocParser.RULE_option + RULE_TYPES_OFFSET;
1537    /** Start option tag. */
1538    public static final int OPTION_TAG_START =
1539            JavadocParser.RULE_optionTagStart + RULE_TYPES_OFFSET;
1540    /** End option tag. */
1541    public static final int OPTION_TAG_END = JavadocParser.RULE_optionTagEnd
1542            + RULE_TYPES_OFFSET;
1543
1544    /** Table body html tag. */
1545    public static final int TBODY = JavadocParser.RULE_tbody + RULE_TYPES_OFFSET;
1546    /** Start table body tag. */
1547    public static final int TBODY_TAG_START = JavadocParser.RULE_tbodyTagStart + RULE_TYPES_OFFSET;
1548    /** End table body tag. */
1549    public static final int TBODY_TAG_END = JavadocParser.RULE_tbodyTagEnd + RULE_TYPES_OFFSET;
1550
1551    /** Table foot html tag. */
1552    public static final int TFOOT = JavadocParser.RULE_tfoot + RULE_TYPES_OFFSET;
1553    /** Start table foot tag. */
1554    public static final int TFOOT_TAG_START = JavadocParser.RULE_tfootTagStart + RULE_TYPES_OFFSET;
1555    /** End table foot tag. */
1556    public static final int TFOOT_TAG_END = JavadocParser.RULE_tfootTagEnd + RULE_TYPES_OFFSET;
1557
1558    /** Table head html tag. */
1559    public static final int THEAD = JavadocParser.RULE_thead + RULE_TYPES_OFFSET;
1560    /** Start table head tag. */
1561    public static final int THEAD_TAG_START = JavadocParser.RULE_theadTagStart + RULE_TYPES_OFFSET;
1562    /** End table head tag. */
1563    public static final int THEAD_TAG_END = JavadocParser.RULE_theadTagEnd + RULE_TYPES_OFFSET;
1564
1565    /** `optgroup` html tag. */
1566    public static final int OPTGROUP = JavadocParser.RULE_optgroup + RULE_TYPES_OFFSET;
1567    /** `optgroup` tag start. */
1568    public static final int OPTGROUP_TAG_START =
1569            JavadocParser.RULE_optgroupTagStart + RULE_TYPES_OFFSET;
1570    /** `optgroup` tag end. */
1571    public static final int OPTGROUP_TAG_END =
1572            JavadocParser.RULE_optgroupTagEnd + RULE_TYPES_OFFSET;
1573
1574    /** `rb` html tag. */
1575    public static final int RB = JavadocParser.RULE_rb + RULE_TYPES_OFFSET;
1576    /** `rb` tag start. */
1577    public static final int RB_TAG_START =
1578            JavadocParser.RULE_rbTagStart + RULE_TYPES_OFFSET;
1579    /** `rb` tag end. */
1580    public static final int RB_TAG_END =
1581            JavadocParser.RULE_rbTagEnd + RULE_TYPES_OFFSET;
1582
1583    /** `rt` html tag. */
1584    public static final int RT = JavadocParser.RULE_rt + RULE_TYPES_OFFSET;
1585    /** `rt` tag start. */
1586    public static final int RT_TAG_START =
1587            JavadocParser.RULE_rtTagStart + RULE_TYPES_OFFSET;
1588    /** `rt` tag end. */
1589    public static final int RT_TAG_END =
1590            JavadocParser.RULE_rtTagEnd + RULE_TYPES_OFFSET;
1591
1592    /** `rtc` html tag. */
1593    public static final int RTC = JavadocParser.RULE_rtc + RULE_TYPES_OFFSET;
1594    /** `rtc` tag start. */
1595    public static final int RTC_TAG_START =
1596            JavadocParser.RULE_rtcTagStart + RULE_TYPES_OFFSET;
1597    /** `rtc` tag end. */
1598    public static final int RTC_TAG_END =
1599            JavadocParser.RULE_rtcTagEnd + RULE_TYPES_OFFSET;
1600
1601    /** `rp` html tag. */
1602    public static final int RP = JavadocParser.RULE_rp + RULE_TYPES_OFFSET;
1603    /** `rp` tag start. */
1604    public static final int RP_TAG_START =
1605            JavadocParser.RULE_rpTagStart + RULE_TYPES_OFFSET;
1606    /** `rp` tag end. */
1607    public static final int RP_TAG_END =
1608            JavadocParser.RULE_rpTagEnd + RULE_TYPES_OFFSET;
1609
1610    /////////////////////// SINGLETON HTML TAGS  //////////////////////////////////////////////////
1611    /**
1612     * Parent node for all singleton html tags.
1613     */
1614    public static final int SINGLETON_ELEMENT = JavadocParser.RULE_singletonElement
1615            + RULE_TYPES_OFFSET;
1616
1617    /**
1618     * Non-special empty html tag.
1619     */
1620    public static final int EMPTY_TAG = JavadocParser.RULE_emptyTag
1621            + RULE_TYPES_OFFSET;
1622
1623    /** Area html tag. */
1624    public static final int AREA_TAG = JavadocParser.RULE_areaTag + RULE_TYPES_OFFSET;
1625
1626    /** Base html tag. */
1627    public static final int BASE_TAG = JavadocParser.RULE_baseTag + RULE_TYPES_OFFSET;
1628
1629    /** Basefont html tag. */
1630    public static final int BASEFONT_TAG = JavadocParser.RULE_basefontTag + RULE_TYPES_OFFSET;
1631
1632    /** Br html tag. */
1633    public static final int BR_TAG = JavadocParser.RULE_brTag + RULE_TYPES_OFFSET;
1634
1635    /** Col html tag. */
1636    public static final int COL_TAG = JavadocParser.RULE_colTag + RULE_TYPES_OFFSET;
1637
1638    /** Frame html tag. */
1639    public static final int FRAME_TAG = JavadocParser.RULE_frameTag + RULE_TYPES_OFFSET;
1640
1641    /** Hr html tag. */
1642    public static final int HR_TAG = JavadocParser.RULE_hrTag + RULE_TYPES_OFFSET;
1643
1644    /** Img html tag. */
1645    public static final int IMG_TAG = JavadocParser.RULE_imgTag + RULE_TYPES_OFFSET;
1646
1647    /** Input html tag. */
1648    public static final int INPUT_TAG = JavadocParser.RULE_inputTag + RULE_TYPES_OFFSET;
1649
1650    /** Isindex html tag. */
1651    public static final int ISINDEX_TAG = JavadocParser.RULE_isindexTag + RULE_TYPES_OFFSET;
1652
1653    /** Link html tag. */
1654    public static final int LINK_TAG = JavadocParser.RULE_linkTag + RULE_TYPES_OFFSET;
1655
1656    /** Meta html tag. */
1657    public static final int META_TAG = JavadocParser.RULE_metaTag + RULE_TYPES_OFFSET;
1658
1659    /** Param html tag. */
1660    public static final int PARAM_TAG = JavadocParser.RULE_paramTag + RULE_TYPES_OFFSET;
1661
1662    /**
1663     * HTML void element {@code <embed>}.
1664     *
1665     * @see #SINGLETON_ELEMENT
1666     * @see <a href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-embed">
1667     *     W3 docs</a>
1668     */
1669    public static final int EMBED_TAG = JavadocParser.RULE_embedTag + RULE_TYPES_OFFSET;
1670
1671    /**
1672     * HTML void element {@code <keygen>}.
1673     *
1674     * @see #SINGLETON_ELEMENT
1675     * @see <a href="https://www.w3.org/TR/html51/sec-forms.html#elementdef-keygen">
1676     *     W3 docs</a>
1677     */
1678    public static final int KEYGEN_TAG = JavadocParser.RULE_keygenTag + RULE_TYPES_OFFSET;
1679
1680    /**
1681     * HTML void element {@code <source>}.
1682     *
1683     * @see #SINGLETON_ELEMENT
1684     * @see <a href=
1685     *     "https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-media-source">
1686     *     W3 docs</a>
1687     */
1688    public static final int SOURCE_TAG = JavadocParser.RULE_sourceTag + RULE_TYPES_OFFSET;
1689
1690    /**
1691     * HTML void element {@code <track>}.
1692     *
1693     * @see #SINGLETON_ELEMENT
1694     * @see <a
1695     *     href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-track">
1696     *     W3 docs</a>
1697     */
1698    public static final int TRACK_TAG = JavadocParser.RULE_trackTag + RULE_TYPES_OFFSET;
1699
1700    /**
1701     * HTML void element {@code <wbr>}.
1702     *
1703     * @see #SINGLETON_ELEMENT
1704     * @see <a href="https://www.w3.org/TR/html51/textlevel-semantics.html#elementdef-wbr">
1705     *     W3 docs</a>
1706     */
1707    public static final int WBR_TAG = JavadocParser.RULE_wbrTag + RULE_TYPES_OFFSET;
1708
1709    ///////////////////////////////////////////////////////////////////////////////////////////////
1710
1711    /**
1712     * Html comment: <code>&lt;&#33;-- --&gt;</code>.
1713     *
1714     * @noinspection HtmlTagCanBeJavadocTag
1715     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
1716     *      replaced with Javadoc tag
1717     */
1718    public static final int HTML_COMMENT = JavadocParser.RULE_htmlComment
1719            + RULE_TYPES_OFFSET;
1720    /**
1721     * CHAR and WS sequence.
1722     */
1723    public static final int TEXT = JavadocParser.RULE_text + RULE_TYPES_OFFSET;
1724
1725    /** Empty private constructor of the current class. */
1726    private JavadocTokenTypes() {
1727    }
1728
1729}