2010-12-06 18:02:36 -07:00
|
|
|
// Copyright 2010 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
|
|
|
|
|
|
|
|
import (
|
|
|
|
"io"
|
|
|
|
"os"
|
|
|
|
)
|
|
|
|
|
|
|
|
// A NodeType is the type of a Node.
|
|
|
|
type NodeType int
|
|
|
|
|
|
|
|
const (
|
|
|
|
ErrorNode NodeType = iota
|
|
|
|
TextNode
|
|
|
|
DocumentNode
|
|
|
|
ElementNode
|
|
|
|
CommentNode
|
|
|
|
)
|
|
|
|
|
|
|
|
// 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<b".
|
|
|
|
type Node struct {
|
|
|
|
Parent *Node
|
|
|
|
Child []*Node
|
|
|
|
Type NodeType
|
|
|
|
Data string
|
|
|
|
Attr []Attribute
|
|
|
|
}
|
|
|
|
|
|
|
|
// A parser implements the HTML5 parsing algorithm:
|
|
|
|
// http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#tree-construction
|
|
|
|
type parser struct {
|
|
|
|
// tokenizer provides the tokens for the parser.
|
|
|
|
tokenizer *Tokenizer
|
|
|
|
// tok is the most recently read token.
|
|
|
|
tok Token
|
|
|
|
// Self-closing tags like <hr/> are re-interpreted as a two-token sequence:
|
|
|
|
// <hr> followed by </hr>. hasSelfClosingToken is true if we have just read
|
|
|
|
// the synthetic start tag and the next one due is the matching end tag.
|
|
|
|
hasSelfClosingToken bool
|
|
|
|
// doc is the document root element.
|
|
|
|
doc *Node
|
|
|
|
// The stack of open elements (section 10.2.3.2).
|
|
|
|
stack []*Node
|
|
|
|
// Element pointers (section 10.2.3.4).
|
|
|
|
head, form *Node
|
|
|
|
// Other parsing state flags (section 10.2.3.5).
|
|
|
|
scripting, framesetOK bool
|
|
|
|
}
|
|
|
|
|
|
|
|
// pop pops the top of the stack of open elements.
|
|
|
|
// It will panic if the stack is empty.
|
|
|
|
func (p *parser) pop() *Node {
|
|
|
|
n := len(p.stack)
|
|
|
|
ret := p.stack[n-1]
|
|
|
|
p.stack = p.stack[:n-1]
|
|
|
|
return ret
|
|
|
|
}
|
|
|
|
|
|
|
|
// push pushes onto the stack of open elements.
|
|
|
|
func (p *parser) push(n *Node) {
|
|
|
|
p.stack = append(p.stack, n)
|
|
|
|
}
|
|
|
|
|
|
|
|
// top returns the top of the stack of open elements.
|
|
|
|
// This is also known as the current node.
|
|
|
|
func (p *parser) top() *Node {
|
|
|
|
if n := len(p.stack); n > 0 {
|
|
|
|
return p.stack[n-1]
|
|
|
|
}
|
|
|
|
return p.doc
|
|
|
|
}
|
|
|
|
|
|
|
|
// addChild adds a child node n to the top element, and pushes n
|
|
|
|
// if it is an element node (text nodes do not have children).
|
|
|
|
func (p *parser) addChild(n *Node) {
|
|
|
|
m := p.top()
|
|
|
|
m.Child = append(m.Child, n)
|
|
|
|
if n.Type == ElementNode {
|
|
|
|
p.push(n)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// addText adds text to the current node.
|
|
|
|
func (p *parser) addText(s string) {
|
|
|
|
// TODO(nigeltao): merge s with previous text, if the preceding node is a text node.
|
|
|
|
// TODO(nigeltao): distinguish whitespace text from others.
|
|
|
|
p.addChild(&Node{
|
|
|
|
Type: TextNode,
|
|
|
|
Data: s,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
|
|
|
|
// Section 10.2.3.3.
|
|
|
|
func (p *parser) addFormattingElement(n *Node) {
|
|
|
|
p.addChild(n)
|
|
|
|
// TODO.
|
|
|
|
}
|
|
|
|
|
|
|
|
// Section 10.2.3.3.
|
|
|
|
func (p *parser) reconstructActiveFormattingElements() {
|
|
|
|
// TODO.
|
|
|
|
}
|
|
|
|
|
|
|
|
// read reads the next token. This is usually from the tokenizer, but it may
|
|
|
|
// be the synthesized end tag implied by a self-closing tag.
|
|
|
|
func (p *parser) read() os.Error {
|
|
|
|
if p.hasSelfClosingToken {
|
|
|
|
p.hasSelfClosingToken = false
|
|
|
|
p.tok.Type = EndTagToken
|
|
|
|
p.tok.Attr = nil
|
|
|
|
return nil
|
|
|
|
}
|
2010-12-07 14:59:20 -07:00
|
|
|
p.tokenizer.Next()
|
2010-12-06 18:02:36 -07:00
|
|
|
p.tok = p.tokenizer.Token()
|
2010-12-07 14:59:20 -07:00
|
|
|
switch p.tok.Type {
|
|
|
|
case ErrorToken:
|
|
|
|
return p.tokenizer.Error()
|
|
|
|
case SelfClosingTagToken:
|
2010-12-06 18:02:36 -07:00
|
|
|
p.hasSelfClosingToken = true
|
|
|
|
p.tok.Type = StartTagToken
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
// Section 10.2.4.
|
|
|
|
func (p *parser) acknowledgeSelfClosingTag() {
|
|
|
|
p.hasSelfClosingToken = false
|
|
|
|
}
|
|
|
|
|
2010-12-07 14:59:20 -07:00
|
|
|
// An insertion mode (section 10.2.3.1) is the state transition function from
|
|
|
|
// a particular state in the HTML5 parser's state machine. It updates the
|
|
|
|
// parser's fields depending on parser.token (where ErrorToken means EOF). In
|
|
|
|
// addition to returning the next insertionMode state, it also returns whether
|
|
|
|
// the token was consumed.
|
|
|
|
type insertionMode func(*parser) (insertionMode, bool)
|
|
|
|
|
2010-12-06 18:02:36 -07:00
|
|
|
// Section 10.2.5.4.
|
|
|
|
func initialInsertionMode(p *parser) (insertionMode, bool) {
|
|
|
|
// TODO(nigeltao): check p.tok for DOCTYPE.
|
|
|
|
return beforeHTMLInsertionMode, false
|
|
|
|
}
|
|
|
|
|
|
|
|
// Section 10.2.5.5.
|
|
|
|
func beforeHTMLInsertionMode(p *parser) (insertionMode, bool) {
|
|
|
|
var (
|
|
|
|
add bool
|
|
|
|
attr []Attribute
|
|
|
|
implied bool
|
|
|
|
)
|
|
|
|
switch p.tok.Type {
|
2010-12-07 14:59:20 -07:00
|
|
|
case ErrorToken:
|
|
|
|
implied = true
|
2010-12-06 18:02:36 -07:00
|
|
|
case TextToken:
|
|
|
|
// TODO(nigeltao): distinguish whitespace text from others.
|
|
|
|
implied = true
|
|
|
|
case StartTagToken:
|
|
|
|
if p.tok.Data == "html" {
|
|
|
|
add = true
|
|
|
|
attr = p.tok.Attr
|
|
|
|
} else {
|
|
|
|
implied = true
|
|
|
|
}
|
|
|
|
case EndTagToken:
|
2010-12-07 14:59:20 -07:00
|
|
|
switch p.tok.Data {
|
|
|
|
case "head", "body", "html", "br":
|
|
|
|
implied = true
|
|
|
|
default:
|
|
|
|
// Ignore the token.
|
|
|
|
}
|
2010-12-06 18:02:36 -07:00
|
|
|
}
|
|
|
|
if add || implied {
|
|
|
|
p.addChild(&Node{
|
|
|
|
Type: ElementNode,
|
|
|
|
Data: "html",
|
|
|
|
Attr: attr,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
return beforeHeadInsertionMode, !implied
|
|
|
|
}
|
|
|
|
|
|
|
|
// Section 10.2.5.6.
|
|
|
|
func beforeHeadInsertionMode(p *parser) (insertionMode, bool) {
|
|
|
|
var (
|
|
|
|
add bool
|
|
|
|
attr []Attribute
|
|
|
|
implied bool
|
|
|
|
)
|
|
|
|
switch p.tok.Type {
|
2010-12-07 14:59:20 -07:00
|
|
|
case ErrorToken:
|
|
|
|
implied = true
|
2010-12-06 18:02:36 -07:00
|
|
|
case TextToken:
|
|
|
|
// TODO(nigeltao): distinguish whitespace text from others.
|
|
|
|
implied = true
|
|
|
|
case StartTagToken:
|
|
|
|
switch p.tok.Data {
|
|
|
|
case "head":
|
|
|
|
add = true
|
|
|
|
attr = p.tok.Attr
|
|
|
|
case "html":
|
2010-12-07 14:59:20 -07:00
|
|
|
return inBodyInsertionMode, false
|
2010-12-06 18:02:36 -07:00
|
|
|
default:
|
|
|
|
implied = true
|
|
|
|
}
|
|
|
|
case EndTagToken:
|
2010-12-07 14:59:20 -07:00
|
|
|
switch p.tok.Data {
|
|
|
|
case "head", "body", "html", "br":
|
|
|
|
implied = true
|
|
|
|
default:
|
|
|
|
// Ignore the token.
|
|
|
|
}
|
2010-12-06 18:02:36 -07:00
|
|
|
}
|
|
|
|
if add || implied {
|
|
|
|
p.addChild(&Node{
|
|
|
|
Type: ElementNode,
|
|
|
|
Data: "head",
|
|
|
|
Attr: attr,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
return inHeadInsertionMode, !implied
|
|
|
|
}
|
|
|
|
|
|
|
|
// Section 10.2.5.7.
|
|
|
|
func inHeadInsertionMode(p *parser) (insertionMode, bool) {
|
|
|
|
var (
|
|
|
|
pop bool
|
|
|
|
implied bool
|
|
|
|
)
|
|
|
|
switch p.tok.Type {
|
2010-12-07 14:59:20 -07:00
|
|
|
case ErrorToken, TextToken:
|
2010-12-06 18:02:36 -07:00
|
|
|
implied = true
|
|
|
|
case StartTagToken:
|
|
|
|
switch p.tok.Data {
|
|
|
|
case "meta":
|
|
|
|
// TODO.
|
|
|
|
case "script":
|
|
|
|
// TODO.
|
|
|
|
default:
|
|
|
|
implied = true
|
|
|
|
}
|
|
|
|
case EndTagToken:
|
|
|
|
if p.tok.Data == "head" {
|
|
|
|
pop = true
|
|
|
|
}
|
|
|
|
// TODO.
|
|
|
|
}
|
|
|
|
if pop || implied {
|
|
|
|
n := p.pop()
|
|
|
|
if n.Data != "head" {
|
|
|
|
panic("html: bad parser state")
|
|
|
|
}
|
|
|
|
return afterHeadInsertionMode, !implied
|
|
|
|
}
|
|
|
|
return inHeadInsertionMode, !implied
|
|
|
|
}
|
|
|
|
|
|
|
|
// Section 10.2.5.9.
|
|
|
|
func afterHeadInsertionMode(p *parser) (insertionMode, bool) {
|
|
|
|
var (
|
|
|
|
add bool
|
|
|
|
attr []Attribute
|
|
|
|
framesetOK bool
|
|
|
|
implied bool
|
|
|
|
)
|
|
|
|
switch p.tok.Type {
|
2010-12-07 14:59:20 -07:00
|
|
|
case ErrorToken, TextToken:
|
2010-12-06 18:02:36 -07:00
|
|
|
implied = true
|
|
|
|
framesetOK = true
|
|
|
|
case StartTagToken:
|
|
|
|
switch p.tok.Data {
|
|
|
|
case "html":
|
|
|
|
// TODO.
|
|
|
|
case "body":
|
|
|
|
add = true
|
|
|
|
attr = p.tok.Attr
|
|
|
|
framesetOK = false
|
|
|
|
case "frameset":
|
|
|
|
// TODO.
|
|
|
|
case "base", "basefont", "bgsound", "link", "meta", "noframes", "script", "style", "title":
|
|
|
|
// TODO.
|
|
|
|
case "head":
|
|
|
|
// TODO.
|
|
|
|
default:
|
|
|
|
implied = true
|
|
|
|
framesetOK = true
|
|
|
|
}
|
|
|
|
case EndTagToken:
|
|
|
|
// TODO.
|
|
|
|
}
|
|
|
|
if add || implied {
|
|
|
|
p.addChild(&Node{
|
|
|
|
Type: ElementNode,
|
|
|
|
Data: "body",
|
|
|
|
Attr: attr,
|
|
|
|
})
|
|
|
|
p.framesetOK = framesetOK
|
|
|
|
}
|
|
|
|
return inBodyInsertionMode, !implied
|
|
|
|
}
|
|
|
|
|
|
|
|
// Section 10.2.5.10.
|
|
|
|
func inBodyInsertionMode(p *parser) (insertionMode, bool) {
|
|
|
|
var endP bool
|
|
|
|
switch p.tok.Type {
|
2010-12-07 14:59:20 -07:00
|
|
|
case ErrorToken:
|
|
|
|
// No-op.
|
2010-12-06 18:02:36 -07:00
|
|
|
case TextToken:
|
|
|
|
p.addText(p.tok.Data)
|
|
|
|
p.framesetOK = false
|
|
|
|
case StartTagToken:
|
|
|
|
switch p.tok.Data {
|
|
|
|
case "address", "article", "aside", "blockquote", "center", "details", "dir", "div", "dl", "fieldset", "figcaption", "figure", "footer", "header", "hgroup", "menu", "nav", "ol", "p", "section", "summary", "ul":
|
|
|
|
// TODO(nigeltao): Do the proper "does the stack of open elements has a p element in button scope" algorithm in section 10.2.3.2.
|
|
|
|
n := p.top()
|
|
|
|
if n.Type == ElementNode && n.Data == "p" {
|
|
|
|
endP = true
|
|
|
|
} else {
|
|
|
|
p.addChild(&Node{
|
|
|
|
Type: ElementNode,
|
|
|
|
Data: p.tok.Data,
|
|
|
|
Attr: p.tok.Attr,
|
|
|
|
})
|
|
|
|
}
|
|
|
|
case "b", "big", "code", "em", "font", "i", "s", "small", "strike", "strong", "tt", "u":
|
|
|
|
p.reconstructActiveFormattingElements()
|
|
|
|
p.addFormattingElement(&Node{
|
|
|
|
Type: ElementNode,
|
|
|
|
Data: p.tok.Data,
|
|
|
|
Attr: p.tok.Attr,
|
|
|
|
})
|
|
|
|
case "area", "br", "embed", "img", "input", "keygen", "wbr":
|
|
|
|
p.reconstructActiveFormattingElements()
|
|
|
|
p.addChild(&Node{
|
|
|
|
Type: ElementNode,
|
|
|
|
Data: p.tok.Data,
|
|
|
|
Attr: p.tok.Attr,
|
|
|
|
})
|
|
|
|
p.pop()
|
|
|
|
p.acknowledgeSelfClosingTag()
|
|
|
|
p.framesetOK = false
|
|
|
|
case "hr":
|
|
|
|
// TODO(nigeltao): auto-insert </p> if necessary.
|
|
|
|
p.addChild(&Node{
|
|
|
|
Type: ElementNode,
|
|
|
|
Data: p.tok.Data,
|
|
|
|
Attr: p.tok.Attr,
|
|
|
|
})
|
|
|
|
p.pop()
|
|
|
|
p.acknowledgeSelfClosingTag()
|
|
|
|
p.framesetOK = false
|
|
|
|
default:
|
|
|
|
// TODO.
|
|
|
|
}
|
|
|
|
case EndTagToken:
|
|
|
|
switch p.tok.Data {
|
|
|
|
case "body":
|
|
|
|
// TODO(nigeltao): autoclose the stack of open elements.
|
|
|
|
return afterBodyInsertionMode, true
|
|
|
|
case "a", "b", "big", "code", "em", "font", "i", "nobr", "s", "small", "strike", "strong", "tt", "u":
|
|
|
|
// TODO(nigeltao): implement the "adoption agency" algorithm:
|
|
|
|
// http://www.whatwg.org/specs/web-apps/current-work/multipage/tokenization.html#adoptionAgency
|
|
|
|
p.pop()
|
|
|
|
default:
|
|
|
|
// TODO.
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if endP {
|
|
|
|
// TODO(nigeltao): do the proper algorithm.
|
|
|
|
n := p.pop()
|
|
|
|
if n.Type != ElementNode || n.Data != "p" {
|
|
|
|
panic("unreachable")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return inBodyInsertionMode, !endP
|
|
|
|
}
|
|
|
|
|
|
|
|
// Section 10.2.5.22.
|
|
|
|
func afterBodyInsertionMode(p *parser) (insertionMode, bool) {
|
|
|
|
switch p.tok.Type {
|
2010-12-07 14:59:20 -07:00
|
|
|
case ErrorToken:
|
|
|
|
// TODO.
|
2010-12-06 18:02:36 -07:00
|
|
|
case TextToken:
|
|
|
|
// TODO.
|
|
|
|
case StartTagToken:
|
|
|
|
// TODO.
|
|
|
|
case EndTagToken:
|
|
|
|
switch p.tok.Data {
|
|
|
|
case "html":
|
|
|
|
// TODO(nigeltao): autoclose the stack of open elements.
|
|
|
|
return afterAfterBodyInsertionMode, true
|
|
|
|
default:
|
|
|
|
// TODO.
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return afterBodyInsertionMode, true
|
|
|
|
}
|
|
|
|
|
|
|
|
// Section 10.2.5.25.
|
|
|
|
func afterAfterBodyInsertionMode(p *parser) (insertionMode, bool) {
|
|
|
|
return inBodyInsertionMode, false
|
|
|
|
}
|
|
|
|
|
|
|
|
// Parse returns the parse tree for the HTML from the given Reader.
|
|
|
|
// The input is assumed to be UTF-8 encoded.
|
|
|
|
func Parse(r io.Reader) (*Node, os.Error) {
|
|
|
|
p := &parser{
|
|
|
|
tokenizer: NewTokenizer(r),
|
|
|
|
doc: &Node{
|
|
|
|
Type: DocumentNode,
|
|
|
|
},
|
|
|
|
scripting: true,
|
|
|
|
framesetOK: true,
|
|
|
|
}
|
2010-12-07 14:59:20 -07:00
|
|
|
// Iterate until EOF. Any other error will cause an early return.
|
2010-12-06 18:02:36 -07:00
|
|
|
im, consumed := initialInsertionMode, true
|
|
|
|
for {
|
|
|
|
if consumed {
|
|
|
|
if err := p.read(); err != nil {
|
|
|
|
if err == os.EOF {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
im, consumed = im(p)
|
|
|
|
}
|
2010-12-07 14:59:20 -07:00
|
|
|
// Loop until the final token (the ErrorToken signifying EOF) is consumed.
|
|
|
|
for {
|
|
|
|
if im, consumed = im(p); consumed {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
2010-12-06 18:02:36 -07:00
|
|
|
return p.doc, nil
|
|
|
|
}
|