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 -> JAVADOC_TAG
231     *       |--SERIAL_LITERAL -> @serial
232     *       |--WS
233     *       |--LITERAL_INCLUDE -> include
234     * }</pre>
235     *
236     * <p><b>Example:</b></p>
237     * <pre>{@code @serial serialized company name}</pre>
238     * <b>Tree:</b>
239     * <pre>{@code
240     *   |--JAVADOC_TAG-> JAVADOC_TAG
241     *       |--SERIAL_LITERAL -> @serial
242     *       |--WS
243     *       |--DESCRIPTION -> DESCRIPTION
244     *           |--TEXT -> serialized company name
245     * }</pre>
246     *
247     * @see
248     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
249     * Oracle Docs</a>
250     * @see #JAVADOC_TAG
251     */
252    public static final int SERIAL_LITERAL = JavadocParser.SERIAL_LITERAL;
253
254    /**
255     * '@version' literal in {@code @version} Javadoc tag.
256     *
257     * <p>Such Javadoc tag can have one argument - {@link #DESCRIPTION}</p>
258     *
259     * <p><b>Example:</b></p>
260     * <pre>{@code @version 1.3}</pre>
261     * <b>Tree:</b>
262     * <pre>{@code
263     *   JAVADOC_TAG -> JAVADOC_TAG
264     *    |--VERSION_LITERAL -> @version
265     *    |--WS ->
266     *    `--DESCRIPTION -> DESCRIPTION
267     *        |--TEXT -> 1.3
268     * }</pre>
269     *
270     * @see
271     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCHBAE">
272     * Oracle Docs</a>
273     * @see #JAVADOC_TAG
274     */
275    public static final int VERSION_LITERAL = JavadocParser.VERSION_LITERAL;
276
277    /**
278     * '@exception' literal in {@code @exception} Javadoc tag.
279     *
280     * <p>Such Javadoc tag can have two argument - {@link #CLASS_NAME} and {@link #DESCRIPTION}</p>
281     *
282     * <p><b>Example:</b></p>
283     * <pre>{@code @exception SQLException if query is not correct}</pre>
284     * <b>Tree:</b>
285     * <pre>{@code
286     *   JAVADOC_TAG -> JAVADOC_TAG
287     *    |--EXCEPTION_LITERAL -> @exception
288     *    |--WS ->
289     *    |--CLASS_NAME -> SQLException
290     *    |--WS ->
291     *    `--DESCRIPTION -> DESCRIPTION
292     *        `--TEXT -> if query is not correct
293     * }</pre>
294     *
295     * @see
296     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCEAHH">
297     * Oracle Docs</a>
298     * @see #JAVADOC_TAG
299     */
300    public static final int EXCEPTION_LITERAL = JavadocParser.EXCEPTION_LITERAL;
301
302    /**
303     * '@throws' literal in {@code @throws} Javadoc tag.
304     *
305     * <p>Such Javadoc tag can have two argument - {@link #CLASS_NAME} and {@link #DESCRIPTION}</p>
306     *
307     * <p><b>Example:</b></p>
308     * <pre>{@code @throws SQLException if query is not correct}</pre>
309     * <b>Tree:</b>
310     * <pre>{@code
311     *   JAVADOC_TAG -> JAVADOC_TAG
312     *    |--THROWS_LITERAL -> @throws
313     *    |--WS ->
314     *    |--CLASS_NAME -> SQLException
315     *    |--WS ->
316     *    `--DESCRIPTION -> DESCRIPTION
317     *        `--TEXT -> if query is not correct
318     * }</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[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     *
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> |--JAVADOC_INLINE_TAG[1x0] : [{&#64;literal #compare(Object)}]
618     *        |--JAVADOC_INLINE_TAG_START[1x0] : [{]
619     *        |--LITERAL_LITERAL[1x1] : [@literal]
620     *        |--WS[1x9] : [ ]
621     *        |--TEXT[1x10] : [#compare(Object)]
622     *        |--JAVADOC_INLINE_TAG_END[1x27] : [}]
623     * </code>
624     * </pre>
625     *
626     * @see
627     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDCFJDG">
628     * Oracle Docs</a>
629     * @see #JAVADOC_INLINE_TAG
630     * @noinspection HtmlTagCanBeJavadocTag
631     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
632     *      replaced with Javadoc tag
633     */
634    public static final int LITERAL_LITERAL = JavadocParser.LITERAL_LITERAL;
635
636    /**
637     * '@value' literal in {&#64;value} Javadoc inline tag.
638     *
639     * <p>Such Javadoc inline tag has one argument {@link #REFERENCE}
640     * and can have such child nodes:</p>
641     * <ul>
642     * <li>{@link #NEWLINE}</li>
643     * <li>{@link #WS}</li>
644     * </ul>
645     *
646     * <p><b>Example:</b></p>
647     * <pre><code>{&#64;value Integer#MAX_VALUE}</code></pre>
648     * <b>Tree:</b>
649     * <pre>
650     * <code> |--JAVADOC_INLINE_TAG[1x0] : [&#64;value Integer#MAX_VALUE}]
651     *        |--JAVADOC_INLINE_TAG_START[1x0] : [{]
652     *        |--VALUE_LITERAL[1x1] : [@value]
653     *        |--WS[1x7] : [ ]
654     *        |--REFERENCE[1x8] : [Integer#MAX_VALUE]
655     *            |--CLASS[1x8] : [Integer]
656     *            |--HASH[1x15] : [#]
657     *            |--MEMBER[1x16] : [MAX_VALUE]
658     *        |--JAVADOC_INLINE_TAG_END[1x25] : [}]
659     * </code>
660     * </pre>
661     *
662     * @see
663     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDDCDHH">
664     * Oracle Docs</a>
665     * @see #JAVADOC_INLINE_TAG
666     * @noinspection HtmlTagCanBeJavadocTag
667     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
668     *      replaced with Javadoc tag
669     */
670    public static final int VALUE_LITERAL = JavadocParser.VALUE_LITERAL;
671
672    /**
673     * PACKAGE_CLASS represents the package or class which has been referenced in the `@see`,
674     * `@link`, `@linkplain` or `@value` javadoc tags. In the javadoc tree it shall be a child
675     * of {@link #REFERENCE}.
676     * <br>
677     * <strong>IMPORTANT:</strong> Constructs like
678     * {@code package.Class.NestedClassAtDepth1.NestedClassAtDepth2#member} are recognized by
679     * the javadoc tool from oracle, and no assumptions like, package names wouldn't consist of
680     * uppercase characters or class names begin with an uppercase character, are made.
681     * Also, <i>the reference</i> in a javadoc tag can consist just a package name or a
682     * simple class name or even a full class name. Thus, PACKAGE_CLASS can represent a
683     * package name or a simple class name or a full class name i.e. checkstyle doesn't
684     * resolve references at present.
685     *
686     * <p><b>Example:</b></p>
687     * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre>
688     * <b>Tree:</b>
689     * <pre>
690     * {@code |--JAVADOC_TAG[3x0] : [@see org.apache.utils.Lists.Comparator#compare(Object)]
691     *        |--SEE_LITERAL[3x0] : [@see]
692     *        |--WS[3x4] : [ ]
693     *        |--REFERENCE[3x5] : [org.apache.utils.Lists.Comparator#compare(Object)]
694     *            |--PACKAGE_CLASS[3x5] : [org.apache.utils]
695     *            |--DOT[3x21] : [.]
696     *            |--CLASS[3x22] : [Lists]
697     *            |--DOT[3x27] : [.]
698     *            |--CLASS[3x28] : [Comparator]
699     *            |--HASH[3x38] : [#]
700     *            |--MEMBER[3x39] : [compare]
701     *            |--PARAMETERS[3x46] : [(Object)]
702     *                |--LEFT_BRACE[3x46] : [(]
703     *                |--ARGUMENT[3x47] : [Object]
704     *                |--RIGHT_BRACE[3x53] : [)]
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 |--JAVADOC_TAG[3x0] : [@see org.apache.utils.Lists.Comparator#compare(Object)]
719     *        |--SEE_LITERAL[3x0] : [@see]
720     *        |--WS[3x4] : [ ]
721     *        |--REFERENCE[3x5] : [org.apache.utils.Lists.Comparator#compare(Object)]
722     *            |--PACKAGE_CLASS[3x5] : [org.apache.utils]
723     *            |--DOT[3x21] : [.]
724     *            |--CLASS[3x22] : [Lists]
725     *            |--DOT[3x27] : [.]
726     *            |--CLASS[3x28] : [Comparator]
727     *            |--HASH[3x38] : [#]
728     *            |--MEMBER[3x39] : [compare]
729     *            |--PARAMETERS[3x46] : [(Object)]
730     *                |--LEFT_BRACE[3x46] : [(]
731     *                |--ARGUMENT[3x47] : [Object]
732     *                |--RIGHT_BRACE[3x53] : [)]
733     * }
734     * </pre>
735     */
736    public static final int HASH = JavadocParser.HASH;
737
738    /**
739     * A class member in {@link #REFERENCE}.
740     * Class member is specified after {@link #HASH} symbol.
741     *
742     * <p><b>Example:</b></p>
743     * <pre>{@code @see org.apache.utils.Lists.Comparator#compare(Object)}</pre>
744     * <b>Tree:</b>
745     * <pre>
746     * {@code |--JAVADOC_TAG[3x0] : [@see org.apache.utils.Lists.Comparator#compare(Object)]
747     *        |--SEE_LITERAL[3x0] : [@see]
748     *        |--WS[3x4] : [ ]
749     *        |--REFERENCE[3x5] : [org.apache.utils.Lists.Comparator#compare(Object)]
750     *            |--PACKAGE_CLASS[3x5] : [org.apache.utils]
751     *            |--DOT[3x21] : [.]
752     *            |--CLASS[3x22] : [Lists]
753     *            |--DOT[3x27] : [.]
754     *            |--CLASS[3x28] : [Comparator]
755     *            |--HASH[3x38] : [#]
756     *            |--MEMBER[3x39] : [compare]
757     *            |--PARAMETERS[3x46] : [(Object)]
758     *                |--LEFT_BRACE[3x46] : [(]
759     *                |--ARGUMENT[3x47] : [Object]
760     *                |--RIGHT_BRACE[3x53] : [)]
761     * }
762     * </pre>
763     */
764    public static final int MEMBER = JavadocParser.MEMBER;
765
766    /**
767     * Left brace in {@link #PARAMETERS} part of {@link #REFERENCE}.
768     *
769     * <p><b>Example:</b></p>
770     * <pre>{@code @see #method(Processor, String)}</pre>
771     * <b>Tree:</b>
772     * <pre>
773     * {@code |--JAVADOC_TAG[1x0] : [@see #method(Processor, String)]
774     *        |--SEE_LITERAL[1x0] : [@see]
775     *        |--WS[1x4] : [ ]
776     *        |--REFERENCE[1x5] : [#method(Processor, String)]
777     *            |--HASH[1x5] : [#]
778     *            |--MEMBER[1x6] : [method]
779     *            |--PARAMETERS[1x12] : [(Processor, String)]
780     *                |--LEFT_BRACE[1x12] : [(]
781     *                |--ARGUMENT[1x13] : [Processor]
782     *                |--COMMA[1x22] : [,]
783     *                |--WS[1x23] : [ ]
784     *                |--ARGUMENT[1x24] : [String]
785     *                |--RIGHT_BRACE[1x30] : [)]
786     * }
787     * </pre>
788     */
789    public static final int LEFT_BRACE = JavadocParser.LEFT_BRACE;
790
791    /**
792     * Right brace in {@link #PARAMETERS} part of {@link #REFERENCE}.
793     *
794     * <p><b>Example:</b></p>
795     * <pre>{@code @see #method(Processor, String)}</pre>
796     * <b>Tree:</b>
797     * <pre>
798     * {@code |--JAVADOC_TAG[1x0] : [@see #method(Processor, String)]
799     *        |--SEE_LITERAL[1x0] : [@see]
800     *        |--WS[1x4] : [ ]
801     *        |--REFERENCE[1x5] : [#method(Processor, String)]
802     *            |--HASH[1x5] : [#]
803     *            |--MEMBER[1x6] : [method]
804     *            |--PARAMETERS[1x12] : [(Processor, String)]
805     *                |--LEFT_BRACE[1x12] : [(]
806     *                |--ARGUMENT[1x13] : [Processor]
807     *                |--COMMA[1x22] : [,]
808     *                |--WS[1x23] : [ ]
809     *                |--ARGUMENT[1x24] : [String]
810     *                |--RIGHT_BRACE[1x30] : [)]
811     * }
812     * </pre>
813     */
814    public static final int RIGHT_BRACE = JavadocParser.RIGHT_BRACE;
815
816    /**
817     * Argument definition in {@link #PARAMETERS} part of {@link #REFERENCE}.
818     *
819     * <p><b>Example:</b></p>
820     * <pre>{@code @see #method(Processor, String)}</pre>
821     * <b>Tree:</b>
822     * <pre>
823     * {@code |--JAVADOC_TAG[1x0] : [@see #method(Processor, String)]
824     *        |--SEE_LITERAL[1x0] : [@see]
825     *        |--WS[1x4] : [ ]
826     *        |--REFERENCE[1x5] : [#method(Processor, String)]
827     *            |--HASH[1x5] : [#]
828     *            |--MEMBER[1x6] : [method]
829     *            |--PARAMETERS[1x12] : [(Processor, String)]
830     *                |--LEFT_BRACE[1x12] : [(]
831     *                |--ARGUMENT[1x13] : [Processor]
832     *                |--COMMA[1x22] : [,]
833     *                |--WS[1x23] : [ ]
834     *                |--ARGUMENT[1x24] : [String]
835     *                |--RIGHT_BRACE[1x30] : [)]
836     * }
837     * </pre>
838     */
839    public static final int ARGUMENT = JavadocParser.ARGUMENT;
840
841    /**
842     * Comma separator between parameters in {@link #PARAMETERS} part of {@link #REFERENCE}.
843     *
844     * <p><b>Example:</b></p>
845     * <pre>{@code @see #method(Processor, String)}</pre>
846     * <b>Tree:</b>
847     * <pre>
848     * {@code |--JAVADOC_TAG[1x0] : [@see #method(Processor, String)]
849     *        |--SEE_LITERAL[1x0] : [@see]
850     *        |--WS[1x4] : [ ]
851     *        |--REFERENCE[1x5] : [#method(Processor, String)]
852     *            |--HASH[1x5] : [#]
853     *            |--MEMBER[1x6] : [method]
854     *            |--PARAMETERS[1x12] : [(Processor, String)]
855     *                |--LEFT_BRACE[1x12] : [(]
856     *                |--ARGUMENT[1x13] : [Processor]
857     *                |--COMMA[1x22] : [,]
858     *                |--WS[1x23] : [ ]
859     *                |--ARGUMENT[1x24] : [String]
860     *                |--RIGHT_BRACE[1x30] : [)]
861     * }
862     * </pre>
863     *
864     * @see #PARAMETERS
865     * @see #REFERENCE
866     * @see #ARGUMENT
867     */
868    public static final int COMMA = JavadocParser.COMMA;
869
870    /**
871     * Quoted text.
872     * One of possible {@code @see} tag arguments.
873     *
874     * <p><b>Example:</b></p>
875     * <pre>{@code @see "Spring Framework"}</pre>
876     * <b>Tree:</b>
877     * <pre>
878     * {@code |--JAVADOC_TAG[1x0] : [@see "Spring Framework"]
879     *        |--SEE_LITERAL[1x0] : [@see]
880     *        |--WS[1x4] : [ ]
881     *        |--STRING[1x5] : ["Spring Framework"]
882     * }
883     * </pre>
884     *
885     * @see #SEE_LITERAL
886     */
887    public static final int STRING = JavadocParser.STRING;
888
889    /**
890     * Exception class name. First argument in {@link #THROWS_LITERAL @throws} and
891     * {@link #EXCEPTION_LITERAL @exception} Javadoc tags.
892     *
893     * <p><b>Example:</b></p>
894     * <pre>{@code @throws IOException connection problems}</pre>
895     * <b>Tree:</b>
896     * <pre>
897     * {@code |--JAVADOC_TAG[1x0] : [@throws IOException connection problems]
898     *        |--THROWS_LITERAL[1x0] : [@throws]
899     *        |--WS[1x7] : [ ]
900     *        |--CLASS_NAME[1x8] : [IOException]
901     *        |--WS[1x19] : [ ]
902     *        |--DESCRIPTION[1x20] : [connection problems]
903     *            |--TEXT[1x20] : [connection problems]
904     * }
905     * </pre>
906     *
907     * @see #EXCEPTION_LITERAL
908     * @see #THROWS_LITERAL
909     */
910    public static final int CLASS_NAME = JavadocParser.CLASS_NAME;
911
912    /**
913     * First argument in {@link #PARAM_LITERAL @param} Javadoc tag.
914     *
915     * <p><b>Example:</b></p>
916     * <pre>{@code @param T The bar.}</pre>
917     * <b>Tree:</b>
918     * <pre>
919     * {@code |--JAVADOC_TAG[4x3] : [@param T The bar.]
920     *        |--PARAM_LITERAL[4x3] : [@param]
921     *        |--WS[4x9] : [ ]
922     *        |--PARAMETER_NAME[4x10] : [T]
923     *        |--WS[4x11] : [ ]
924     *        |--DESCRIPTION[4x12] : [The bar.]
925     *            |--TEXT[4x12] : [The bar.]
926     * }
927     * </pre>
928     *
929     * @see
930     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHJECF">
931     * Oracle Docs</a>
932     * @see #PARAM_LITERAL
933     */
934    public static final int PARAMETER_NAME = JavadocParser.PARAMETER_NAME;
935
936    /**
937     * 'exclude' literal.
938     * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments.
939     *
940     * <p><b>Example:</b></p>
941     * <pre>{@code @serial exclude}</pre>
942     * <b>Tree:</b>
943     * <pre>
944     * {@code |--JAVADOC_TAG[1x0] : [@serial exclude]
945     *        |--SERIAL_LITERAL[1x0] : [@serial]
946     *        |--WS[1x7] : [ ]
947     *        |--LITERAL_EXCLUDE[1x8] : [exclude]
948     * }
949     * </pre>
950     *
951     * @see
952     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
953     * Oracle Docs</a>
954     * @see #SERIAL_LITERAL
955     */
956    public static final int LITERAL_EXCLUDE = JavadocParser.LITERAL_EXCLUDE;
957
958    /**
959     * 'include' literal.
960     * One of three possible {@link #SERIAL_LITERAL @serial} tag arguments.
961     *
962     * <p><b>Example:</b></p>
963     * <pre>{@code @serial include}</pre>
964     * <b>Tree:</b>
965     * <pre>
966     * {@code |--JAVADOC_TAG[1x0] : [@serial include]
967     *        |--SERIAL_LITERAL[1x0] : [@serial]
968     *        |--WS[1x7] : [ ]
969     *        |--LITERAL_INCLUDE[1x8] : [include]
970     * }
971     * </pre>
972     *
973     * @see
974     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
975     * Oracle Docs</a>
976     * @see #SERIAL_LITERAL
977     */
978    public static final int LITERAL_INCLUDE = JavadocParser.LITERAL_INCLUDE;
979
980    /**
981     * Field name. First argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag.
982     *
983     * <p><b>Example:</b></p>
984     * <pre>{@code @serialField counter Integer objects counter}</pre>
985     * <b>Tree:</b>
986     * <pre>
987     * {@code |--JAVADOC_TAG[3x0] : [@serialField counter Integer objects counter]
988     *        |--SERIAL_FIELD_LITERAL[3x0] : [@serialField]
989     *        |--WS[3x12] : [ ]
990     *        |--FIELD_NAME[3x13] : [counter]
991     *        |--WS[3x20] : [ ]
992     *        |--FIELD_TYPE[3x21] : [Integer]
993     *        |--WS[3x28] : [ ]
994     *        |--DESCRIPTION[3x29] : [objects counter]
995     *            |--TEXT[3x29] : [objects counter]
996     * }
997     * </pre>
998     *
999     * @see
1000     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
1001     * Oracle Docs</a>
1002     * @see #SERIAL_FIELD_LITERAL
1003     */
1004    public static final int FIELD_NAME = JavadocParser.FIELD_NAME;
1005
1006    /**
1007     * Field type. Second argument of {@link #SERIAL_FIELD_LITERAL @serialField} Javadoc tag.
1008     *
1009     * <p><b>Example:</b></p>
1010     * <pre>{@code @serialField counter Integer objects counter}</pre>
1011     * <b>Tree:</b>
1012     * <pre>
1013     * {@code |--JAVADOC_TAG[3x0] : [@serialField counter Integer objects counter]
1014     *        |--SERIAL_FIELD_LITERAL[3x0] : [@serialField]
1015     *        |--WS[3x12] : [ ]
1016     *        |--FIELD_NAME[3x13] : [counter]
1017     *        |--WS[3x20] : [ ]
1018     *        |--FIELD_TYPE[3x21] : [Integer]
1019     *        |--WS[3x28] : [ ]
1020     *        |--DESCRIPTION[3x29] : [objects counter]
1021     *            |--TEXT[3x29] : [objects counter]
1022     * }
1023     * </pre>
1024     *
1025     * @see
1026     * <a href="https://docs.oracle.com/javase/8/docs/technotes/tools/unix/javadoc.html#CHDHDECF">
1027     * Oracle Docs</a>
1028     * @see #SERIAL_FIELD_LITERAL
1029     */
1030    public static final int FIELD_TYPE = JavadocParser.FIELD_TYPE;
1031
1032    // ------------------------------------------------------------------------------------------ //
1033    // -----------------        HTML TAGS          ---------------------------------------------- //
1034    // ------------------------------------------------------------------------------------------ //
1035
1036    /**
1037     * Identifier inside HTML tag: tag name or attribute name.
1038     */
1039    public static final int HTML_TAG_NAME = JavadocParser.HTML_TAG_NAME;
1040
1041    // HTML tag components
1042
1043    /**
1044     * Start html tag component: {@code '<'}.
1045     */
1046    public static final int START = JavadocParser.START;
1047
1048    /**
1049     * Slash html tag component: {@code '/'}.
1050     */
1051    public static final int SLASH = JavadocParser.SLASH;
1052
1053    /**
1054     * End html tag component: {@code '>'}.
1055     */
1056    public static final int END = JavadocParser.END;
1057
1058    /**
1059     * Slash close html tag component: {@code '/>'}.
1060     */
1061    public static final int SLASH_END = JavadocParser.SLASH_END;
1062
1063    /**
1064     * Equals html tag component: {@code '='}.
1065     */
1066    public static final int EQUALS = JavadocParser.EQUALS;
1067
1068    /**
1069     * Attribute value html tag component.
1070     */
1071    public static final int ATTR_VALUE = JavadocParser.ATTR_VALUE;
1072
1073    /////////////////////// HTML TAGS WITH OPTIONAL END TAG /////////////////////////////////////
1074    /** Paragraph tag name. */
1075    public static final int P_HTML_TAG_NAME = JavadocParser.P_HTML_TAG_NAME;
1076
1077    /** List item tag name. */
1078    public static final int LI_HTML_TAG_NAME = JavadocParser.LI_HTML_TAG_NAME;
1079
1080    /** Table row tag name. */
1081    public static final int TR_HTML_TAG_NAME = JavadocParser.TR_HTML_TAG_NAME;
1082
1083    /** Table cell tag name. */
1084    public static final int TD_HTML_TAG_NAME = JavadocParser.TD_HTML_TAG_NAME;
1085
1086    /** Table header cell tag name. */
1087    public static final int TH_HTML_TAG_NAME = JavadocParser.TH_HTML_TAG_NAME;
1088
1089    /** Body tag name. */
1090    public static final int BODY_HTML_TAG_NAME = JavadocParser.BODY_HTML_TAG_NAME;
1091
1092    /** Colgroup tag name. */
1093    public static final int COLGROUP_HTML_TAG_NAME = JavadocParser.COLGROUP_HTML_TAG_NAME;
1094
1095    /** Description of a term tag name. */
1096    public static final int DD_HTML_TAG_NAME = JavadocParser.DD_HTML_TAG_NAME;
1097
1098    /** Description term tag name. */
1099    public static final int DT_HTML_TAG_NAME = JavadocParser.DT_HTML_TAG_NAME;
1100
1101    /** Head tag name. */
1102    public static final int HEAD_HTML_TAG_NAME = JavadocParser.HEAD_HTML_TAG_NAME;
1103
1104    /** Html tag name. */
1105    public static final int HTML_HTML_TAG_NAME = JavadocParser.HTML_HTML_TAG_NAME;
1106
1107    /** Option tag name. */
1108    public static final int OPTION_HTML_TAG_NAME = JavadocParser.OPTION_HTML_TAG_NAME;
1109
1110    /** Table body tag name. */
1111    public static final int TBODY_HTML_TAG_NAME = JavadocParser.TBODY_HTML_TAG_NAME;
1112
1113    /** Table foot tag name. */
1114    public static final int TFOOT_HTML_TAG_NAME = JavadocParser.TFOOT_HTML_TAG_NAME;
1115
1116    /** Table head tag name. */
1117    public static final int THEAD_HTML_TAG_NAME = JavadocParser.THEAD_HTML_TAG_NAME;
1118
1119    /** `optgroup` tag name. */
1120    public static final int OPTGROUP_HTML_TAG_NAME = JavadocParser.OPTGROUP_HTML_TAG_NAME;
1121
1122    /** `rb` tag name. */
1123    public static final int RB_HTML_TAG_NAME = JavadocParser.RB_HTML_TAG_NAME;
1124
1125    /** `rt` tag name. */
1126    public static final int RT_HTML_TAG_NAME = JavadocParser.RT_HTML_TAG_NAME;
1127
1128    /** `rtc` tag name. */
1129    public static final int RTC_HTML_TAG_NAME = JavadocParser.RTC_HTML_TAG_NAME;
1130
1131    /** `rp` tag name. */
1132    public static final int RP_HTML_TAG_NAME = JavadocParser.RP_HTML_TAG_NAME;
1133    ///////////////////////////////////////////////////////////////////////////////////////////////
1134
1135    /////////////////////// SINGLETON HTML TAGS  //////////////////////////////////////////////////
1136    /** Area tag name. */
1137    public static final int AREA_HTML_TAG_NAME = JavadocParser.AREA_HTML_TAG_NAME;
1138
1139    /** Base tag name. */
1140    public static final int BASE_HTML_TAG_NAME = JavadocParser.BASE_HTML_TAG_NAME;
1141
1142    /** Basefont tag name. */
1143    public static final int BASEFONT_HTML_TAG_NAME = JavadocParser.BASEFONT_HTML_TAG_NAME;
1144
1145    /** Br tag name. */
1146    public static final int BR_HTML_TAG_NAME = JavadocParser.BR_HTML_TAG_NAME;
1147
1148    /** Col tag name. */
1149    public static final int COL_HTML_TAG_NAME = JavadocParser.COL_HTML_TAG_NAME;
1150
1151    /** Frame tag name. */
1152    public static final int FRAME_HTML_TAG_NAME = JavadocParser.FRAME_HTML_TAG_NAME;
1153
1154    /** Hr tag name. */
1155    public static final int HR_HTML_TAG_NAME = JavadocParser.HR_HTML_TAG_NAME;
1156
1157    /** Img tag name. */
1158    public static final int IMG_HTML_TAG_NAME = JavadocParser.IMG_HTML_TAG_NAME;
1159
1160    /** Input tag name. */
1161    public static final int INPUT_HTML_TAG_NAME = JavadocParser.INPUT_HTML_TAG_NAME;
1162
1163    /** Isindex tag name. */
1164    public static final int ISINDEX_HTML_TAG_NAME = JavadocParser.ISINDEX_HTML_TAG_NAME;
1165
1166    /** Link tag name. */
1167    public static final int LINK_HTML_TAG_NAME = JavadocParser.LINK_HTML_TAG_NAME;
1168
1169    /** Meta tag name. */
1170    public static final int META_HTML_TAG_NAME = JavadocParser.META_HTML_TAG_NAME;
1171
1172    /** Param tag name. */
1173    public static final int PARAM_HTML_TAG_NAME = JavadocParser.PARAM_HTML_TAG_NAME;
1174    /** "embed" tag name. */
1175    public static final int EMBED_HTML_TAG_NAME = JavadocParser.EMBED_HTML_TAG_NAME;
1176    /** "keygen" tag name. */
1177    public static final int KEYGEN_HTML_TAG_NAME = JavadocParser.KEYGEN_HTML_TAG_NAME;
1178    /** "source" tag name. */
1179    public static final int SOURCE_HTML_TAG_NAME = JavadocParser.SOURCE_HTML_TAG_NAME;
1180    /** "track" tag name. */
1181    public static final int TRACK_HTML_TAG_NAME = JavadocParser.TRACK_HTML_TAG_NAME;
1182    /** "wbr" tag name. */
1183    public static final int WBR_HTML_TAG_NAME = JavadocParser.WBR_HTML_TAG_NAME;
1184    ///////////////////////////////////////////////////////////////////////////////////////////////
1185
1186    /**
1187     * HTML comment start symbol '&lt;&#33;--'.
1188     */
1189    public static final int HTML_COMMENT_START = JavadocParser.HTML_COMMENT_START;
1190
1191    /**
1192     * HTML comment end symbol '--&gt;'.
1193     */
1194    public static final int HTML_COMMENT_END = JavadocParser.HTML_COMMENT_END;
1195
1196    // ------------------------------------------------------------------------------------------ //
1197    // -----------------        OTHER          -------------------------------------------------- //
1198    // ------------------------------------------------------------------------------------------ //
1199
1200    /** Leading asterisk. */
1201    public static final int LEADING_ASTERISK = JavadocParser.LEADING_ASTERISK;
1202
1203    /**
1204     * Newline symbol - '\n'.
1205     */
1206    public static final int NEWLINE = JavadocParser.NEWLINE;
1207
1208    /**
1209     * Any other symbol.
1210     */
1211    public static final int CHAR = JavadocParser.CHAR;
1212
1213    /**
1214     * Whitespace or tab ('\t') symbol.
1215     */
1216    public static final int WS = JavadocParser.WS;
1217
1218    /**
1219     * End Of File symbol. Copied from
1220     * {@link org.antlr.v4.runtime.Recognizer#EOF} to avoid ANTLR dependency in
1221     * API.
1222     */
1223    public static final int EOF = -1;
1224
1225    // ------------------------------------------------------------------------------------------ //
1226    // ------ JAVADOC TAGS DEPENDING ON RULE TYPES OFFSET --------------------------------------- //
1227    // ------------------------------------------------------------------------------------------ //
1228
1229    /**
1230     * Rule types offset.
1231     * RULE_TYPES_OFFSET constant is used to split lexer tokens types and parser rules types.
1232     * We need unique numbers for all tokens,
1233     * ANTLR do not need this and that is why these types are mixed by used values.
1234     * All values we can take a look at
1235     * target/generated-sources/antlr/com/puppycrawl/tools/checkstyle/grammar/javadoc/JavadocParser.java
1236     * For example: LEADING_ASTERISK=1 and RULE_htmlElement = 1.
1237     * RULE_TYPES_OFFSET required to shift parser rules,
1238     * to let them not overlap with types that have prefix "RULE_".
1239     */
1240    private static final int RULE_TYPES_OFFSET = 10000;
1241
1242    /**
1243     * Root node of any Javadoc comment.
1244     * Last child is always {@link #EOF}.
1245     *
1246     * <p><b>Tree for example:</b></p>
1247     * <pre>{@code
1248     * JAVADOC[3x0]
1249     *   |--NEWLINE[3x0] : [\n]
1250     *   |--LEADING_ASTERISK[4x0] : [ *]
1251     *   |--WS[4x2] : [ ]
1252     *   |--JAVADOC_TAG[4x3] : [@param T The bar.\n ]
1253     *       |--PARAM_LITERAL[4x3] : [@param]
1254     *       |--WS[4x9] : [ ]
1255     *       |--PARAMETER_NAME[4x10] : [T]
1256     *       |--WS[4x11] : [ ]
1257     *       |--DESCRIPTION[4x12] : [The bar.\n ]
1258     *           |--TEXT[4x12] : [The bar.]
1259     *           |--NEWLINE[4x20] : [\n]
1260     *           |--TEXT[5x0] : [ ]
1261     *   |--EOF[5x1] : [<EOF>]
1262     * }</pre>
1263     */
1264    public static final int JAVADOC = JavadocParser.RULE_javadoc + RULE_TYPES_OFFSET;
1265
1266    /**
1267     * Javadoc tag.
1268     *
1269     * <p>Type of Javadoc tag is resolved by literal node that is first child of this node.</p>
1270     *
1271     * <p>As literal could be:</p>
1272     * <ul>
1273     * <li>{@link #RETURN_LITERAL}</li>
1274     * <li>{@link #DEPRECATED_LITERAL}</li>
1275     * <li>{@link #SINCE_LITERAL}</li>
1276     * <li>{@link #SERIAL_DATA_LITERAL}</li>
1277     * <li>{@link #SERIAL_FIELD_LITERAL}</li>
1278     * <li>{@link #PARAM_LITERAL}</li>
1279     * <li>{@link #SEE_LITERAL}</li>
1280     * <li>{@link #SERIAL_LITERAL}</li>
1281     * <li>{@link #VERSION_LITERAL}</li>
1282     * <li>{@link #EXCEPTION_LITERAL}</li>
1283     * <li>{@link #THROWS_LITERAL}</li>
1284     * <li>{@link #AUTHOR_LITERAL}</li>
1285     * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc tag.</li>
1286     * </ul>
1287     *
1288     * <p><b>Example</b></p>
1289     * <pre>{@code &#64;param T The bar.}</pre>
1290     * <b>Tree</b>
1291     * <pre>{@code
1292     *   |--JAVADOC_TAG[4x3] : [@param T The bar.]
1293     *       |--PARAM_LITERAL[4x3] : [@param]
1294     *       |--WS[4x9] : [ ]
1295     *       |--PARAMETER_NAME[4x10] : [T]
1296     *       |--WS[4x11] : [ ]
1297     *       |--DESCRIPTION[4x12] : [The bar.]
1298     *           |--TEXT[4x12] : [The bar.]
1299     * }</pre>
1300     */
1301
1302    public static final int JAVADOC_TAG = JavadocParser.RULE_javadocTag + RULE_TYPES_OFFSET;
1303    /**
1304     * Javadoc inline tag.
1305     *
1306     * <p>Type of Javadoc inline tag is resolved by literal node that is second child of this node.
1307     * First child is always {@link #JAVADOC_INLINE_TAG_START} and last node is always
1308     * {@link #JAVADOC_INLINE_TAG_END}.</p>
1309     *
1310     * <p>As literal could be:</p>
1311     * <ul>
1312     * <li>{@link #CODE_LITERAL}</li>
1313     * <li>{@link #DOC_ROOT_LITERAL}</li>
1314     * <li>{@link #LINK_LITERAL}</li>
1315     * <li>{@link #INHERIT_DOC_LITERAL}</li>
1316     * <li>{@link #LINKPLAIN_LITERAL}</li>
1317     * <li>{@link #LITERAL_LITERAL}</li>
1318     * <li>{@link #VALUE_LITERAL}</li>
1319     * <li>or {@link #CUSTOM_NAME} if it is custom Javadoc inline tag.</li>
1320     * </ul>
1321     *
1322     * <p><b>Example:</b></p>
1323     * <pre><code>{&#64;link String}</code></pre>
1324     * <b>Tree:</b>
1325     * <pre>
1326     * <code> |--JAVADOC_INLINE_TAG[4x3] : [&#64;link String}]
1327     *        |--JAVADOC_INLINE_TAG_START[4x3] : [{]
1328     *        |--LINK_LITERAL[4x4] : [@link]
1329     *        |--WS[4x9] : [ ]
1330     *        |--REFERENCE[4x10] : [String]
1331     *            |--CLASS[4x10] : [String]
1332     *        |--JAVADOC_INLINE_TAG_END[4x16] : [}]
1333     * </code>
1334     * </pre>
1335     *
1336     * @noinspection HtmlTagCanBeJavadocTag
1337     * @noinspection HtmlTagCanBeJavadocTag
1338     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
1339     *      replaced with Javadoc tag
1340     */
1341    public static final int JAVADOC_INLINE_TAG = JavadocParser.RULE_javadocInlineTag
1342            + RULE_TYPES_OFFSET;
1343
1344    /**
1345     * Parameter of the Javadoc tags listed below.
1346     * <ul>
1347     * <li>{@link #SEE_LITERAL @see}</li>
1348     * <li>{@link #LINK_LITERAL &#123;&#64;link&#125;}</li>
1349     * <li>{@link #LINKPLAIN_LITERAL &#123;&#64;linkplain&#125;}</li>
1350     * <li>{@link #VALUE_LITERAL &#123;&#64;value&#125;}</li>
1351     * </ul>
1352     */
1353    public static final int REFERENCE = JavadocParser.RULE_reference + RULE_TYPES_OFFSET;
1354
1355    /**
1356     * Parameters part in {@link #REFERENCE}.
1357     * It is used to specify parameters for {@link #MEMBER method}.
1358     * Always contains {@link #LEFT_BRACE} as first child and {@link #RIGHT_BRACE} as last child.
1359     * Each parameter is represented by {@link #ARGUMENT} node.
1360     * Arguments in braces are separated by {@link #COMMA} (and optional {@link #WS}).
1361     *
1362     * <p><b>Example:</b></p>
1363     * <pre>{@code @see #method(Processor, String)}</pre>
1364     * <b>Tree:</b>
1365     * <pre>
1366     * {@code |--JAVADOC_TAG[1x0] : [@see #method(Processor, String)]
1367     *        |--SEE_LITERAL[1x0] : [@see]
1368     *        |--WS[1x4] : [ ]
1369     *        |--REFERENCE[1x5] : [#method(Processor, String)]
1370     *            |--HASH[1x5] : [#]
1371     *            |--MEMBER[1x6] : [method]
1372     *            |--PARAMETERS[1x12] : [(Processor, String)]
1373     *                |--LEFT_BRACE[1x12] : [(]
1374     *                |--ARGUMENT[1x13] : [Processor]
1375     *                |--COMMA[1x22] : [,]
1376     *                |--WS[1x23] : [ ]
1377     *                |--ARGUMENT[1x24] : [String]
1378     *                |--RIGHT_BRACE[1x30] : [)]
1379     * }
1380     * </pre>
1381     */
1382    public static final int PARAMETERS = JavadocParser.RULE_parameters + RULE_TYPES_OFFSET;
1383
1384    /**
1385     * Description node. It contains:
1386     * <ul>
1387     * <li>{@link #TEXT}</li>
1388     * <li>{@link #WS}</li>
1389     * <li>{@link #NEWLINE}</li>
1390     * <li>{@link #HTML_ELEMENT}</li>
1391     * </ul>
1392     *
1393     * <p>It is argument for many Javadoc tags and inline tags.</p>
1394     *
1395     * <p><b>Example:</b></p>
1396     * <pre>{@code @throws IOException if <b>connection</b> problems occur}</pre>
1397     * <b>Tree:</b>
1398     * <pre>
1399     * {@code |--JAVADOC_TAG[1x0] : [@throws IOException if <b>connection</b> problems occur]
1400     *        |--THROWS_LITERAL[1x0] : [@throws]
1401     *        |--WS[1x7] : [ ]
1402     *        |--CLASS_NAME[1x8] : [IOException]
1403     *        |--WS[1x19] : [ ]
1404     *        |--DESCRIPTION[1x20] : [if <b>connection</b> problems occur]
1405     *            |--TEXT[1x20] : [if ]
1406     *            |--HTML_ELEMENT[1x23] : [<b>connection</b>]
1407     *                |--HTML_TAG[1x23] : [<b>connection</b>]
1408     *                    |--HTML_ELEMENT_START[1x23] : [<b>]
1409     *                        |--START[1x23] : [<]
1410     *                        |--HTML_TAG_NAME[1x24] : [b]
1411     *                        |--END[1x25] : [>]
1412     *                    |--TEXT[1x26] : [connection]
1413     *                    |--HTML_ELEMENT_END[1x36] : [</b>]
1414     *                        |--START[1x36] : [<]
1415     *                        |--SLASH[1x37] : [/]
1416     *                        |--HTML_TAG_NAME[1x38] : [b]
1417     *                        |--END[1x39] : [>]
1418     *            |--TEXT[1x40] : [ problems occur]
1419     * }
1420     * </pre>
1421     */
1422    public static final int DESCRIPTION = JavadocParser.RULE_description + RULE_TYPES_OFFSET;
1423
1424    // ------------------------------------------------------------------------------------------ //
1425    // -------- HTML TAGS DEPENDING ON RULE TYPES OFFSET ---------------------------------------- //
1426    // ------------------------------------------------------------------------------------------ //
1427
1428    /**
1429     * Parent node for all html tags.
1430     */
1431    public static final int HTML_ELEMENT = JavadocParser.RULE_htmlElement
1432            + RULE_TYPES_OFFSET;
1433
1434    /**
1435     * Start html tag: &lt;XXXX&gt;.
1436     */
1437    public static final int HTML_ELEMENT_START = JavadocParser.RULE_htmlElementStart
1438            + RULE_TYPES_OFFSET;
1439
1440    /**
1441     * End html tag: &lt;XXXX&gt;.
1442     */
1443    public static final int HTML_ELEMENT_END = JavadocParser.RULE_htmlElementEnd
1444            + RULE_TYPES_OFFSET;
1445
1446    /**
1447     * Non-special HTML tag.
1448     */
1449    public static final int HTML_TAG = JavadocParser.RULE_htmlTag + RULE_TYPES_OFFSET;
1450
1451    /**
1452     * Html tag attribute. Parent node for: {@code HTML_TAG_IDENT, EQUALS, ATTR_VALUE}.
1453     */
1454    public static final int ATTRIBUTE = JavadocParser.RULE_attribute
1455            + RULE_TYPES_OFFSET;
1456
1457    /////////////////////// HTML TAGS WITH OPTIONAL END TAG /////////////////////////////////////
1458    /** Paragraph html tag: {@code <p></p>}. */
1459    public static final int PARAGRAPH = JavadocParser.RULE_paragraph + RULE_TYPES_OFFSET;
1460    /** Start paragraph tag. */
1461    public static final int P_TAG_START = JavadocParser.RULE_pTagStart + RULE_TYPES_OFFSET;
1462    /** End paragraph tag. */
1463    public static final int P_TAG_END = JavadocParser.RULE_pTagEnd + RULE_TYPES_OFFSET;
1464    /** List item html tag: {@code <li></li>}. */
1465
1466    public static final int LI = JavadocParser.RULE_li + RULE_TYPES_OFFSET;
1467    /** Start list item tag. */
1468    public static final int LI_TAG_START = JavadocParser.RULE_liTagStart + RULE_TYPES_OFFSET;
1469    /** End list item tag. */
1470    public static final int LI_TAG_END = JavadocParser.RULE_liTagEnd + RULE_TYPES_OFFSET;
1471
1472    /** Table row html tag: {@code <tr></tr>}. */
1473    public static final int TR = JavadocParser.RULE_tr + RULE_TYPES_OFFSET;
1474    /** Start table row tag. */
1475    public static final int TR_TAG_START = JavadocParser.RULE_trTagStart + RULE_TYPES_OFFSET;
1476    /** End table row tag. */
1477    public static final int TR_TAG_END = JavadocParser.RULE_trTagEnd + RULE_TYPES_OFFSET;
1478
1479    /** Table cell html tag: {@code <td></td>}. */
1480    public static final int TD = JavadocParser.RULE_td + RULE_TYPES_OFFSET;
1481    /** Start table cell tag. */
1482    public static final int TD_TAG_START = JavadocParser.RULE_tdTagStart + RULE_TYPES_OFFSET;
1483    /** End table cell tag. */
1484    public static final int TD_TAG_END = JavadocParser.RULE_tdTagEnd + RULE_TYPES_OFFSET;
1485
1486    /** Table header cell html tag: {@code <th></th>}. */
1487    public static final int TH = JavadocParser.RULE_th + RULE_TYPES_OFFSET;
1488    /** Start table header cell tag. */
1489    public static final int TH_TAG_START = JavadocParser.RULE_thTagStart + RULE_TYPES_OFFSET;
1490    /** End table header cell tag. */
1491    public static final int TH_TAG_END = JavadocParser.RULE_thTagEnd + RULE_TYPES_OFFSET;
1492
1493    /** Body html tag. */
1494    public static final int BODY = JavadocParser.RULE_body + RULE_TYPES_OFFSET;
1495    /** Start body tag. */
1496    public static final int BODY_TAG_START = JavadocParser.RULE_bodyTagStart + RULE_TYPES_OFFSET;
1497    /** End body tag. */
1498    public static final int BODY_TAG_END = JavadocParser.RULE_bodyTagEnd + RULE_TYPES_OFFSET;
1499
1500    /** Colgroup html tag. */
1501    public static final int COLGROUP = JavadocParser.RULE_colgroup + RULE_TYPES_OFFSET;
1502    /** Start colgroup tag. */
1503    public static final int COLGROUP_TAG_START = JavadocParser.RULE_colgroupTagStart
1504            + RULE_TYPES_OFFSET;
1505    /** End colgroup tag. */
1506    public static final int COLGROUP_TAG_END = JavadocParser.RULE_colgroupTagEnd
1507            + RULE_TYPES_OFFSET;
1508
1509    /** Description of a term html tag: {@code <dd></dd>}. */
1510    public static final int DD = JavadocParser.RULE_dd + RULE_TYPES_OFFSET;
1511    /** Start description of a term tag. */
1512    public static final int DD_TAG_START = JavadocParser.RULE_ddTagStart + RULE_TYPES_OFFSET;
1513    /** End description of a term tag. */
1514    public static final int DD_TAG_END = JavadocParser.RULE_ddTagEnd + RULE_TYPES_OFFSET;
1515
1516    /** Description term html tag: {@code <dt></dt>}. */
1517    public static final int DT = JavadocParser.RULE_dt + RULE_TYPES_OFFSET;
1518    /** Start description term tag. */
1519    public static final int DT_TAG_START = JavadocParser.RULE_dtTagStart + RULE_TYPES_OFFSET;
1520    /** End description term tag. */
1521    public static final int DT_TAG_END = JavadocParser.RULE_dtTagEnd + RULE_TYPES_OFFSET;
1522
1523    /** Head html tag. */
1524    public static final int HEAD = JavadocParser.RULE_head + RULE_TYPES_OFFSET;
1525    /** Start head tag. */
1526    public static final int HEAD_TAG_START = JavadocParser.RULE_headTagStart + RULE_TYPES_OFFSET;
1527    /** End head tag. */
1528    public static final int HEAD_TAG_END = JavadocParser.RULE_headTagEnd + RULE_TYPES_OFFSET;
1529
1530    /** Html html tag. */
1531    public static final int HTML = JavadocParser.RULE_html + RULE_TYPES_OFFSET;
1532    /** Start html tag. */
1533    public static final int HTML_TAG_START = JavadocParser.RULE_htmlTagStart + RULE_TYPES_OFFSET;
1534    /** End html tag. */
1535    public static final int HTML_TAG_END = JavadocParser.RULE_htmlTagEnd + RULE_TYPES_OFFSET;
1536
1537    /** Option html tag. */
1538    public static final int OPTION = JavadocParser.RULE_option + RULE_TYPES_OFFSET;
1539    /** Start option tag. */
1540    public static final int OPTION_TAG_START =
1541            JavadocParser.RULE_optionTagStart + RULE_TYPES_OFFSET;
1542    /** End option tag. */
1543    public static final int OPTION_TAG_END = JavadocParser.RULE_optionTagEnd
1544            + RULE_TYPES_OFFSET;
1545
1546    /** Table body html tag. */
1547    public static final int TBODY = JavadocParser.RULE_tbody + RULE_TYPES_OFFSET;
1548    /** Start table body tag. */
1549    public static final int TBODY_TAG_START = JavadocParser.RULE_tbodyTagStart + RULE_TYPES_OFFSET;
1550    /** End table body tag. */
1551    public static final int TBODY_TAG_END = JavadocParser.RULE_tbodyTagEnd + RULE_TYPES_OFFSET;
1552
1553    /** Table foot html tag. */
1554    public static final int TFOOT = JavadocParser.RULE_tfoot + RULE_TYPES_OFFSET;
1555    /** Start table foot tag. */
1556    public static final int TFOOT_TAG_START = JavadocParser.RULE_tfootTagStart + RULE_TYPES_OFFSET;
1557    /** End table foot tag. */
1558    public static final int TFOOT_TAG_END = JavadocParser.RULE_tfootTagEnd + RULE_TYPES_OFFSET;
1559
1560    /** Table head html tag. */
1561    public static final int THEAD = JavadocParser.RULE_thead + RULE_TYPES_OFFSET;
1562    /** Start table head tag. */
1563    public static final int THEAD_TAG_START = JavadocParser.RULE_theadTagStart + RULE_TYPES_OFFSET;
1564    /** End table head tag. */
1565    public static final int THEAD_TAG_END = JavadocParser.RULE_theadTagEnd + RULE_TYPES_OFFSET;
1566
1567    /** `optgroup` html tag. */
1568    public static final int OPTGROUP = JavadocParser.RULE_optgroup + RULE_TYPES_OFFSET;
1569    /** `optgroup` tag start. */
1570    public static final int OPTGROUP_TAG_START =
1571            JavadocParser.RULE_optgroupTagStart + RULE_TYPES_OFFSET;
1572    /** `optgroup` tag end. */
1573    public static final int OPTGROUP_TAG_END =
1574            JavadocParser.RULE_optgroupTagEnd + RULE_TYPES_OFFSET;
1575
1576    /** `rb` html tag. */
1577    public static final int RB = JavadocParser.RULE_rb + RULE_TYPES_OFFSET;
1578    /** `rb` tag start. */
1579    public static final int RB_TAG_START =
1580            JavadocParser.RULE_rbTagStart + RULE_TYPES_OFFSET;
1581    /** `rb` tag end. */
1582    public static final int RB_TAG_END =
1583            JavadocParser.RULE_rbTagEnd + RULE_TYPES_OFFSET;
1584
1585    /** `rt` html tag. */
1586    public static final int RT = JavadocParser.RULE_rt + RULE_TYPES_OFFSET;
1587    /** `rt` tag start. */
1588    public static final int RT_TAG_START =
1589            JavadocParser.RULE_rtTagStart + RULE_TYPES_OFFSET;
1590    /** `rt` tag end. */
1591    public static final int RT_TAG_END =
1592            JavadocParser.RULE_rtTagEnd + RULE_TYPES_OFFSET;
1593
1594    /** `rtc` html tag. */
1595    public static final int RTC = JavadocParser.RULE_rtc + RULE_TYPES_OFFSET;
1596    /** `rtc` tag start. */
1597    public static final int RTC_TAG_START =
1598            JavadocParser.RULE_rtcTagStart + RULE_TYPES_OFFSET;
1599    /** `rtc` tag end. */
1600    public static final int RTC_TAG_END =
1601            JavadocParser.RULE_rtcTagEnd + RULE_TYPES_OFFSET;
1602
1603    /** `rp` html tag. */
1604    public static final int RP = JavadocParser.RULE_rp + RULE_TYPES_OFFSET;
1605    /** `rp` tag start. */
1606    public static final int RP_TAG_START =
1607            JavadocParser.RULE_rpTagStart + RULE_TYPES_OFFSET;
1608    /** `rp` tag end. */
1609    public static final int RP_TAG_END =
1610            JavadocParser.RULE_rpTagEnd + RULE_TYPES_OFFSET;
1611
1612    /////////////////////// SINGLETON HTML TAGS  //////////////////////////////////////////////////
1613    /**
1614     * Parent node for all singleton html tags.
1615     */
1616    public static final int SINGLETON_ELEMENT = JavadocParser.RULE_singletonElement
1617            + RULE_TYPES_OFFSET;
1618
1619    /**
1620     * Non-special empty html tag.
1621     */
1622    public static final int EMPTY_TAG = JavadocParser.RULE_emptyTag
1623            + RULE_TYPES_OFFSET;
1624
1625    /** Area html tag. */
1626    public static final int AREA_TAG = JavadocParser.RULE_areaTag + RULE_TYPES_OFFSET;
1627
1628    /** Base html tag. */
1629    public static final int BASE_TAG = JavadocParser.RULE_baseTag + RULE_TYPES_OFFSET;
1630
1631    /** Basefont html tag. */
1632    public static final int BASEFONT_TAG = JavadocParser.RULE_basefontTag + RULE_TYPES_OFFSET;
1633
1634    /** Br html tag. */
1635    public static final int BR_TAG = JavadocParser.RULE_brTag + RULE_TYPES_OFFSET;
1636
1637    /** Col html tag. */
1638    public static final int COL_TAG = JavadocParser.RULE_colTag + RULE_TYPES_OFFSET;
1639
1640    /** Frame html tag. */
1641    public static final int FRAME_TAG = JavadocParser.RULE_frameTag + RULE_TYPES_OFFSET;
1642
1643    /** Hr html tag. */
1644    public static final int HR_TAG = JavadocParser.RULE_hrTag + RULE_TYPES_OFFSET;
1645
1646    /** Img html tag. */
1647    public static final int IMG_TAG = JavadocParser.RULE_imgTag + RULE_TYPES_OFFSET;
1648
1649    /** Input html tag. */
1650    public static final int INPUT_TAG = JavadocParser.RULE_inputTag + RULE_TYPES_OFFSET;
1651
1652    /** Isindex html tag. */
1653    public static final int ISINDEX_TAG = JavadocParser.RULE_isindexTag + RULE_TYPES_OFFSET;
1654
1655    /** Link html tag. */
1656    public static final int LINK_TAG = JavadocParser.RULE_linkTag + RULE_TYPES_OFFSET;
1657
1658    /** Meta html tag. */
1659    public static final int META_TAG = JavadocParser.RULE_metaTag + RULE_TYPES_OFFSET;
1660
1661    /** Param html tag. */
1662    public static final int PARAM_TAG = JavadocParser.RULE_paramTag + RULE_TYPES_OFFSET;
1663
1664    /**
1665     * HTML void element {@code <embed>}.
1666     *
1667     * @see #SINGLETON_ELEMENT
1668     * @see <a href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-embed">
1669     *     W3 docs</a>
1670     */
1671    public static final int EMBED_TAG = JavadocParser.RULE_embedTag + RULE_TYPES_OFFSET;
1672
1673    /**
1674     * HTML void element {@code <keygen>}.
1675     *
1676     * @see #SINGLETON_ELEMENT
1677     * @see <a href="https://www.w3.org/TR/html51/sec-forms.html#elementdef-keygen">
1678     *     W3 docs</a>
1679     */
1680    public static final int KEYGEN_TAG = JavadocParser.RULE_keygenTag + RULE_TYPES_OFFSET;
1681
1682    /**
1683     * HTML void element {@code <source>}.
1684     *
1685     * @see #SINGLETON_ELEMENT
1686     * @see <a href=
1687     *     "https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-media-source">
1688     *     W3 docs</a>
1689     */
1690    public static final int SOURCE_TAG = JavadocParser.RULE_sourceTag + RULE_TYPES_OFFSET;
1691
1692    /**
1693     * HTML void element {@code <track>}.
1694     *
1695     * @see #SINGLETON_ELEMENT
1696     * @see <a
1697     *     href="https://www.w3.org/TR/html51/semantics-embedded-content.html#elementdef-track">
1698     *     W3 docs</a>
1699     */
1700    public static final int TRACK_TAG = JavadocParser.RULE_trackTag + RULE_TYPES_OFFSET;
1701
1702    /**
1703     * HTML void element {@code <wbr>}.
1704     *
1705     * @see #SINGLETON_ELEMENT
1706     * @see <a href="https://www.w3.org/TR/html51/textlevel-semantics.html#elementdef-wbr">
1707     *     W3 docs</a>
1708     */
1709    public static final int WBR_TAG = JavadocParser.RULE_wbrTag + RULE_TYPES_OFFSET;
1710
1711    ///////////////////////////////////////////////////////////////////////////////////////////////
1712
1713    /**
1714     * Html comment: <code>&lt;&#33;-- --&gt;</code>.
1715     *
1716     * @noinspection HtmlTagCanBeJavadocTag
1717     * @noinspectionreason HtmlTagCanBeJavadocTag - encoded symbols were not decoded when
1718     *      replaced with Javadoc tag
1719     */
1720    public static final int HTML_COMMENT = JavadocParser.RULE_htmlComment
1721            + RULE_TYPES_OFFSET;
1722    /**
1723     * CHAR and WS sequence.
1724     */
1725    public static final int TEXT = JavadocParser.RULE_text + RULE_TYPES_OFFSET;
1726
1727    /** Empty private constructor of the current class. */
1728    private JavadocTokenTypes() {
1729    }
1730
1731}