A small menubar app that allows you to switch between R versions quickly (if you have multiple versions of R framework installed). https://rud.is/rswitch
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

1645 lines
57 KiB

3 years ago
//
// TokeniserState.swift
// SwiftSoup
//
// Created by Nabil Chatbi on 12/10/16.
// Copyright © 2016 Nabil Chatbi.. All rights reserved.
//
import Foundation
protocol TokeniserStateProtocol {
func read(_ t: Tokeniser, _ r: CharacterReader)throws
}
public class TokeniserStateVars {
public static let nullScalr: UnicodeScalar = "\u{0000}"
static let attributeSingleValueCharsSorted = ["'", UnicodeScalar.Ampersand, nullScalr].sorted()
static let attributeDoubleValueCharsSorted = ["\"", UnicodeScalar.Ampersand, nullScalr].sorted()
static let attributeNameCharsSorted = [UnicodeScalar.BackslashT, "\n", "\r", UnicodeScalar.BackslashF, " ", "/", "=", ">", nullScalr, "\"", "'", UnicodeScalar.LessThan].sorted()
static let attributeValueUnquoted = [UnicodeScalar.BackslashT, "\n", "\r", UnicodeScalar.BackslashF, " ", UnicodeScalar.Ampersand, ">", nullScalr, "\"", "'", UnicodeScalar.LessThan, "=", "`"].sorted()
static let replacementChar: UnicodeScalar = Tokeniser.replacementChar
static let replacementStr: String = String(Tokeniser.replacementChar)
static let eof: UnicodeScalar = CharacterReader.EOF
}
enum TokeniserState: TokeniserStateProtocol {
case Data
case CharacterReferenceInData
case Rcdata
case CharacterReferenceInRcdata
case Rawtext
case ScriptData
case PLAINTEXT
case TagOpen
case EndTagOpen
case TagName
case RcdataLessthanSign
case RCDATAEndTagOpen
case RCDATAEndTagName
case RawtextLessthanSign
case RawtextEndTagOpen
case RawtextEndTagName
case ScriptDataLessthanSign
case ScriptDataEndTagOpen
case ScriptDataEndTagName
case ScriptDataEscapeStart
case ScriptDataEscapeStartDash
case ScriptDataEscaped
case ScriptDataEscapedDash
case ScriptDataEscapedDashDash
case ScriptDataEscapedLessthanSign
case ScriptDataEscapedEndTagOpen
case ScriptDataEscapedEndTagName
case ScriptDataDoubleEscapeStart
case ScriptDataDoubleEscaped
case ScriptDataDoubleEscapedDash
case ScriptDataDoubleEscapedDashDash
case ScriptDataDoubleEscapedLessthanSign
case ScriptDataDoubleEscapeEnd
case BeforeAttributeName
case AttributeName
case AfterAttributeName
case BeforeAttributeValue
case AttributeValue_doubleQuoted
case AttributeValue_singleQuoted
case AttributeValue_unquoted
case AfterAttributeValue_quoted
case SelfClosingStartTag
case BogusComment
case MarkupDeclarationOpen
case CommentStart
case CommentStartDash
case Comment
case CommentEndDash
case CommentEnd
case CommentEndBang
case Doctype
case BeforeDoctypeName
case DoctypeName
case AfterDoctypeName
case AfterDoctypePublicKeyword
case BeforeDoctypePublicIdentifier
case DoctypePublicIdentifier_doubleQuoted
case DoctypePublicIdentifier_singleQuoted
case AfterDoctypePublicIdentifier
case BetweenDoctypePublicAndSystemIdentifiers
case AfterDoctypeSystemKeyword
case BeforeDoctypeSystemIdentifier
case DoctypeSystemIdentifier_doubleQuoted
case DoctypeSystemIdentifier_singleQuoted
case AfterDoctypeSystemIdentifier
case BogusDoctype
case CdataSection
internal func read(_ t: Tokeniser, _ r: CharacterReader)throws {
switch self {
case .Data:
switch (r.current()) {
case UnicodeScalar.Ampersand:
t.advanceTransition(.CharacterReferenceInData)
break
case UnicodeScalar.LessThan:
t.advanceTransition(.TagOpen)
break
case TokeniserStateVars.nullScalr:
t.error(self) // NOT replacement character (oddly?)
t.emit(r.consume())
break
case TokeniserStateVars.eof:
try t.emit(Token.EOF())
break
default:
let data: String = r.consumeData()
t.emit(data)
break
}
break
case .CharacterReferenceInData:
try TokeniserState.readCharRef(t, .Data)
break
case .Rcdata:
switch (r.current()) {
case UnicodeScalar.Ampersand:
t.advanceTransition(.CharacterReferenceInRcdata)
break
case UnicodeScalar.LessThan:
t.advanceTransition(.RcdataLessthanSign)
break
case TokeniserStateVars.nullScalr:
t.error(self)
r.advance()
t.emit(TokeniserStateVars.replacementChar)
break
case TokeniserStateVars.eof:
try t.emit(Token.EOF())
break
default:
let data = r.consumeToAny(UnicodeScalar.Ampersand, UnicodeScalar.LessThan, TokeniserStateVars.nullScalr)
t.emit(data)
break
}
break
case .CharacterReferenceInRcdata:
try TokeniserState.readCharRef(t, .Rcdata)
break
case .Rawtext:
try TokeniserState.readData(t, r, self, .RawtextLessthanSign)
break
case .ScriptData:
try TokeniserState.readData(t, r, self, .ScriptDataLessthanSign)
break
case .PLAINTEXT:
switch (r.current()) {
case TokeniserStateVars.nullScalr:
t.error(self)
r.advance()
t.emit(TokeniserStateVars.replacementChar)
break
case TokeniserStateVars.eof:
try t.emit(Token.EOF())
break
default:
let data = r.consumeTo(TokeniserStateVars.nullScalr)
t.emit(data)
break
}
break
case .TagOpen:
// from < in data
switch (r.current()) {
case "!":
t.advanceTransition(.MarkupDeclarationOpen)
break
case "/":
t.advanceTransition(.EndTagOpen)
break
case "?":
t.advanceTransition(.BogusComment)
break
default:
if (r.matchesLetter()) {
t.createTagPending(true)
t.transition(.TagName)
} else {
t.error(self)
t.emit(UnicodeScalar.LessThan) // char that got us here
t.transition(.Data)
}
break
}
break
case .EndTagOpen:
if (r.isEmpty()) {
t.eofError(self)
t.emit("</")
t.transition(.Data)
} else if (r.matchesLetter()) {
t.createTagPending(false)
t.transition(.TagName)
} else if (r.matches(">")) {
t.error(self)
t.advanceTransition(.Data)
} else {
t.error(self)
t.advanceTransition(.BogusComment)
}
break
case .TagName:
// from < or </ in data, will have start or end tag pending
// previous TagOpen state did NOT consume, will have a letter char in current
//String tagName = r.consumeToAnySorted(tagCharsSorted).toLowerCase()
let tagName = r.consumeTagName()
t.tagPending.appendTagName(tagName)
switch (r.consume()) {
case UnicodeScalar.BackslashT:
t.transition(.BeforeAttributeName)
break
case "\n":
t.transition(.BeforeAttributeName)
break
case "\r":
t.transition(.BeforeAttributeName)
break
case UnicodeScalar.BackslashF:
t.transition(.BeforeAttributeName)
break
case " ":
t.transition(.BeforeAttributeName)
break
case "/":
t.transition(.SelfClosingStartTag)
break
case ">":
try t.emitTagPending()
t.transition(.Data)
break
case TokeniserStateVars.nullScalr: // replacement
t.tagPending.appendTagName(TokeniserStateVars.replacementStr)
break
case TokeniserStateVars.eof: // should emit pending tag?
t.eofError(self)
t.transition(.Data)
// no default, as covered with above consumeToAny
default:
break
}
case .RcdataLessthanSign:
if (r.matches("/")) {
t.createTempBuffer()
t.advanceTransition(.RCDATAEndTagOpen)
} else if (r.matchesLetter() && t.appropriateEndTagName() != nil && !r.containsIgnoreCase("</" + t.appropriateEndTagName()!)) {
// diverge from spec: got a start tag, but there's no appropriate end tag (</title>), so rather than
// consuming to EOF break out here
t.tagPending = t.createTagPending(false).name(t.appropriateEndTagName()!)
try t.emitTagPending()
r.unconsume() // undo UnicodeScalar.LessThan
t.transition(.Data)
} else {
t.emit(UnicodeScalar.LessThan)
t.transition(.Rcdata)
}
break
case .RCDATAEndTagOpen:
if (r.matchesLetter()) {
t.createTagPending(false)
t.tagPending.appendTagName(r.current())
t.dataBuffer.append(r.current())
t.advanceTransition(.RCDATAEndTagName)
} else {
t.emit("</")
t.transition(.Rcdata)
}
break
case .RCDATAEndTagName:
if (r.matchesLetter()) {
let name = r.consumeLetterSequence()
t.tagPending.appendTagName(name)
t.dataBuffer.append(name)
return
}
func anythingElse(_ t: Tokeniser, _ r: CharacterReader) {
t.emit("</" + t.dataBuffer.toString())
r.unconsume()
t.transition(.Rcdata)
}
let c = r.consume()
switch (c) {
case UnicodeScalar.BackslashT:
if (try t.isAppropriateEndTagToken()) {
t.transition(.BeforeAttributeName)
} else {
anythingElse(t, r)
}
break
case "\n":
if (try t.isAppropriateEndTagToken()) {
t.transition(.BeforeAttributeName)
} else {
anythingElse(t, r)
}
break
case "\r":
if (try t.isAppropriateEndTagToken()) {
t.transition(.BeforeAttributeName)
} else {
anythingElse(t, r)
}
break
case UnicodeScalar.BackslashF:
if (try t.isAppropriateEndTagToken()) {
t.transition(.BeforeAttributeName)
} else {
anythingElse(t, r)
}
break
case " ":
if (try t.isAppropriateEndTagToken()) {
t.transition(.BeforeAttributeName)
} else {
anythingElse(t, r)
}
break
case "/":
if (try t.isAppropriateEndTagToken()) {
t.transition(.SelfClosingStartTag)
} else {
anythingElse(t, r)
}
break
case ">":
if (try t.isAppropriateEndTagToken()) {
try t.emitTagPending()
t.transition(.Data)
} else {anythingElse(t, r)}
break
default:
anythingElse(t, r)
break
}
break
case .RawtextLessthanSign:
if (r.matches("/")) {
t.createTempBuffer()
t.advanceTransition(.RawtextEndTagOpen)
} else {
t.emit(UnicodeScalar.LessThan)
t.transition(.Rawtext)
}
break
case .RawtextEndTagOpen:
TokeniserState.readEndTag(t, r, .RawtextEndTagName, .Rawtext)
break
case .RawtextEndTagName:
try TokeniserState.handleDataEndTag(t, r, .Rawtext)
break
case .ScriptDataLessthanSign:
switch (r.consume()) {
case "/":
t.createTempBuffer()
t.transition(.ScriptDataEndTagOpen)
break
case "!":
t.emit("<!")
t.transition(.ScriptDataEscapeStart)
break
default:
t.emit(UnicodeScalar.LessThan)
r.unconsume()
t.transition(.ScriptData)
}
break
case .ScriptDataEndTagOpen:
TokeniserState.readEndTag(t, r, .ScriptDataEndTagName, .ScriptData)
break
case .ScriptDataEndTagName:
try TokeniserState.handleDataEndTag(t, r, .ScriptData)
break
case .ScriptDataEscapeStart:
if (r.matches("-")) {
t.emit("-")
t.advanceTransition(.ScriptDataEscapeStartDash)
} else {
t.transition(.ScriptData)
}
break
case .ScriptDataEscapeStartDash:
if (r.matches("-")) {
t.emit("-")
t.advanceTransition(.ScriptDataEscapedDashDash)
} else {
t.transition(.ScriptData)
}
break
case .ScriptDataEscaped:
if (r.isEmpty()) {
t.eofError(self)
t.transition(.Data)
return
}
switch (r.current()) {
case "-":
t.emit("-")
t.advanceTransition(.ScriptDataEscapedDash)
break
case UnicodeScalar.LessThan:
t.advanceTransition(.ScriptDataEscapedLessthanSign)
break
case TokeniserStateVars.nullScalr:
t.error(self)
r.advance()
t.emit(TokeniserStateVars.replacementChar)
break
default:
let data = r.consumeToAny("-", UnicodeScalar.LessThan, TokeniserStateVars.nullScalr)
t.emit(data)
}
break
case .ScriptDataEscapedDash:
if (r.isEmpty()) {
t.eofError(self)
t.transition(.Data)
return
}
let c = r.consume()
switch (c) {
case "-":
t.emit(c)
t.transition(.ScriptDataEscapedDashDash)
break
case UnicodeScalar.LessThan:
t.transition(.ScriptDataEscapedLessthanSign)
break
case TokeniserStateVars.nullScalr:
t.error(self)
t.emit(TokeniserStateVars.replacementChar)
t.transition(.ScriptDataEscaped)
break
default:
t.emit(c)
t.transition(.ScriptDataEscaped)
}
break
case .ScriptDataEscapedDashDash:
if (r.isEmpty()) {
t.eofError(self)
t.transition(.Data)
return
}
let c = r.consume()
switch (c) {
case "-":
t.emit(c)
break
case UnicodeScalar.LessThan:
t.transition(.ScriptDataEscapedLessthanSign)
break
case ">":
t.emit(c)
t.transition(.ScriptData)
break
case TokeniserStateVars.nullScalr:
t.error(self)
t.emit(TokeniserStateVars.replacementChar)
t.transition(.ScriptDataEscaped)
break
default:
t.emit(c)
t.transition(.ScriptDataEscaped)
}
break
case .ScriptDataEscapedLessthanSign:
if (r.matchesLetter()) {
t.createTempBuffer()
t.dataBuffer.append(r.current())
t.emit("<" + String(r.current()))
t.advanceTransition(.ScriptDataDoubleEscapeStart)
} else if (r.matches("/")) {
t.createTempBuffer()
t.advanceTransition(.ScriptDataEscapedEndTagOpen)
} else {
t.emit(UnicodeScalar.LessThan)
t.transition(.ScriptDataEscaped)
}
break
case .ScriptDataEscapedEndTagOpen:
if (r.matchesLetter()) {
t.createTagPending(false)
t.tagPending.appendTagName(r.current())
t.dataBuffer.append(r.current())
t.advanceTransition(.ScriptDataEscapedEndTagName)
} else {
t.emit("</")
t.transition(.ScriptDataEscaped)
}
break
case .ScriptDataEscapedEndTagName:
try TokeniserState.handleDataEndTag(t, r, .ScriptDataEscaped)
break
case .ScriptDataDoubleEscapeStart:
TokeniserState.handleDataDoubleEscapeTag(t, r, .ScriptDataDoubleEscaped, .ScriptDataEscaped)
break
case .ScriptDataDoubleEscaped:
let c = r.current()
switch (c) {
case "-":
t.emit(c)
t.advanceTransition(.ScriptDataDoubleEscapedDash)
break
case UnicodeScalar.LessThan:
t.emit(c)
t.advanceTransition(.ScriptDataDoubleEscapedLessthanSign)
break
case TokeniserStateVars.nullScalr:
t.error(self)
r.advance()
t.emit(TokeniserStateVars.replacementChar)
break
case TokeniserStateVars.eof:
t.eofError(self)
t.transition(.Data)
break
default:
let data = r.consumeToAny("-", UnicodeScalar.LessThan, TokeniserStateVars.nullScalr)
t.emit(data)
}
break
case .ScriptDataDoubleEscapedDash:
let c = r.consume()
switch (c) {
case "-":
t.emit(c)
t.transition(.ScriptDataDoubleEscapedDashDash)
break
case UnicodeScalar.LessThan:
t.emit(c)
t.transition(.ScriptDataDoubleEscapedLessthanSign)
break
case TokeniserStateVars.nullScalr:
t.error(self)
t.emit(TokeniserStateVars.replacementChar)
t.transition(.ScriptDataDoubleEscaped)
break
case TokeniserStateVars.eof:
t.eofError(self)
t.transition(.Data)
break
default:
t.emit(c)
t.transition(.ScriptDataDoubleEscaped)
}
break
case .ScriptDataDoubleEscapedDashDash:
let c = r.consume()
switch (c) {
case "-":
t.emit(c)
break
case UnicodeScalar.LessThan:
t.emit(c)
t.transition(.ScriptDataDoubleEscapedLessthanSign)
break
case ">":
t.emit(c)
t.transition(.ScriptData)
break
case TokeniserStateVars.nullScalr:
t.error(self)
t.emit(TokeniserStateVars.replacementChar)
t.transition(.ScriptDataDoubleEscaped)
break
case TokeniserStateVars.eof:
t.eofError(self)
t.transition(.Data)
break
default:
t.emit(c)
t.transition(.ScriptDataDoubleEscaped)
}
break
case .ScriptDataDoubleEscapedLessthanSign:
if (r.matches("/")) {
t.emit("/")
t.createTempBuffer()
t.advanceTransition(.ScriptDataDoubleEscapeEnd)
} else {
t.transition(.ScriptDataDoubleEscaped)
}
break
case .ScriptDataDoubleEscapeEnd:
TokeniserState.handleDataDoubleEscapeTag(t, r, .ScriptDataEscaped, .ScriptDataDoubleEscaped)
break
case .BeforeAttributeName:
// from tagname <xxx
let c = r.consume()
switch (c) {
case UnicodeScalar.BackslashT, "\n", "\r", UnicodeScalar.BackslashF, " ":
break // ignore whitespace
case "/":
t.transition(.SelfClosingStartTag)
break
case ">":
try t.emitTagPending()
t.transition(.Data)
break
case TokeniserStateVars.nullScalr:
t.error(self)
try t.tagPending.newAttribute()
r.unconsume()
t.transition(.AttributeName)
break
case TokeniserStateVars.eof:
t.eofError(self)
t.transition(.Data)
break
case "\"", "'", UnicodeScalar.LessThan, "=":
t.error(self)
try t.tagPending.newAttribute()
t.tagPending.appendAttributeName(c)
t.transition(.AttributeName)
break
default: // A-Z, anything else
try t.tagPending.newAttribute()
r.unconsume()
t.transition(.AttributeName)
}
break
case .AttributeName:
let name = r.consumeToAnySorted(TokeniserStateVars.attributeNameCharsSorted)
t.tagPending.appendAttributeName(name)
let c = r.consume()
switch (c) {
case UnicodeScalar.BackslashT:
t.transition(.AfterAttributeName)
break
case "\n":
t.transition(.AfterAttributeName)
break
case "\r":
t.transition(.AfterAttributeName)
break
case UnicodeScalar.BackslashF:
t.transition(.AfterAttributeName)
break
case " ":
t.transition(.AfterAttributeName)
break
case "/":
t.transition(.SelfClosingStartTag)
break
case "=":
t.transition(.BeforeAttributeValue)
break
case ">":
try t.emitTagPending()
t.transition(.Data)
break
case TokeniserStateVars.nullScalr:
t.error(self)
t.tagPending.appendAttributeName(TokeniserStateVars.replacementChar)
break
case TokeniserStateVars.eof:
t.eofError(self)
t.transition(.Data)
break
case "\"":
t.error(self)
t.tagPending.appendAttributeName(c)
case "'":
t.error(self)
t.tagPending.appendAttributeName(c)
case UnicodeScalar.LessThan:
t.error(self)
t.tagPending.appendAttributeName(c)
// no default, as covered in consumeToAny
default:
break
}
break
case .AfterAttributeName:
let c = r.consume()
switch (c) {
case UnicodeScalar.BackslashT, "\n", "\r", UnicodeScalar.BackslashF, " ":
// ignore
break
case "/":
t.transition(.SelfClosingStartTag)
break
case "=":
t.transition(.BeforeAttributeValue)
break
case ">":
try t.emitTagPending()
t.transition(.Data)
break
case TokeniserStateVars.nullScalr:
t.error(self)
t.tagPending.appendAttributeName(TokeniserStateVars.replacementChar)
t.transition(.AttributeName)
break
case TokeniserStateVars.eof:
t.eofError(self)
t.transition(.Data)
break
case "\"", "'", UnicodeScalar.LessThan:
t.error(self)
try t.tagPending.newAttribute()
t.tagPending.appendAttributeName(c)
t.transition(.AttributeName)
break
default: // A-Z, anything else
try t.tagPending.newAttribute()
r.unconsume()
t.transition(.AttributeName)
}
break
case .BeforeAttributeValue:
let c = r.consume()
switch (c) {
case UnicodeScalar.BackslashT, "\n", "\r", UnicodeScalar.BackslashF, " ":
// ignore
break
case "\"":
t.transition(.AttributeValue_doubleQuoted)
break
case UnicodeScalar.Ampersand:
r.unconsume()
t.transition(.AttributeValue_unquoted)
break
case "'":
t.transition(.AttributeValue_singleQuoted)
break
case TokeniserStateVars.nullScalr:
t.error(self)
t.tagPending.appendAttributeValue(TokeniserStateVars.replacementChar)
t.transition(.AttributeValue_unquoted)
break
case TokeniserStateVars.eof:
t.eofError(self)
try t.emitTagPending()
t.transition(.Data)
break
case ">":
t.error(self)
try t.emitTagPending()
t.transition(.Data)
break
case UnicodeScalar.LessThan, "=", "`":
t.error(self)
t.tagPending.appendAttributeValue(c)
t.transition(.AttributeValue_unquoted)
break
default:
r.unconsume()
t.transition(.AttributeValue_unquoted)
}
break
case .AttributeValue_doubleQuoted:
let value = r.consumeToAny(TokeniserStateVars.attributeDoubleValueCharsSorted)
if (value.count > 0) {
t.tagPending.appendAttributeValue(value)
} else {
t.tagPending.setEmptyAttributeValue()
}
let c = r.consume()
switch (c) {
case "\"":
t.transition(.AfterAttributeValue_quoted)
break
case UnicodeScalar.Ampersand:
if let ref = try t.consumeCharacterReference("\"", true) {
t.tagPending.appendAttributeValue(ref)
} else {
t.tagPending.appendAttributeValue(UnicodeScalar.Ampersand)
}
break
case TokeniserStateVars.nullScalr:
t.error(self)
t.tagPending.appendAttributeValue(TokeniserStateVars.replacementChar)
break
case TokeniserStateVars.eof:
t.eofError(self)
t.transition(.Data)
break
// no default, handled in consume to any above
default:
break
}
break
case .AttributeValue_singleQuoted:
let value = r.consumeToAny(TokeniserStateVars.attributeSingleValueCharsSorted)
if (value.count > 0) {
t.tagPending.appendAttributeValue(value)
} else {
t.tagPending.setEmptyAttributeValue()
}
let c = r.consume()
switch (c) {
case "'":
t.transition(.AfterAttributeValue_quoted)
break
case UnicodeScalar.Ampersand:
if let ref = try t.consumeCharacterReference("'", true) {
t.tagPending.appendAttributeValue(ref)
} else {
t.tagPending.appendAttributeValue(UnicodeScalar.Ampersand)
}
break
case TokeniserStateVars.nullScalr:
t.error(self)
t.tagPending.appendAttributeValue(TokeniserStateVars.replacementChar)
break
case TokeniserStateVars.eof:
t.eofError(self)
t.transition(.Data)
break
// no default, handled in consume to any above
default:
break
}
break
case .AttributeValue_unquoted:
let value = r.consumeToAnySorted(TokeniserStateVars.attributeValueUnquoted)
if (value.count > 0) {
t.tagPending.appendAttributeValue(value)
}
let c = r.consume()
switch (c) {
case UnicodeScalar.BackslashT, "\n", "\r", UnicodeScalar.BackslashF, " ":
t.transition(.BeforeAttributeName)
break
case UnicodeScalar.Ampersand:
if let ref = try t.consumeCharacterReference(">", true) {
t.tagPending.appendAttributeValue(ref)
} else {
t.tagPending.appendAttributeValue(UnicodeScalar.Ampersand)
}
break
case ">":
try t.emitTagPending()
t.transition(.Data)
break
case TokeniserStateVars.nullScalr:
t.error(self)
t.tagPending.appendAttributeValue(TokeniserStateVars.replacementChar)
break
case TokeniserStateVars.eof:
t.eofError(self)
t.transition(.Data)
break
case "\"", "'", UnicodeScalar.LessThan, "=", "`":
t.error(self)
t.tagPending.appendAttributeValue(c)
break
// no default, handled in consume to any above
default:
break
}
break
case .AfterAttributeValue_quoted:
// CharacterReferenceInAttributeValue state handled inline
let c = r.consume()
switch (c) {
case UnicodeScalar.BackslashT, "\n", "\r", UnicodeScalar.BackslashF, " ":
t.transition(.BeforeAttributeName)
break
case "/":
t.transition(.SelfClosingStartTag)
break
case ">":
try t.emitTagPending()
t.transition(.Data)
break
case TokeniserStateVars.eof:
t.eofError(self)
t.transition(.Data)
break
default:
t.error(self)
r.unconsume()
t.transition(.BeforeAttributeName)
}
break
case .SelfClosingStartTag:
let c = r.consume()
switch (c) {
case ">":
t.tagPending._selfClosing = true
try t.emitTagPending()
t.transition(.Data)
break
case TokeniserStateVars.eof:
t.eofError(self)
t.transition(.Data)
break
default:
t.error(self)
r.unconsume()
t.transition(.BeforeAttributeName)
}
break
case .BogusComment:
// todo: handle bogus comment starting from eof. when does that trigger?
// rewind to capture character that lead us here
r.unconsume()
let comment: Token.Comment = Token.Comment()
comment.bogus = true
comment.data.append(r.consumeTo(">"))
// todo: replace nullChar with replaceChar
try t.emit(comment)
t.advanceTransition(.Data)
break
case .MarkupDeclarationOpen:
if (r.matchConsume("--")) {
t.createCommentPending()
t.transition(.CommentStart)
} else if (r.matchConsumeIgnoreCase("DOCTYPE")) {
t.transition(.Doctype)
} else if (r.matchConsume("[CDATA[")) {
// todo: should actually check current namepspace, and only non-html allows cdata. until namespace
// is implemented properly, keep handling as cdata
//} else if (!t.currentNodeInHtmlNS() && r.matchConsume("[CDATA[")) {
t.transition(.CdataSection)
} else {
t.error(self)
t.advanceTransition(.BogusComment) // advance so self character gets in bogus comment data's rewind
}
break
case .CommentStart:
let c = r.consume()
switch (c) {
case "-":
t.transition(.CommentStartDash)
break
case TokeniserStateVars.nullScalr:
t.error(self)
t.commentPending.data.append(TokeniserStateVars.replacementChar)
t.transition(.Comment)
break
case ">":
t.error(self)
try t.emitCommentPending()
t.transition(.Data)
break
case TokeniserStateVars.eof:
t.eofError(self)
try t.emitCommentPending()
t.transition(.Data)
break
default:
t.commentPending.data.append(c)
t.transition(.Comment)
}
break
case .CommentStartDash:
let c = r.consume()
switch (c) {
case "-":
t.transition(.CommentStartDash)
break
case TokeniserStateVars.nullScalr:
t.error(self)
t.commentPending.data.append(TokeniserStateVars.replacementChar)
t.transition(.Comment)
break
case ">":
t.error(self)
try t.emitCommentPending()
t.transition(.Data)
break
case TokeniserStateVars.eof:
t.eofError(self)
try t.emitCommentPending()
t.transition(.Data)
break
default:
t.commentPending.data.append(c)
t.transition(.Comment)
}
break
case .Comment:
let c = r.current()
switch (c) {
case "-":
t.advanceTransition(.CommentEndDash)
break
case TokeniserStateVars.nullScalr:
t.error(self)
r.advance()
t.commentPending.data.append(TokeniserStateVars.replacementChar)
break
case TokeniserStateVars.eof:
t.eofError(self)
try t.emitCommentPending()
t.transition(.Data)
break
default:
t.commentPending.data.append(r.consumeToAny("-", TokeniserStateVars.nullScalr))
}
break
case .CommentEndDash:
let c = r.consume()
switch (c) {
case "-":
t.transition(.CommentEnd)
break
case TokeniserStateVars.nullScalr:
t.error(self)
t.commentPending.data.append("-").append(TokeniserStateVars.replacementChar)
t.transition(.Comment)
break
case TokeniserStateVars.eof:
t.eofError(self)
try t.emitCommentPending()
t.transition(.Data)
break
default:
t.commentPending.data.append("-").append(c)
t.transition(.Comment)
}
break
case .CommentEnd:
let c = r.consume()
switch (c) {
case ">":
try t.emitCommentPending()
t.transition(.Data)
break
case TokeniserStateVars.nullScalr:
t.error(self)
t.commentPending.data.append("--").append(TokeniserStateVars.replacementChar)
t.transition(.Comment)
break
case "!":
t.error(self)
t.transition(.CommentEndBang)
break
case "-":
t.error(self)
t.commentPending.data.append("-")
break
case TokeniserStateVars.eof:
t.eofError(self)
try t.emitCommentPending()
t.transition(.Data)
break
default:
t.error(self)
t.commentPending.data.append("--").append(c)
t.transition(.Comment)
}
break
case .CommentEndBang:
let c = r.consume()
switch (c) {
case "-":
t.commentPending.data.append("--!")
t.transition(.CommentEndDash)
break
case ">":
try t.emitCommentPending()
t.transition(.Data)
break
case TokeniserStateVars.nullScalr:
t.error(self)
t.commentPending.data.append("--!").append(TokeniserStateVars.replacementChar)
t.transition(.Comment)
break
case TokeniserStateVars.eof:
t.eofError(self)
try t.emitCommentPending()
t.transition(.Data)
break
default:
t.commentPending.data.append("--!").append(c)
t.transition(.Comment)
}
break
case .Doctype:
let c = r.consume()
switch (c) {
case UnicodeScalar.BackslashT, "\n", "\r", UnicodeScalar.BackslashF, " ":
t.transition(.BeforeDoctypeName)
break
case TokeniserStateVars.eof:
t.eofError(self)
// note: fall through to > case
case ">": // catch invalid <!DOCTYPE>
t.error(self)
t.createDoctypePending()
t.doctypePending.forceQuirks = true
try t.emitDoctypePending()
t.transition(.Data)
break
default:
t.error(self)
t.transition(.BeforeDoctypeName)
}
break
case .BeforeDoctypeName:
if (r.matchesLetter()) {
t.createDoctypePending()
t.transition(.DoctypeName)
return
}
let c = r.consume()
switch (c) {
case UnicodeScalar.BackslashT, "\n", "\r", UnicodeScalar.BackslashF, " ":
break // ignore whitespace
case TokeniserStateVars.nullScalr:
t.error(self)
t.createDoctypePending()
t.doctypePending.name.append(TokeniserStateVars.replacementChar)
t.transition(.DoctypeName)
break
case TokeniserStateVars.eof:
t.eofError(self)
t.createDoctypePending()
t.doctypePending.forceQuirks = true
try t.emitDoctypePending()
t.transition(.Data)
break
default:
t.createDoctypePending()