"""HTML parser. Generates a tree structure from a stream of (possibly

def __init__(self, tree = simpletree.TreeBuilder,

tokenizer = tokenizer.HTMLTokenizer, strict = False):

"""

# Raise an exception on the first error encountered

self.strict = strict

self.tree = tree()

self.tokenizer_class = tokenizer

self.errors = []

# "quirks" / "limited-quirks" / "no-quirks"

self.compatMode = "no quirks"

self.phases = {

"initial": InitialPhase(self, self.tree),

"beforeHtml": BeforeHtmlPhase(self, self.tree),

"beforeHead": BeforeHeadPhase(self, self.tree),

"inHead": InHeadPhase(self, self.tree),

# XXX "inHeadNoscript": InHeadNoScriptPhase(self, self.tree),

"afterHead": AfterHeadPhase(self, self.tree),

"inBody": InBodyPhase(self, self.tree),

"inCDataRCData": InCDataRCDataPhase(self, self.tree),

"inTable": InTablePhase(self, self.tree),

"inCaption": InCaptionPhase(self, self.tree),

"inColumnGroup": InColumnGroupPhase(self, self.tree),

"inTableBody": InTableBodyPhase(self, self.tree),

"inRow": InRowPhase(self, self.tree),

"inCell": InCellPhase(self, self.tree),

"inSelect": InSelectPhase(self, self.tree),

"inSelectInTable": InSelectInTablePhase(self, self.tree),

"afterBody": AfterBodyPhase(self, self.tree),

"inFrameset": InFramesetPhase(self, self.tree),

"afterFrameset": AfterFramesetPhase(self, self.tree),

"afterAfterBody": AfterAfterBodyPhase(self, self.tree),

"afterAfterFrameset": AfterAfterFramesetPhase(self, self.tree),

# XXX after after frameset

}

def _parse(self, stream, innerHTML=False, container="div",

encoding=None, parseMeta=True, useChardet=True, **kwargs):

self.innerHTMLMode = innerHTML

self.container = container

self.tokenizer = self.tokenizer_class(stream, encoding=encoding,

parseMeta=parseMeta,

useChardet=useChardet, **kwargs)

self.reset()

while True:

try:

self.mainLoop()

break

except ReparseException, e:

self.reset()

def reset(self):

self.tree.reset()

self.firstStartTag = False

self.errors = []

self.compatMode = "no quirks"

if self.innerHTMLMode:

self.innerHTML = self.container.lower()

if self.innerHTML in cdataElements:

self.tokenizer.contentModelFlag = tokenizer.contentModelFlags["RCDATA"]

elif self.innerHTML in rcdataElements:

self.tokenizer.contentModelFlag = tokenizer.contentModelFlags["CDATA"]

elif self.innerHTML == 'plaintext':

self.tokenizer.contentModelFlag = tokenizer.contentModelFlags["PLAINTEXT"]

else:

# contentModelFlag already is PCDATA

#self.tokenizer.contentModelFlag = tokenizer.contentModelFlags["PCDATA"]

pass

self.phase = self.phases["beforeHtml"]

self.phase.insertHtmlElement()

self.resetInsertionMode()

else:

self.innerHTML = False

self.phase = self.phases["initial"]

# We only seem to have InBodyPhase testcases where the following is

# relevant ... need others too

self.lastPhase = None

self.beforeRCDataPhase = None

def mainLoop(self):

(CharactersToken,

SpaceCharactersToken,

StartTagToken,

EndTagToken,

CommentToken,

DoctypeToken) = (tokenTypes["Characters"],

tokenTypes["SpaceCharacters"],

tokenTypes["StartTag"],

tokenTypes["EndTag"],

tokenTypes["Comment"],

tokenTypes["Doctype"])

for token in self.normalizedTokens():

type = token["type"]

if type == CharactersToken:

self.phase.processCharacters(token["data"])

elif type == SpaceCharactersToken:

self.phase.processSpaceCharacters(token["data"])

elif type == StartTagToken:

self.phase.processStartTag(token["name"], token["data"])

elif type == EndTagToken:

self.phase.processEndTag(token["name"])

elif type == CommentToken:

self.phase.processComment(token["data"])

elif type == DoctypeToken:

self.phase.processDoctype(token["name"], token["publicId"],

token["systemId"], token["correct"])

else:

self.parseError(token["data"], token.get("datavars", {}))

# When the loop finishes it's EOF

self.phase.processEOF()

def normalizedTokens(self):

for token in self.tokenizer:

yield self.normalizeToken(token)

def parse(self, stream, encoding=None, parseMeta=True, useChardet=True):

"""Parse a HTML document into a well-formed tree

self._parse(stream, innerHTML=False, encoding=encoding)

return self.tree.getDocument()

def parseFragment(self, stream, container="div", encoding=None,

parseMeta=False, useChardet=True):

"""Parse a HTML fragment into a well-formed tree fragment

self._parse(stream, True, container=container, encoding=encoding)

return self.tree.getFragment()

def parseError(self, errorcode="XXX-undefined-error", datavars={}):

# XXX The idea is to make errorcode mandatory.

self.errors.append((self.tokenizer.stream.position(), errorcode, datavars))

if self.strict:

raise ParseError

def normalizeToken(self, token):

""" HTML5 specific normalizations to the token stream """

if token["type"] == tokenTypes["EmptyTag"]:

# When a solidus (/) is encountered within a tag name what happens

# depends on whether the current tag name matches that of a void

# element. If it matches a void element atheists did the wrong

# thing and if it doesn't it's wrong for everyone.

if token["name"] not in voidElements:

self.parseError("incorrectly-placed-solidus")

token["type"] = tokenTypes["StartTag"]

if token["type"] == tokenTypes["StartTag"]:

token["data"] = dict(token["data"][::-1])

return token

def resetInsertionMode(self):

# The name of this method is mostly historical. (It's also used in the

# specification.)

last = False

newModes = {

"select":"inSelect",

"td":"inCell",

"th":"inCell",

"tr":"inRow",

"tbody":"inTableBody",

"thead":"inTableBody",

"tfoot":"inTableBody",

"caption":"inCaption",

"colgroup":"inColumnGroup",

"table":"inTable",

"head":"inBody",

"body":"inBody",

"frameset":"inFrameset"

}

for node in self.tree.openElements[::-1]:

nodeName = node.name

if node == self.tree.openElements[0]:

last = True

if nodeName not in ['td', 'th']:

# XXX

assert self.innerHTML

nodeName = self.innerHTML

# Check for conditions that should only happen in the innerHTML

# case

if nodeName in ("select", "colgroup", "head", "frameset"):

# XXX

assert self.innerHTML

if nodeName in newModes:

self.phase = self.phases[newModes[nodeName]]

break

elif nodeName == "html":

if self.tree.headPointer is None:

self.phase = self.phases["beforeHead"]

else:

self.phase = self.phases["afterHead"]

break

elif last:

self.phase = self.phases["inBody"]

break

def parseRCDataCData(self, name, attributes, contentType):

"""Generic (R)CDATA Parsing algorithm

assert contentType in ("CDATA", "RCDATA")

element = self.tree.insertElement(name, attributes)

self.tokenizer.contentModelFlag = contentModelFlags[contentType]

self.originalPhase = self.phase

"""Base class for helper object that implements each phase of processing

# Order should be (they can be omitted):

# * EOF

# * Comment

# * Doctype

# * SpaceCharacters

# * Characters

# * StartTag

# - startTag* methods

# * EndTag

# - endTag* methods

def __init__(self, parser, tree):

self.parser = parser

self.tree = tree

def processEOF(self):

raise NotImplementedError

def processComment(self, data):

# For most phases the following is correct. Where it's not it will be

# overridden.

self.tree.insertComment(data, self.tree.openElements[-1])

def processDoctype(self, name, publicId, systemId, correct):

self.parser.parseError("unexpected-doctype")

def processSpaceCharacters(self, data):

self.tree.insertText(data)

def processStartTag(self, name, attributes):

self.startTagHandler[name](name, attributes)

def startTagHtml(self, name, attributes):

if self.parser.firstStartTag == False and name == "html":

self.parser.parseError("non-html-root")

# XXX Need a check here to see if the first start tag token emitted is

# this token... If it's not, invoke self.parser.parseError().

for attr, value in attributes.iteritems():

if attr not in self.tree.openElements[0].attributes:

self.tree.openElements[0].attributes[attr] = value

self.parser.firstStartTag = False

def processEndTag(self, name):

# This phase deals with error handling as well which is currently not

# covered in the specification. The error handling is typically known as

# "quirks mode". It is expected that a future version of HTML5 will defin

# this.

def processEOF(self):

self.parser.parseError("expected-doctype-but-got-eof")

self.parser.compatMode = "quirks"

self.parser.phase = self.parser.phases["beforeHtml"]

self.parser.phase.processEOF()

def processComment(self, data):

self.tree.insertComment(data, self.tree.document)

def processDoctype(self, name, publicId, systemId, correct):

nameLower = name.translate(asciiUpper2Lower)

if (nameLower != "html" or publicId != None or

systemId != None):

self.parser.parseError("unknown-doctype")

if publicId is None:

publicId = ""

if systemId is None:

systemId = ""

self.tree.insertDoctype(name, publicId, systemId)

if publicId != "":

publicId = publicId.translate(asciiUpper2Lower)

if ((not correct) or nameLower != "html"

or publicId in

("+//silmaril//dtd html pro v0r11 19970101//en",

"-//advasoft ltd//dtd html 3.0 aswedit + extensions//en",

"-//as//dtd html 3.0 aswedit + extensions//en",

"-//ietf//dtd html 2.0 level 1//en",

"-//ietf//dtd html 2.0 level 2//en",

"-//ietf//dtd html 2.0 strict level 1//en",

"-//ietf//dtd html 2.0 strict level 2//en",

"-//ietf//dtd html 2.0 strict//en",

"-//ietf//dtd html 2.0//en",

"-//ietf//dtd html 2.1e//en",

"-//ietf//dtd html 3.0//en",

"-//ietf//dtd html 3.0//en//",

"-//ietf//dtd html 3.2 final//en",

"-//ietf//dtd html 3.2//en",

"-//ietf//dtd html 3//en",

"-//ietf//dtd html level 0//en",

"-//ietf//dtd html level 0//en//2.0",

"-//ietf//dtd html level 1//en",

"-//ietf//dtd html level 1//en//2.0",

"-//ietf//dtd html level 2//en",

"-//ietf//dtd html level 2//en//2.0",

"-//ietf//dtd html level 3//en",

"-//ietf//dtd html level 3//en//3.0",

"-//ietf//dtd html strict level 0//en",

"-//ietf//dtd html strict level 0//en//2.0",

"-//ietf//dtd html strict level 1//en",

"-//ietf//dtd html strict level 1//en//2.0",

"-//ietf//dtd html strict level 2//en",

"-//ietf//dtd html strict level 2//en//2.0",

"-//ietf//dtd html strict level 3//en",

"-//ietf//dtd html strict level 3//en//3.0",

"-//ietf//dtd html strict//en",

"-//ietf//dtd html strict//en//2.0",

"-//ietf//dtd html strict//en//3.0",

"-//ietf//dtd html//en",

"-//ietf//dtd html//en//2.0",

"-//ietf//dtd html//en//3.0",

"-//metrius//dtd metrius presentational//en",

"-//microsoft//dtd internet explorer 2.0 html strict//en",

"-//microsoft//dtd internet explorer 2.0 html//en",

"-//microsoft//dtd internet explorer 2.0 tables//en",

"-//microsoft//dtd internet explorer 3.0 html strict//en",

"-//microsoft//dtd internet explorer 3.0 html//en",

"-//microsoft//dtd internet explorer 3.0 tables//en",

"-//netscape comm. corp.//dtd html//en",

"-//netscape comm. corp.//dtd strict html//en",

"-//o'reilly and associates//dtd html 2.0//en",

"-//o'reilly and associates//dtd html extended 1.0//en",

"-//spyglass//dtd html 2.0 extended//en",

"-//sq//dtd html 2.0 hotmetal + extensions//en",

"-//sun microsystems corp.//dtd hotjava html//en",

"-//sun microsystems corp.//dtd hotjava strict html//en",

"-//w3c//dtd html 3 1995-03-24//en",

"-//w3c//dtd html 3.2 draft//en",

"-//w3c//dtd html 3.2 final//en",

"-//w3c//dtd html 3.2//en",

"-//w3c//dtd html 3.2s draft//en",

"-//w3c//dtd html 4.0 frameset//en",

"-//w3c//dtd html 4.0 transitional//en",

"-//w3c//dtd html experimental 19960712//en",

"-//w3c//dtd html experimental 970421//en",

"-//w3c//dtd w3 html//en",

"-//w3o//dtd w3 html 3.0//en",

"-//w3o//dtd w3 html 3.0//en//",

"-//w3o//dtd w3 html strict 3.0//en//",

"-//webtechs//dtd mozilla html 2.0//en",

"-//webtechs//dtd mozilla html//en",

"-/w3c/dtd html 4.0 transitional/en",

"html")

or (publicId in

("-//w3c//dtd html 4.01 frameset//EN",

"-//w3c//dtd html 4.01 transitional//EN") and systemId == None)

or (systemId != None and

systemId ==

"http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd")):

self.parser.compatMode = "quirks"

elif (publicId in

("-//w3c//dtd xhtml 1.0 frameset//EN",

"-//w3c//dtd xhtml 1.0 transitional//EN")

or (publicId in

("-//w3c//dtd html 4.01 frameset//EN",

"-//w3c//dtd html 4.01 transitional//EN") and systemId == None)):

self.parser.compatMode = "limited quirks"

self.parser.phase = self.parser.phases["beforeHtml"]

def processSpaceCharacters(self, data):

pass

def processCharacters(self, data):

self.parser.parseError("expected-doctype-but-got-chars")

self.parser.compatMode = "quirks"

self.parser.phase = self.parser.phases["beforeHtml"]

self.parser.phase.processCharacters(data)

def processStartTag(self, name, attributes):

self.parser.parseError("expected-doctype-but-got-start-tag",

{"name": name})

self.parser.compatMode = "quirks"

self.parser.phase = self.parser.phases["beforeHtml"]

self.parser.phase.processStartTag(name, attributes)

def processEndTag(self, name):

self.parser.parseError("expected-doctype-but-got-end-tag",

{"name": name})

self.parser.compatMode = "quirks"

self.parser.phase = self.parser.phases["beforeHtml"]

# helper methods

def insertHtmlElement(self):

self.tree.insertRoot("html")

self.parser.phase = self.parser.phases["beforeHead"]

# other

def processEOF(self):

self.insertHtmlElement()

self.parser.phase.processEOF()

def processComment(self, data):

self.tree.insertComment(data, self.tree.document)

def processSpaceCharacters(self, data):

pass

def processCharacters(self, data):

self.insertHtmlElement()

self.parser.phase.processCharacters(data)

def processStartTag(self, name, attributes):

if name == "html":

self.parser.firstStartTag = True

self.insertHtmlElement()

self.parser.phase.processStartTag(name, attributes)

def processEndTag(self, name):

self.insertHtmlElement()

def __init__(self, parser, tree):

Phase.__init__(self, parser, tree)

self.startTagHandler = utils.MethodDispatcher([

("html", self.startTagHtml),

("head", self.startTagHead)

])

self.startTagHandler.default = self.startTagOther

self.endTagHandler = utils.MethodDispatcher([

(("head", "br"), self.endTagImplyHead)

])

self.endTagHandler.default = self.endTagOther

def processEOF(self):

self.startTagHead("head", {})

self.parser.phase.processEOF()

def processSpaceCharacters(self, data):

pass

def processCharacters(self, data):

self.startTagHead("head", {})

self.parser.phase.processCharacters(data)

def startTagHead(self, name, attributes):

self.tree.insertElement(name, attributes)

self.tree.headPointer = self.tree.openElements[-1]

self.parser.phase = self.parser.phases["inHead"]

def startTagOther(self, name, attributes):

self.startTagHead("head", {})

self.parser.phase.processStartTag(name, attributes)

def endTagImplyHead(self, name):

self.startTagHead("head", {})

self.parser.phase.processEndTag(name)

def endTagOther(self, name):

self.parser.parseError("end-tag-after-implied-root",

def __init__(self, parser, tree):

Phase.__init__(self, parser, tree)

self.startTagHandler = utils.MethodDispatcher([

("html", self.startTagHtml),

("title", self.startTagTitle),

(("noscript", "noframes", "style"), self.startTagNoScriptNoFramesStyle),

("script", self.startTagScript),

(("base", "link", "command", "eventsource"),

self.startTagBaseLinkCommandEventsource),

("meta", self.startTagMeta),

("head", self.startTagHead)

])

self.startTagHandler.default = self.startTagOther

self. endTagHandler = utils.MethodDispatcher([

("head", self.endTagHead),

("br", self.endTagBr)

])

self.endTagHandler.default = self.endTagOther

# helper

def appendToHead(self, element):

if self.tree.headPointer is not None:

self.tree.headPointer.appendChild(element)

else:

assert self.parser.innerHTML

self.tree.openElements[-1].appendChild(element)

# the real thing

def processEOF (self):

self.anythingElse()

self.parser.phase.processEOF()

def processCharacters(self, data):

self.anythingElse()

self.parser.phase.processCharacters(data)

def startTagHtml(self, name, attributes):

self.parser.phases["inBody"].processStartTag(name, attributes)

def startTagHead(self, name, attributes):

self.parser.parseError("two-heads-are-not-better-than-one")

def startTagBaseLinkCommandEventsource(self, name, attributes):

self.tree.insertElement(name, attributes)

self.tree.openElements.pop()

#XXX Acknowledge self closing flag

def startTagMeta(self, name, attributes):

self.tree.insertElement(name, attributes)

self.tree.openElements.pop()

#XXX Acknowledge self closing flag

if self.parser.tokenizer.stream.charEncoding[1] == "tentative":

if "charset" in attributes:

self.parser.tokenizer.stream.changeEncoding(attributes["charset"])

elif "content" in attributes:

data = inputstream.EncodingBytes(

attributes["content"].encode(self.parser.tokenizer.stream.charEncoding[0]))

parser = inputstream.ContentAttrParser(data)

codec = parser.parse()

self.parser.tokenizer.stream.changeEncoding(codec)

def startTagTitle(self, name, attributes):

self.parser.parseRCDataCData(name, attributes, "RCDATA")

def startTagNoScriptNoFramesStyle(self, name, attributes):

#Need to decide whether to implement the scripting-disabled case

self.parser.parseRCDataCData(name, attributes, "CDATA")

def startTagScript(self, name, attributes):

#I think this is equivalent to the CDATA stuff since we don't execute script

#self.tree.insertElement(name, attributes)

self.parser.parseRCDataCData(name, attributes, "CDATA")

def startTagOther(self, name, attributes):

self.anythingElse()

self.parser.phase.processStartTag(name, attributes)

def endTagHead(self, name):

node = self.parser.tree.openElements.pop()

assert node.name == "head"

self.parser.phase = self.parser.phases["afterHead"]

def endTagBr(self, name):

self.anythingElse()

self.parser.phase.processEndTag(name)

def endTagOther(self, name):

self.parser.parseError("unexpected-end-tag", {"name": name})

def anythingElse(self):

def __init__(self, parser, tree):

Phase.__init__(self, parser, tree)

self.startTagHandler = utils.MethodDispatcher([

("html", self.startTagHtml),

("body", self.startTagBody),

("frameset", self.startTagFrameset),

(("base", "link", "meta", "noframes", "script", "style", "title"),

self.startTagFromHead),

("head", self.startTagHead)

])

self.startTagHandler.default = self.startTagOther

self.endTagHandler = utils.MethodDispatcher([("br", self.endTagBr)])

self.endTagHandler.default = self.endTagOther

def processEOF(self):

self.anythingElse()

self.parser.phase.processEOF()

def processCharacters(self, data):

self.anythingElse()

self.parser.phase.processCharacters(data)

def startTagBody(self, name, attributes):

self.tree.insertElement(name, attributes)

self.parser.phase = self.parser.phases["inBody"]

def startTagFrameset(self, name, attributes):

self.tree.insertElement(name, attributes)

self.parser.phase = self.parser.phases["inFrameset"]

def startTagFromHead(self, name, attributes):

self.parser.parseError("unexpected-start-tag-out-of-my-head",

{"name": name})

self.tree.openElements.append(self.tree.headPointer)

self.parser.phases["inHead"].processStartTag(name, attributes)

for node in self.tree.openElements[::-1]:

if node.name == "head":

self.tree.openElements.remove(node)

break

def startTagHead(self, name, attributes):

self.parser.parseError("unexpected-start-tag", {"name":name})

def startTagOther(self, name, attributes):

self.anythingElse()

self.parser.phase.processStartTag(name, attributes)

def endTagBr(self, name):

#This is not currently in the spec

self.anythingElse()

self.parser.phase.processEndTag("br")

def endTagOther(self, name):

self.parser.parseError("unexpected-end-tag", {"name":name})

def anythingElse(self):

self.tree.insertElement("body", {})

# http://www.whatwg.org/specs/web-apps/current-work/#in-body

# the crazy mode

def __init__(self, parser, tree):

Phase.__init__(self, parser, tree)

#Keep a ref to this for special handling of whitespace in <pre>

self.processSpaceCharactersNonPre = self.processSpaceCharacters

self.startTagHandler = utils.MethodDispatcher([

("html", self.startTagHtml),

(("base", "link", "meta", "script", "style", "title"),

self.startTagProcessInHead),

("body", self.startTagBody),

(("address", "article", "aside", "blockquote", "center", "datagrid",

"details", "dialog", "dir", "div", "dl", "fieldset", "figure",

"footer", "h1", "h2", "h3", "h4", "h5", "h6", "header", "listing",

"menu", "nav", "ol", "p", "pre", "section", "ul"),

self.startTagCloseP),

("form", self.startTagForm),

(("li", "dd", "dt"), self.startTagListItem),

("plaintext",self.startTagPlaintext),

(headingElements, self.startTagHeading),

("a", self.startTagA),

(("b", "big", "em", "font", "i", "s", "small", "strike", "strong",

"tt", "u"),self.startTagFormatting),

("nobr", self.startTagNobr),

("button", self.startTagButton),

(("applet", "marquee", "object"), self.startTagAppletMarqueeObject),

("xmp", self.startTagXmp),

("table", self.startTagTable),

(("area", "basefont", "bgsound", "br", "embed", "img", "param",

"spacer", "wbr"), self.startTagVoidFormatting),

("hr", self.startTagHr),

("image", self.startTagImage),

("input", self.startTagInput),

("isindex", self.startTagIsIndex),

("textarea", self.startTagTextarea),

(("iframe", "noembed", "noframes", "noscript"), self.startTagCdata),

("select", self.startTagSelect),

(("rp", "rt"), self.startTagRpRt),

(("option", "optgroup"), self.startTagOpt),

(("caption", "col", "colgroup", "frame", "frameset", "head",

"tbody", "td", "tfoot", "th", "thead",

"tr"), self.startTagMisplaced),

(("event-source", "command"), self.startTagNew)

])

self.startTagHandler.default = self.startTagOther

self.endTagHandler = utils.MethodDispatcher([

("body",self.endTagBody),

("html",self.endTagHtml),

(("address", "article", "aside", "blockquote", "center", "datagrid",

"details", "dialog", "dir", "div", "dl", "fieldset", "figure",

"footer", "header", "listing", "menu", "nav", "ol", "pre", "section",

"ul"), self.endTagBlock),

("form", self.endTagForm),

("p",self.endTagP),

(("dd", "dt", "li"), self.endTagListItem),

(headingElements, self.endTagHeading),

(("a", "b", "big", "em", "font", "i", "nobr", "s", "small",

"strike", "strong", "tt", "u"), self.endTagFormatting),

(("applet", "button", "marquee", "object"), self.endTagAppletButtonMarqueeObject),

("br", self.endTagBr),

])

self.endTagHandler.default = self.endTagOther

# helper

def addFormattingElement(self, name, attributes):

self.tree.insertElement(name, attributes)

self.tree.activeFormattingElements.append(

self.tree.openElements[-1])

# the real deal

def processEOF(self):

allowed_elements = frozenset(("dd", "dt", "li", "p", "tbody", "td",

"tfoot", "th", "thead", "tr", "body",

"html"))

for node in self.tree.openElements[::-1]:

if node.name not in allowed_elements:

self.parser.parseError("expected-closing-tag-but-got-eof")

break

#Stop parsing

def processSpaceCharactersDropNewline(self, data):

# Sometimes (start of <pre>, <listing>, and <textarea> blocks) we

# want to drop leading newlines

self.processSpaceCharacters = self.processSpaceCharactersNonPre

if (data.startswith("\n") and

self.tree.openElements[-1].name in ("pre", "listing", "textarea") and

not self.tree.openElements[-1].hasContent()):

data = data[1:]

if data:

self.tree.reconstructActiveFormattingElements()

self.tree.insertText(data)

def processCharacters(self, data):

# XXX The specification says to do this for every character at the

# moment, but apparently that doesn't match the real world so we don't

# do it for space characters.

self.tree.reconstructActiveFormattingElements()

self.tree.insertText(data)

#This matches the current spec but may not match the real world

def processSpaceCharacters(self, data):

self.tree.reconstructActiveFormattingElements()

self.tree.insertText(data)

def startTagProcessInHead(self, name, attributes):

self.parser.phases["inHead"].processStartTag(name, attributes)

def startTagBody(self, name, attributes):

self.parser.parseError("unexpected-start-tag", {"name": "body"})

if (len(self.tree.openElements) == 1

or self.tree.openElements[1].name != "body"):

assert self.parser.innerHTML

else:

for attr, value in attributes.iteritems():

if attr not in self.tree.openElements[1].attributes:

self.tree.openElements[1].attributes[attr] = value

def startTagCloseP(self, name, attributes):

if self.tree.elementInScope("p"):

self.endTagP("p")

self.tree.insertElement(name, attributes)

if name in ("pre", "listing"):

self.processSpaceCharacters = self.processSpaceCharactersDropNewline

def startTagForm(self, name, attributes):

if self.tree.formPointer:

self.parser.parseError(u"unexpected-start-tag", {"name": "form"})

else:

if self.tree.elementInScope("p"):

self.endTagP("p")

self.tree.insertElement(name, attributes)

self.tree.formPointer = self.tree.openElements[-1]

def startTagListItem(self, name, attributes):

if self.tree.elementInScope("p"):

self.endTagP("p")

stopNames = {"li":("li"), "dd":("dd", "dt"), "dt":("dd", "dt")}

stopName = stopNames[name]

# AT Use reversed in Python 2.4...

for i, node in enumerate(self.tree.openElements[::-1]):

if node.name in stopName:

poppedNodes = []

for j in range(i+1):

poppedNodes.append(self.tree.openElements.pop())

if i >= 1:

self.parser.parseError(

i == 1 and "missing-end-tag" or "missing-end-tags",

{"name": u", ".join([item.name

for item

in poppedNodes[:-1]])})

break

# Phrasing elements are all non special, non scoping, non

# formatting elements

if (node.name in (specialElements | scopingElements)

and node.name not in ("address", "div")):

break

# Always insert an <li> element.

self.tree.insertElement(name, attributes)

def startTagPlaintext(self, name, attributes):

if self.tree.elementInScope("p"):

self.endTagP("p")

self.tree.insertElement(name, attributes)

self.parser.tokenizer.contentModelFlag = contentModelFlags["PLAINTEXT"]

def startTagHeading(self, name, attributes):

if self.tree.elementInScope("p"):

self.endTagP("p")

# Uncomment the following for IE7 behavior:

#

#for item in headingElements:

# if self.tree.elementInScope(item):

# self.parser.parseError("unexpected-start-tag", {"name": name})

# item = self.tree.openElements.pop()

# while item.name not in headingElements:

# item = self.tree.openElements.pop()

# break

self.tree.insertElement(name, attributes)

def startTagA(self, name, attributes):

afeAElement = self.tree.elementInActiveFormattingElements("a")

if afeAElement:

self.parser.parseError("unexpected-start-tag-implies-end-tag",

{"startName": "a", "endName": "a"})

self.endTagFormatting("a")

if afeAElement in self.tree.openElements:

self.tree.openElements.remove(afeAElement)

if afeAElement in self.tree.activeFormattingElements:

self.tree.activeFormattingElements.remove(afeAElement)

self.tree.reconstructActiveFormattingElements()

self.addFormattingElement(name, attributes)

def startTagFormatting(self, name, attributes):

self.tree.reconstructActiveFormattingElements()

self.addFormattingElement(name, attributes)

def startTagNobr(self, name, attributes):

self.tree.reconstructActiveFormattingElements()

if self.tree.elementInScope("nobr"):

self.parser.parseError("unexpected-start-tag-implies-end-tag",

{"startName": "nobr", "endName": "nobr"})

self.processEndTag("nobr")

# XXX Need tests that trigger the following

self.tree.reconstructActiveFormattingElements()

self.addFormattingElement(name, attributes)

def startTagButton(self, name, attributes):

if self.tree.elementInScope("button"):

self.parser.parseError("unexpected-start-tag-implies-end-tag",

{"startName": "button", "endName": "button"})

self.processEndTag("button")

self.parser.phase.processStartTag(name, attributes)

else:

self.tree.reconstructActiveFormattingElements()

self.tree.insertElement(name, attributes)

self.tree.activeFormattingElements.append(Marker)

def startTagAppletMarqueeObject(self, name, attributes):

self.tree.reconstructActiveFormattingElements()

self.tree.insertElement(name, attributes)

self.tree.activeFormattingElements.append(Marker)

def startTagXmp(self, name, attributes):

self.tree.reconstructActiveFormattingElements()

self.parser.parseRCDataCData(name, attributes, "CDATA")

def startTagTable(self, name, attributes):

if self.tree.elementInScope("p"):

self.processEndTag("p")

self.tree.insertElement(name, attributes)

self.parser.phase = self.parser.phases["inTable"]

def startTagVoidFormatting(self, name, attributes):

self.tree.reconstructActiveFormattingElements()

self.tree.insertElement(name, attributes)

self.tree.openElements.pop()

def startTagHr(self, name, attributes):

if self.tree.elementInScope("p"):

self.endTagP("p")

self.tree.insertElement(name, attributes)

self.tree.openElements.pop()

def startTagImage(self, name, attributes):

# No really...

self.parser.parseError("unexpected-start-tag-treated-as",

{"originalName": "image", "newName": "img"})

self.processStartTag("img", attributes)

def startTagInput(self, name, attributes):

self.tree.reconstructActiveFormattingElements()

self.tree.insertElement(name, attributes)

if self.tree.formPointer:

# XXX Not exactly sure what to do here

self.tree.openElements[-1].form = self.tree.formPointer

self.tree.openElements.pop()

def startTagIsIndex(self, name, attributes):

self.parser.parseError("deprecated-tag", {"name": "isindex"})

if self.tree.formPointer:

return

self.processStartTag("form", {})

self.processStartTag("hr", {})

self.processStartTag("p", {})

self.processStartTag("label", {})

# XXX Localization ...

self.processCharacters(

"This is a searchable index. Insert your search keywords here: ")

attributes["name"] = "isindex"

attrs = [[key,value] for key,value in attributes.iteritems()]

self.processStartTag("input", dict(attrs))

self.processEndTag("label")

self.processEndTag("p")

self.processStartTag("hr", {})

self.processEndTag("form")

def startTagTextarea(self, name, attributes):

# XXX Form element pointer checking here as well...

self.tree.insertElement(name, attributes)

self.parser.tokenizer.contentModelFlag = contentModelFlags["RCDATA"]

self.processSpaceCharacters = self.processSpaceCharactersDropNewline

def startTagCdata(self, name, attributes):

"""iframe, noembed noframes, noscript(if scripting enabled)"""