public override void Read(Tokeniser t, CharacterReader r)
{
if (r.IsEmpty())
{
t.EofError(this);
t.Emit("</");
t.Transition(Data);
}
else if (r.MatchesLetter())
{
t.CreateTagPending(false);
t.Transition(TagName);
}
else if (r.Matches('>'))
{
t.Error(this);
t.AdvanceTransition(Data);
}
else
{
t.Error(this);
t.AdvanceTransition(BogusComment);
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
char c = r.Consume();
switch (c)
{
case '\t':
case '\n':
case '\r':
case '\f':
case ' ':
break;
case '>':
t.EmitDoctypePending();
t.Transition(Data);
break;
case _eof:
t.EofError(this);
t.DoctypePending.ForceQuirks = true;
t.EmitDoctypePending();
t.Transition(Data);
break;
default:
t.Error(this);
t.Transition(BogusDoctype);
break;
// NOT force quirks
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
char c = r.Consume();
switch (c)
{
case '\t':
case '\n':
case '\r':
case '\f':
case ' ':
break;
case '"':
// set system id to empty string
t.Transition(DoctypeSystemIdentifierDoubleQuoted);
break;
case '\'':
// set public id to empty string
t.Transition(DoctypeSystemIdentifierSingleQuoted);
break;
case '>':
t.Error(this);
t.DoctypePending.ForceQuirks = true;
t.EmitDoctypePending();
t.Transition(Data);
break;
case _eof:
t.EofError(this);
t.DoctypePending.ForceQuirks = true;
t.EmitDoctypePending();
t.Transition(Data);
break;
default:
t.Error(this);
t.DoctypePending.ForceQuirks = true;
t.Transition(BogusDoctype);
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
char c = r.Consume();
switch (c)
{
case '\'':
t.Transition(AfterDoctypeSystemIdentifier);
break;
case _nullChar:
t.Error(this);
t.DoctypePending.SystemIdentifier.Append(_replacementChar);
break;
case '>':
t.Error(this);
t.DoctypePending.ForceQuirks = true;
t.EmitDoctypePending();
t.Transition(Data);
break;
case _eof:
t.EofError(this);
t.DoctypePending.ForceQuirks = true;
t.EmitDoctypePending();
t.Transition(Data);
break;
default:
t.DoctypePending.SystemIdentifier.Append(c);
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
char c = r.Consume();
switch (c)
{
case '-':
t.Emit(c);
break;
case '<':
t.Emit(c);
t.Transition(ScriptDataDoubleEscapedLessthanSign);
break;
case '>':
t.Emit(c);
t.Transition(ScriptData);
break;
case _nullChar:
t.Error(this);
t.Emit(_replacementChar);
t.Transition(ScriptDataDoubleEscaped);
break;
case _eof:
t.EofError(this);
t.Transition(Data);
break;
default:
t.Emit(c);
t.Transition(ScriptDataDoubleEscaped);
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
char c = r.Consume();
switch (c)
{
case '\t':
case '\n':
case '\r':
case '\f':
case ' ':
// ignore
break;
case '"':
t.Transition(AttributeValueDoubleQuoted);
break;
case '&':
r.Unconsume();
t.Transition(AttributeValueUnquoted);
break;
case '\'':
t.Transition(AttributeValueSingleQuoted);
break;
case _nullChar:
t.Error(this);
t.TagPending.AppendAttributeValue(_replacementChar);
t.Transition(AttributeValueUnquoted);
break;
case _eof:
t.EofError(this);
t.Transition(Data);
break;
case '>':
t.Error(this);
t.EmitTagPending();
t.Transition(Data);
break;
case '<':
case '=':
case '`':
t.Error(this);
t.TagPending.AppendAttributeValue(c);
t.Transition(AttributeValueUnquoted);
break;
default:
r.Unconsume();
t.Transition(AttributeValueUnquoted);
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
char c = r.Consume();
switch (c)
{
case '-':
t.CommentPending.Data.Append("--!");
t.Transition(CommentEndDash);
break;
case '>':
t.EmitCommentPending();
t.Transition(Data);
break;
case _nullChar:
t.Error(this);
t.CommentPending.Data.Append("--!").Append(_replacementChar);
t.Transition(Comment);
break;
case _eof:
t.EofError(this);
t.EmitCommentPending();
t.Transition(Data);
break;
default:
t.CommentPending.Data.Append("--!").Append(c);
t.Transition(Comment);
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
if (r.IsEmpty())
{
t.EofError(this);
t.Transition(Data);
return;
}
char c = r.Consume();
switch (c)
{
case '-':
t.Emit(c);
t.Transition(ScriptDataEscapedDashDash);
break;
case '<':
t.Transition(ScriptDataEscapedLessThanSign);
break;
case _nullChar:
t.Error(this);
t.Emit(_replacementChar);
t.Transition(ScriptDataEscaped);
break;
default:
t.Emit(c);
t.Transition(ScriptDataEscaped);
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
char c = r.Consume();
switch (c)
{
case '>':
t.TagPending.IsSelfClosing = true;
t.EmitTagPending();
t.Transition(Data);
break;
case _eof:
t.EofError(this);
t.Transition(Data);
break;
default:
t.Error(this);
t.Transition(BeforeAttributeName);
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
char c = r.Current();
switch (c)
{
case '-':
t.AdvanceTransition(CommentEndDash);
break;
case _nullChar:
t.Error(this);
r.Advance();
t.CommentPending.Data.Append(_replacementChar);
break;
case _eof:
t.EofError(this);
t.EmitCommentPending();
t.Transition(Data);
break;
default:
t.CommentPending.Data.Append(r.ConsumeToAny('-', _nullChar));
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
char c = r.Consume();
switch (c)
{
case '\t':
case '\n':
case '\r':
case '\f':
case ' ':
t.Transition(BeforeAttributeName);
break;
case '/':
t.Transition(SelfClosingStartTag);
break;
case '>':
t.EmitTagPending();
t.Transition(Data);
break;
case _eof:
t.EofError(this);
t.Transition(Data);
break;
default:
t.Error(this);
r.Unconsume();
t.Transition(BeforeAttributeName);
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
string value = r.ConsumeToAny('\t', '\n', '\r', '\f', ' ', '&', '>', _nullChar, '"', '\'', '<', '=', '`');
if (value.Length > 0)
{
t.TagPending.AppendAttributeValue(value);
}
char c = r.Consume();
switch (c)
{
case '\t':
case '\n':
case '\r':
case '\f':
case ' ':
t.Transition(BeforeAttributeName);
break;
case '&':
char? reference = t.ConsumeCharacterReference('>', true);
if (reference != null)
{
t.TagPending.AppendAttributeValue(reference.Value);
}
else
{
t.TagPending.AppendAttributeValue('&');
}
break;
case '>':
t.EmitTagPending();
t.Transition(Data);
break;
case _nullChar:
t.Error(this);
t.TagPending.AppendAttributeValue(_replacementChar);
break;
case _eof:
t.EofError(this);
t.Transition(Data);
break;
case '"':
case '\'':
case '<':
case '=':
case '`':
t.Error(this);
t.TagPending.AppendAttributeValue(c);
break;
// no default, handled in Consume to any above
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
string value = r.ConsumeToAny('\'', '&', _nullChar);
if (value.Length > 0)
{
t.TagPending.AppendAttributeValue(value);
}
char c = r.Consume();
switch (c)
{
case '\'':
t.Transition(AfterAttributeValueQuoted);
break;
case '&':
char? reference = t.ConsumeCharacterReference('\'', true);
if (reference != null)
{
t.TagPending.AppendAttributeValue(reference.Value);
}
else
{
t.TagPending.AppendAttributeValue('&');
}
break;
case _nullChar:
t.Error(this);
t.TagPending.AppendAttributeValue(_replacementChar);
break;
case _eof:
t.EofError(this);
t.Transition(Data);
break;
// no default, handled in Consume to any above
}
}
// from < or </ in data, will have start or end tag pending
public override void Read(Tokeniser t, CharacterReader r)
{
// previous TagOpen state did NOT Consume, will have a letter char in current
string tagName = r.ConsumeToAny('\t', '\n', '\r', '\f', ' ', '/', '>', _nullChar).ToLowerInvariant();
t.TagPending.AppendTagName(tagName);
switch (r.Consume())
{
case '\t':
case '\n':
case '\r':
case '\f':
case ' ':
t.Transition(BeforeAttributeName);
break;
case '/':
t.Transition(SelfClosingStartTag);
break;
case '>':
t.EmitTagPending();
t.Transition(Data);
break;
case _nullChar: // replacement
t.TagPending.AppendTagName(_replacementStr);
break;
case _eof: // should Emit pending tag?
t.EofError(this);
t.Transition(Data);
break;
// no default, as covered with above ConsumeToAny
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
if (r.MatchesLetter())
{
t.CreateDoctypePending();
t.Transition(DoctypeName);
return;
}
char c = r.Consume();
switch (c)
{
case '\t':
case '\n':
case '\r':
case '\f':
case ' ':
break; // ignore whitespace
case _nullChar:
t.Error(this);
t.DoctypePending.Name.Append(_replacementChar);
t.Transition(DoctypeName);
break;
case _eof:
t.EofError(this);
t.CreateDoctypePending();
t.DoctypePending.ForceQuirks = true;
t.EmitDoctypePending();
t.Transition(Data);
break;
default:
t.CreateDoctypePending();
t.DoctypePending.Name.Append(c);
t.Transition(DoctypeName);
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
if (r.IsEmpty())
{
t.EofError(this);
t.Transition(Data);
return;
}
switch (r.Current())
{
case '-':
t.Emit('-');
t.AdvanceTransition(ScriptDataEscapedDash);
break;
case '<':
t.AdvanceTransition(ScriptDataEscapedLessThanSign);
break;
case _nullChar:
t.Error(this);
r.Advance();
t.Emit(_replacementChar);
break;
default:
string data = r.ConsumeToAny('-', '<', _nullChar);
t.Emit(data);
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
if (r.MatchesLetter())
{
string name = r.ConsumeLetterSequence();
t.DoctypePending.Name.Append(name.ToLowerInvariant());
return;
}
char c = r.Consume();
switch (c)
{
case '>':
t.EmitDoctypePending();
t.Transition(Data);
break;
case '\t':
case '\n':
case '\r':
case '\f':
case ' ':
t.Transition(AfterDoctypeName);
break;
case _nullChar:
t.Error(this);
t.DoctypePending.Name.Append(_replacementChar);
break;
case _eof:
t.EofError(this);
t.DoctypePending.ForceQuirks = true;
t.EmitDoctypePending();
t.Transition(Data);
break;
default:
t.DoctypePending.Name.Append(c);
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
char c = r.Current();
switch (c)
{
case '-':
t.Emit(c);
t.AdvanceTransition(ScriptDataDoubleEscapedDash);
break;
case '<':
t.Emit(c);
t.AdvanceTransition(ScriptDataDoubleEscapedLessthanSign);
break;
case _nullChar:
t.Error(this);
r.Advance();
t.Emit(_replacementChar);
break;
case _eof:
t.EofError(this);
t.Transition(Data);
break;
default:
string data = r.ConsumeToAny('-', '<', _nullChar);
t.Emit(data);
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
if (r.IsEmpty())
{
t.EofError(this);
t.DoctypePending.ForceQuirks = true;
t.EmitDoctypePending();
t.Transition(Data);
return;
}
if (r.MatchesAny('\t', '\n', '\r', '\f', ' '))
{
r.Advance(); // ignore whitespace
}
else if (r.Matches('>'))
{
t.EmitDoctypePending();
t.AdvanceTransition(Data);
}
else if (r.MatchConsumeIgnoreCase("PUBLIC"))
{
t.Transition(AfterDoctypePublicKeyword);
}
else if (r.MatchConsumeIgnoreCase("SYSTEM"))
{
t.Transition(AfterDoctypeSystemKeyword);
}
else
{
t.Error(this);
t.DoctypePending.ForceQuirks = true;
t.AdvanceTransition(BogusDoctype);
}
}
// from tagname <xxx
public override void Read(Tokeniser t, CharacterReader r)
{
char c = r.Consume();
switch (c)
{
case '\t':
case '\n':
case '\r':
case '\f':
case ' ':
break; // ignore whitespace
case '/':
t.Transition(SelfClosingStartTag);
break;
case '>':
t.EmitTagPending();
t.Transition(Data);
break;
case _nullChar:
t.Error(this);
t.TagPending.NewAttribute();
r.Unconsume();
t.Transition(AttributeName);
break;
case _eof:
t.EofError(this);
t.Transition(Data);
break;
case '"':
case '\'':
case '<':
case '=':
t.Error(this);
t.TagPending.NewAttribute();
t.TagPending.AppendAttributeName(c);
t.Transition(AttributeName);
break;
default: // A-Z, anything else
t.TagPending.NewAttribute();
r.Unconsume();
t.Transition(AttributeName);
break;
}
}
// from before attribute name
public override void Read(Tokeniser t, CharacterReader r)
{
string name = r.ConsumeToAny('\t', '\n', '\r', '\f', ' ', '/', '=', '>', _nullChar, '"', '\'', '<');
t.TagPending.AppendAttributeName(name.ToLowerInvariant());
char c = r.Consume();
switch (c)
{
case '\t':
case '\n':
case '\r':
case '\f':
case ' ':
t.Transition(AfterAttributeName);
break;
case '/':
t.Transition(SelfClosingStartTag);
break;
case '=':
t.Transition(BeforeAttributeValue);
break;
case '>':
t.EmitTagPending();
t.Transition(Data);
break;
case _nullChar:
t.Error(this);
t.TagPending.AppendAttributeName(_replacementChar);
break;
case _eof:
t.EofError(this);
t.Transition(Data);
break;
case '"':
case '\'':
case '<':
t.Error(this);
t.TagPending.AppendAttributeName(c);
break;
// no default, as covered in ConsumeToAny
}
}
