parserimpl.java

windows 代码

                    }

                    lexer.ungetToken();
                    Report.warning(lexer, element, node, Report.MISSING_ENDTAG_BEFORE);
                    lexer.popInline( element);
                    if (!((mode & Lexer.Preformatted) != 0))
                        Node.trimSpaces(lexer, element);
                    Node.trimEmptyElement(lexer, element);
                    return;
                }

                if ((element.tag.model & Dict.CM_HEADING) != 0)
                {
                    if (node.tag == TagTable.tagCenter ||
                        node.tag == TagTable.tagDiv)
                    {
                        if (node.type != Node.StartTag &&
                            node.type != Node.StartEndTag)
                        {
                            Report.warning(lexer, element, node, Report.DISCARDING_UNEXPECTED);
                            continue;
                        }

                        Report.warning(lexer, element, node, Report.TAG_NOT_ALLOWED_IN);

                        /* insert center as parent if heading is empty */
                        if (element.content == null)
                        {
                            Node.insertNodeAsParent(element, node);
                            continue;
                        }

                        /* split heading and make center parent of 2nd part */
                        Node.insertNodeAfterElement(element, node);

                        if (!((mode & Lexer.Preformatted) != 0))
                            Node.trimSpaces(lexer, element);

                        element = lexer.cloneNode(element);
                        element.start = lexer.lexsize;
                        element.end   = lexer.lexsize;
                        Node.insertNodeAtEnd(node, element);
                        continue;
                    }

                    if (node.tag == TagTable.tagHr)
                    {
                        if (node.type != Node.StartTag &&
                            node.type != Node.StartEndTag)
                        {
                            Report.warning(lexer, element, node, Report.DISCARDING_UNEXPECTED);
                            continue;
                        }

                        Report.warning(lexer, element, node, Report.TAG_NOT_ALLOWED_IN);

                        /* insert hr before heading if heading is empty */
                        if (element.content == null)
                        {
                            Node.insertNodeBeforeElement(element, node);
                            continue;
                        }

                        /* split heading and insert hr before 2nd part */
                        Node.insertNodeAfterElement(element, node);

                        if (!((mode & Lexer.Preformatted) != 0))
                            Node.trimSpaces(lexer, element);

                        element = lexer.cloneNode(element);
                        element.start = lexer.lexsize;
                        element.end   = lexer.lexsize;
                        Node.insertNodeAfterElement(node, element);
                        continue;
                    }
                }

                if (element.tag == TagTable.tagDt)
                {
                    if (node.tag == TagTable.tagHr)
                    {
                        Node dd;

                        if (node.type != Node.StartTag &&
                            node.type != Node.StartEndTag)
                        {
                            Report.warning(lexer, element, node, Report.DISCARDING_UNEXPECTED);
                            continue;
                        }

                        Report.warning(lexer, element, node, Report.TAG_NOT_ALLOWED_IN);
                        dd = lexer.inferredTag("dd");

                        /* insert hr within dd before dt if dt is empty */
                        if (element.content == null)
                        {
                            Node.insertNodeBeforeElement(element, dd);
                            Node.insertNodeAtEnd(dd, node);
                            continue;
                        }

                        /* split dt and insert hr within dd before 2nd part */
                        Node.insertNodeAfterElement(element, dd);
                        Node.insertNodeAtEnd(dd, node);

                        if (!((mode & Lexer.Preformatted) != 0))
                            Node.trimSpaces(lexer, element);

                        element = lexer.cloneNode(element);
                        element.start = lexer.lexsize;
                        element.end   = lexer.lexsize;
                        Node.insertNodeAfterElement(dd, element);
                        continue;
                    }
                }


                /* 
                  if this is the end tag for an ancestor element
                  then infer end tag for this element
                */
                if (node.type == Node.EndTag)
                {
                    for (parent = element.parent;
                            parent != null; parent = parent.parent)
                    {
                        if (node.tag == parent.tag)
                        {
                            if (!((element.tag.model & Dict.CM_OPT) != 0) &&
                                !element.implicit)
                                Report.warning(lexer, element, node, Report.MISSING_ENDTAG_BEFORE);

                            if (element.tag == TagTable.tagA)
                                lexer.popInline(element);

                            lexer.ungetToken();

                            if (!((mode & Lexer.Preformatted) != 0))
                                Node.trimSpaces(lexer, element);

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

                /* block level tags end this element */
                if (!((node.tag.model & Dict.CM_INLINE) != 0))
                {
                    if (node.type != Node.StartTag)
                    {
                        Report.warning(lexer, element, node, Report.DISCARDING_UNEXPECTED);
                        continue;
                    }

                    if (!((element.tag.model & Dict.CM_OPT) != 0))
                        Report.warning(lexer, element, node, Report.MISSING_ENDTAG_BEFORE);

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

                    /*
                       prevent anchors from propagating into block tags
                       except for headings h1 to h6
                    */
                    if (element.tag == TagTable.tagA)
                    {
                        if (node.tag != null &&
                            !((node.tag.model & Dict.CM_HEADING) != 0))
                            lexer.popInline(element);
                        else if (!(element.content != null))
                        {
                            Node.discardElement(element);
                            lexer.ungetToken();
                            return;
                        }
                    }

                    lexer.ungetToken();

                    if (!((mode & Lexer.Preformatted) != 0))
                        Node.trimSpaces(lexer, element);

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

                /* parse inline element */
                if (node.type == Node.StartTag || node.type == Node.StartEndTag)
                {
                    if (node.implicit)
                        Report.warning(lexer, element, node, Report.INSERTING_TAG);

                    /* trim white space before <br> */
                    if (node.tag == TagTable.tagBr)
                        Node.trimSpaces(lexer, element);
            
                    Node.insertNodeAtEnd(element, node);
                    parseTag(lexer, node, mode);
                    continue;
                }

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

            if (!((element.tag.model & Dict.CM_OPT) != 0))
                Report.warning(lexer, element, node, Report.MISSING_ENDTAG_FOR);

            Node.trimEmptyElement(lexer, element);
        }
    };

    public static class ParseList implements Parser {

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

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

            lexer.insert = -1;  /* defer implicit inline start tags */

            while (true)
            {
                node = lexer.getToken(Lexer.IgnoreWhitespace);
                if (node == null) break;

                if (node.tag == list.tag && node.type == Node.EndTag)
                {
                    if ((list.tag.model & Dict.CM_OBSOLETE) != 0)
                        Node.coerceNode(lexer, list, TagTable.tagUl);

                    list.closed = true;
                    Node.trimEmptyElement(lexer, list);
                    return;
                }

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

                if (node.type != Node.TextNode && 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;
                    }

                    if (node.tag != null && (node.tag.model & Dict.CM_INLINE) != 0)
                    {
                        Report.warning(lexer, list, node, Report.DISCARDING_UNEXPECTED);
                        lexer.popInline(node);
                        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();

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

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

                    Report.warning(lexer, list, node, Report.DISCARDING_UNEXPECTED);
                    continue;
                }

                if (node.tag != TagTable.tagLi)
                {
                    lexer.ungetToken();

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

                    node = lexer.inferredTag("li");
                    node.addAttribute("style", "list-style: none");
                    Report.warning(lexer, list, node, Report.MISSING_STARTTAG);
                }

                /* node should be <LI> */
                Node.insertNodeAtEnd(list, node);
                parseTag(lexer, node, Lexer.IgnoreWhitespace);
            }

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

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

    };

    public static class ParseDefList implements Parser {

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

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

            lexer.insert = -1;  /* defer implicit inline start tags */

            while (true)
            {
                node = lexer.getToken(Lexer.IgnoreWhitespace);
                if (node == null) break;
                if (node.tag == list.tag && node.type == Node.EndTag)
                {
                    list.closed = true;