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