parserimpl.java

windows 代码

                    Node.trimEmptyElement(lexer, list);
                    return;
                }

                /* deal with comments etc. */
                if (Node.insertMisc(list, node))
                    continue;

                if (node.type == Node.TextNode)
                {
                    lexer.ungetToken();
                    node = lexer.inferredTag( "dt");
                    Report.warning(lexer, list, node, Report.MISSING_STARTTAG);
                }

                if (node.tag == null)
                {
                    Report.warning(lexer, list, node, Report.DISCARDING_UNEXPECTED);
                    continue;
                }

                /* 
                  if this is the end tag for an ancestor element
                  then infer end tag for this element
                */
                if (node.type == Node.EndTag)
                {
                    if (node.tag == TagTable.tagForm)
                    {
                        lexer.badForm = 1;
                        Report.warning(lexer, list, node, Report.DISCARDING_UNEXPECTED);
                        continue;
                    }

                    for (parent = list.parent;
                            parent != null; parent = parent.parent)
                    {
                        if (node.tag == parent.tag)
                        {
                            Report.warning(lexer, list, node, Report.MISSING_ENDTAG_BEFORE);

                            lexer.ungetToken();
                            Node.trimEmptyElement(lexer, list);
                            return;
                        }
                    }
                }

                /* center in a dt or a dl breaks the dl list in two */
                if (node.tag == TagTable.tagCenter)
                {
                    if (list.content != null)
                        Node.insertNodeAfterElement(list, node);
                    else /* trim empty dl list */
                    {
                        Node.insertNodeBeforeElement(list, node);
                        Node.discardElement(list);
                    }

                    /* and parse contents of center */
                    parseTag(lexer, node, mode);

                    /* now create a new dl element */
                    list = lexer.inferredTag("dl");
                    Node.insertNodeAfterElement(node, list);
                    continue;
                }

                if (!(node.tag == TagTable.tagDt || node.tag == TagTable.tagDd))
                {
                    lexer.ungetToken();

                    if (!((node.tag.model & (Dict.CM_BLOCK | Dict.CM_INLINE)) != 0))
                    {
                        Report.warning(lexer, list, node, Report.TAG_NOT_ALLOWED_IN);
                        Node.trimEmptyElement(lexer, list);
                        return;
                    }

                    /* if DD appeared directly in BODY then exclude blocks */
                    if (!((node.tag.model & Dict.CM_INLINE) != 0) && lexer.excludeBlocks)
                    {
                        Node.trimEmptyElement(lexer, list);
                        return;
                    }

                    node = lexer.inferredTag( "dd");
                    Report.warning(lexer, list, node, Report.MISSING_STARTTAG);
                }

                if (node.type == Node.EndTag)
                {
                    Report.warning(lexer, list, node, Report.DISCARDING_UNEXPECTED);
                    continue;
                }
        
                /* node should be <DT> or <DD>*/
                Node.insertNodeAtEnd(list, node);
                parseTag(lexer, node, Lexer.IgnoreWhitespace);
            }

            Report.warning(lexer, list, node, Report.MISSING_ENDTAG_FOR);
            Node.trimEmptyElement(lexer, list);
        }

    };

    public static class ParsePre implements Parser {

        public void parse( Lexer lexer, Node pre, short mode )
        {
            Node node, parent;

            if ((pre.tag.model & Dict.CM_EMPTY) != 0)
                return;

            if ((pre.tag.model & Dict.CM_OBSOLETE) != 0)
                Node.coerceNode(lexer, pre, TagTable.tagPre);

            lexer.inlineDup( null); /* tell lexer to insert inlines if needed */

            while (true)
            {
                node = lexer.getToken(Lexer.Preformatted);
                if (node == null) break;
                if (node.tag == pre.tag && node.type == Node.EndTag)
                {
                    Node.trimSpaces(lexer, pre);
                    pre.closed = true;
                    Node.trimEmptyElement(lexer, pre);
                    return;
                }

                if (node.tag == TagTable.tagHtml)
                {
                    if (node.type == Node.StartTag || node.type == Node.StartEndTag)
                        Report.warning(lexer, pre, node, Report.DISCARDING_UNEXPECTED);

                    continue;
                }

                if (node.type == Node.TextNode)
                {
                    /* if first check for inital newline */
                    if (pre.content == null)
                    {
                        if (node.textarray[node.start] == (byte)'\n')
                            ++node.start;

                        if (node.start >= node.end)
                        {
                            continue;
                        }
                    }

                    Node.insertNodeAtEnd(pre, node);
                    continue;
                }

                /* deal with comments etc. */
                if (Node.insertMisc(pre, node))
                    continue;

                /* discard unknown  and PARAM tags */
                if (node.tag == null || node.tag == TagTable.tagParam)
                {
                    Report.warning(lexer, pre, node, Report.DISCARDING_UNEXPECTED);
                    continue;
                }

                if (node.tag == TagTable.tagP)
                {
                    if (node.type == Node.StartTag)
                    {
                        Report.warning(lexer, pre, node, Report.USING_BR_INPLACE_OF);

                        /* trim white space before <p> in <pre>*/
                        Node.trimSpaces(lexer, pre);
            
                        /* coerce both <p> and </p> to <br> */
                        Node.coerceNode(lexer, node, TagTable.tagBr);
                        Node.insertNodeAtEnd(pre, node);
                    }
                    else
                    {
                        Report.warning(lexer, pre, node, Report.DISCARDING_UNEXPECTED);
                    }
                    continue;
                }

                if ((node.tag.model & Dict.CM_HEAD) != 0 && !((node.tag.model & Dict.CM_BLOCK) != 0))
                {
                    moveToHead(lexer, pre, node);
                    continue;
                }

                /* 
                  if this is the end tag for an ancestor element
                  then infer end tag for this element
                */
                if (node.type == Node.EndTag)
                {
                    if (node.tag == TagTable.tagForm)
                    {
                        lexer.badForm = 1;
                        Report.warning(lexer, pre, node, Report.DISCARDING_UNEXPECTED);
                        continue;
                    }

                    for (parent = pre.parent;
                            parent != null; parent = parent.parent)
                    {
                        if (node.tag == parent.tag)
                        {
                            Report.warning(lexer, pre, node, Report.MISSING_ENDTAG_BEFORE);

                            lexer.ungetToken();
                            Node.trimSpaces(lexer, pre);
                            Node.trimEmptyElement(lexer, pre);
                            return;
                        }
                    }
                }

                /* what about head content, HEAD, BODY tags etc? */
                if (!((node.tag.model & Dict.CM_INLINE) != 0))
                {
                    if (node.type != Node.StartTag)
                    {
                        Report.warning(lexer, pre, node, Report.DISCARDING_UNEXPECTED);
                        continue;
                    }
 
                    Report.warning(lexer, pre, node, Report.MISSING_ENDTAG_BEFORE);
                    lexer.excludeBlocks = true;

                    /* check if we need to infer a container */
                    if ((node.tag.model & Dict.CM_LIST) != 0)
                    {
                        lexer.ungetToken();
                        node = lexer.inferredTag( "ul");
                        Node.addClass(node, "noindent");
                    }
                    else if ((node.tag.model & Dict.CM_DEFLIST) != 0)
                    {
                        lexer.ungetToken();
                        node = lexer.inferredTag( "dl");
                    }
                    else if ((node.tag.model & Dict.CM_TABLE) != 0)
                    {
                        lexer.ungetToken();
                        node = lexer.inferredTag( "table");
                    }

                    Node.insertNodeAfterElement(pre, node);
                    pre = lexer.inferredTag( "pre");
                    Node.insertNodeAfterElement(node, pre);
                    parseTag(lexer, node, Lexer.IgnoreWhitespace);
                    lexer.excludeBlocks = false;
                    continue;
                }
                /*
                if (!((node.tag.model & Dict.CM_INLINE) != 0))
                {
                    Report.warning(lexer, pre, node, Report.MISSING_ENDTAG_BEFORE);
                    lexer.ungetToken();
                    return;
                }
                */
                if (node.type == Node.StartTag || node.type == Node.StartEndTag)
                {
                    /* trim white space before <br> */
                    if (node.tag == TagTable.tagBr)
                        Node.trimSpaces(lexer, pre);
            
                    Node.insertNodeAtEnd(pre, node);
                    parseTag(lexer, node, Lexer.Preformatted);
                    continue;
                }

                /* discard unexpected tags */
                Report.warning(lexer, pre, node, Report.DISCARDING_UNEXPECTED);
            }

            Report.warning(lexer, pre, node, Report.MISSING_ENDTAG_FOR);
            Node.trimEmptyElement(lexer, pre);
        }

    };

    public static class ParseBlock implements Parser {

        public void parse( Lexer lexer, Node element, short mode )
        /*
           element is node created by the lexer
           upon seeing the start tag, or by the
           parser when the start tag is inferred
        */
        {
            Node node, parent;
            boolean checkstack;
            int istackbase = 0;

            checkstack = true;

            if ((element.tag.model & Dict.CM_EMPTY) != 0)
                return;

            if (element.tag == TagTable.tagForm && element.isDescendantOf(TagTable.tagForm))
                Report.warning(lexer, element, null, Report.ILLEGAL_NESTING);

            /*
             InlineDup() asks the lexer to insert inline emphasis tags
             currently pushed on the istack, but take care to avoid
             propagating inline emphasis inside OBJECT or APPLET.
             For these elements a fresh inline stack context is created
             and disposed of upon reaching the end of the element.
             They thus behave like table cells in this respect.
            */
            if ((element.tag.model & Dict.CM_OBJECT) != 0)
            {
                istackbase = lexer.istackbase;
                lexer.istackbase = lexer.istack.size();
            }

            if (!((element.tag.model & Dict.CM_MIXED) != 0))
                lexer.inlineDup( null);

            mode = Lexer.IgnoreWhitespace;

            while (true)
            {
                node = lexer.getToken(mode /*Lexer.MixedContent*/);
                if (node == null) break;
                /* end tag for this element */
                if (node.type == Node.EndTag && node.tag != null &&
                    (node.tag == element.tag || element.was == node.tag))
                {

                    if ((element.tag.model & Dict.CM_OBJECT) != 0)
                    {
                        /* pop inline stack */
                        while (lexer.istack.size() > lexer.istackbase)