html: parse misnested formatting tags according to the HTML5 spec.

This is the "adoption agency" algorithm. The test case input is "<a><p>X<a>Y</a>Z</p></a>". The correct parse is: | <html> | <head> | <body> | <a> | <p> | <a> | "X" | <a> | "Y" | "Z" R=gri CC=golang-dev https://golang.org/cl/4771042

html: parse misnested formatting tags according to the HTML5 spec.
This is the "adoption agency" algorithm. The test case input is "<a><p>X<a>Y</a>Z</p></a>". The correct parse is: | <html> | <head> | <body> | <a> | <p> | <a> | "X" | <a> | "Y" | "Z" R=gri CC=golang-dev https://golang.org/cl/4771042
5a141064 · Nigel Tao · d11c0f1d · 5a141064 · 5a141064 · 5a141064
Commit 5a141064 authored Jul 21, 2011 by Nigel Tao
5 changed files
--- a/src/pkg/html/Makefile
+++ b/src/pkg/html/Makefile
@@ -6,9 +6,11 @@ include ../../Make.inc
 TARG=html
 GOFILES=\
+	const.go\
 	doc.go\
 	entity.go\
 	escape.go\
+	node.go\
 	parse.go\
 	token.go\

--- a/src/pkg/html/const.go
+++ b/src/pkg/html/const.go
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+package html
+// Section 11.2.3.2 of the HTML5 specification says "The following elements
+// have varying levels of special parsing rules".
+// http://www.whatwg.org/specs/web-apps/current-work/multipage/parsing.html#the-stack-of-open-elements
+var isSpecialElement = map[string]bool{
+	"address":    true,
+	"applet":     true,
+	"area":       true,
+	"article":    true,
+	"aside":      true,
+	"base":       true,
+	"basefont":   true,
+	"bgsound":    true,
+	"blockquote": true,
+	"body":       true,
+	"br":         true,
+	"button":     true,
+	"caption":    true,
+	"center":     true,
+	"col":        true,
+	"colgroup":   true,
+	"command":    true,
+	"dd":         true,
+	"details":    true,
+	"dir":        true,
+	"div":        true,
+	"dl":         true,
+	"dt":         true,
+	"embed":      true,
+	"fieldset":   true,
+	"figcaption": true,
+	"figure":     true,
+	"footer":     true,
+	"form":       true,
+	"frame":      true,
+	"frameset":   true,
+	"h1":         true,
+	"h2":         true,
+	"h3":         true,
+	"h4":         true,
+	"h5":         true,
+	"h6":         true,
+	"head":       true,
+	"header":     true,
+	"hgroup":     true,
+	"hr":         true,
+	"html":       true,
+	"iframe":     true,
+	"img":        true,
+	"input":      true,
+	"isindex":    true,
+	"li":         true,
+	"link":       true,
+	"listing":    true,
+	"marquee":    true,
+	"menu":       true,
+	"meta":       true,
+	"nav":        true,
+	"noembed":    true,
+	"noframes":   true,
+	"noscript":   true,
+	"object":     true,
+	"ol":         true,
+	"p":          true,
+	"param":      true,
+	"plaintext":  true,
+	"pre":        true,
+	"script":     true,
+	"section":    true,
+	"select":     true,
+	"style":      true,
+	"summary":    true,
+	"table":      true,
+	"tbody":      true,
+	"td":         true,
+	"textarea":   true,
+	"tfoot":      true,
+	"th":         true,
+	"thead":      true,
+	"title":      true,
+	"tr":         true,
+	"ul":         true,
+	"wbr":        true,
+	"xmp":        true,
+}
--- a/src/pkg/html/node.go
+++ b/src/pkg/html/node.go
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+package html
+// A NodeType is the type of a Node.
+type NodeType int
+const (
+	ErrorNode NodeType = iota
+	TextNode
+	DocumentNode
+	ElementNode
+	CommentNode
+	scopeMarkerNode
+)
+// Section 11.2.3.3 says "scope markers are inserted when entering applet
+// elements, buttons, object elements, marquees, table cells, and table
+// captions, and are used to prevent formatting from 'leaking'".
+var scopeMarker = Node{Type: scopeMarkerNode}
+// A Node consists of a NodeType and some Data (tag name for element nodes,
+// content for text) and are part of a tree of Nodes. Element nodes may also
+// contain a slice of Attributes. Data is unescaped, so that it looks like
+// "a<b" rather than "a&lt;b".
+type Node struct {
+	Parent *Node
+	Child  []*Node
+	Type   NodeType
+	Data   string
+	Attr   []Attribute
+}
+// Add adds a node as a child of n.
+// It will panic if the child's parent is not nil.
+func (n *Node) Add(child *Node) {
+	if child.Parent != nil {
+		panic("html: Node.Add called for a child Node that already has a parent")
+	}
+	child.Parent = n
+	n.Child = append(n.Child, child)
+}
+// Remove removes a node as a child of n.
+// It will panic if the child's parent is not n.
+func (n *Node) Remove(child *Node) {
+	if child.Parent == n {
+		child.Parent = nil
+		for i, m := range n.Child {
+			if m == child {
+				copy(n.Child[i:], n.Child[i+1:])
+				j := len(n.Child) - 1
+				n.Child[j] = nil
+				n.Child = n.Child[:j]
+				return
+			}
+		}
+	}
+	panic("html: Node.Remove called for a non-child Node")
+}
+// reparentChildren reparents all of src's child nodes to dst.
+func reparentChildren(dst, src *Node) {
+	for _, n := range src.Child {
+		if n.Parent != src {
+			panic("html: nodes have an inconsistent parent/child relationship")
+		}
+		n.Parent = dst
+	}
+	dst.Child = append(dst.Child, src.Child...)
+	src.Child = nil
+}
+// clone returns a new node with the same type, data and attributes.
+// The clone has no parent and no children.
+func (n *Node) clone() *Node {
+	m := &Node{
+		Type: n.Type,
+		Data: n.Data,
+		Attr: make([]Attribute, len(n.Attr)),
+	}
+	copy(m.Attr, n.Attr)
+	return m
+}
+// nodeStack is a stack of nodes.
+type nodeStack []*Node
+// pop pops the stack. It will panic if s is empty.
+func (s *nodeStack) pop() *Node {
+	i := len(*s)
+	n := (*s)[i-1]
+	*s = (*s)[:i-1]
+	return n
+}
+// top returns the most recently pushed node, or nil if s is empty.
+func (s *nodeStack) top() *Node {
+	if i := len(*s); i > 0 {
+		return (*s)[i-1]
+	}
+	return nil
+}
+// index returns the index of the top-most occurence of n in the stack, or -1
+// if n is not present.
+func (s *nodeStack) index(n *Node) int {
+	for i := len(*s) - 1; i >= 0; i-- {
+		if (*s)[i] == n {
+			return i
+		}
+	}
+	return -1
+}
+// insert inserts a node at the given index.
+func (s *nodeStack) insert(i int, n *Node) {
+	(*s) = append(*s, nil)
+	copy((*s)[i+1:], (*s)[i:])
+	(*s)[i] = n
+}
+// remove removes a node from the stack. It is a no-op if n is not present.
+func (s *nodeStack) remove(n *Node) {
+	i := s.index(n)
+	if i == -1 {
+		return
+	}
+	copy((*s)[i:], (*s)[i+1:])
+	j := len(*s) - 1
+	(*s)[j] = nil
+	*s = (*s)[:j]
+}
+// forTag returns the top-most element node with the given tag.
+func (s *nodeStack) forTag(tag string) *Node {
+	for i := len(*s) - 1; i >= 0; i-- {
+		n := (*s)[i]
+		if n.Type == ElementNode && n.Data == tag {
+			return n
+		}
+	}
+	return nil
+}
--- a/src/pkg/html/parse.go
+++ b/src/pkg/html/parse.go
--- a/src/pkg/html/parse_test.go
+++ b/src/pkg/html/parse_test.go
@@ -85,6 +85,8 @@ func dumpLevel(w io.Writer, n *Node, level int) os.Error {
 		fmt.Fprintf(w, "%q", EscapeString(n.Data))
 	case CommentNode:
 		return os.NewError("COMMENT")
+	case scopeMarkerNode:
+		return os.NewError("unexpected scopeMarkerNode")
 	default:
 		return os.NewError("unknown node type")
 	}
@@ -119,7 +121,7 @@ func TestParser(t *testing.T) {
 		rc := make(chan io.Reader)
 		go readDat(filename, rc)
 		// TODO(nigeltao): Process all test cases, not just a subset.
-		for i := 0; i < 22; i++ {
+		for i := 0; i < 23; i++ {
 			// Parse the #data section.
 			b, err := ioutil.ReadAll(<-rc)
 			if err != nil {