// from < in data
public override void Read(Tokeniser t, CharacterReader r)
{
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(this);
t.Emit('<'); // char that got us here
t.Transition(Data);
}
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;
}
}
// handles data in title, textarea etc
public override void Read(Tokeniser t, CharacterReader r)
{
switch (r.Current)
{
case '&':
t.AdvanceTransition(CharacterReferenceInRcdata);
break;
case '<':
t.AdvanceTransition(RcdataLessthanSign);
break;
case nullChar:
t.Error(this);
r.Advance();
t.Emit(replacementChar);
break;
case eof:
t.Emit(Token.EOF.Instance);
break;
default:
string data = r.ConsumeToAny('&', '<', nullChar);
t.Emit(data);
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
char c = r.Consume();
switch (c)
{
case '\t':
case '\n':
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;
}
}
// in data state, gather characters until a char reference or tag is found
public override void Read(Tokeniser t, CharacterReader r)
{
switch (r.Current)
{
case '&':
t.AdvanceTransition(CharacterReferenceInData);
break;
case '<':
t.AdvanceTransition(TagOpen);
break;
case nullChar:
t.Error(this); // NOT replacement char (oddly?)
t.Emit(r.Consume());
break;
case eof:
t.Emit(Token.EOF.Instance);
break;
default:
string data = r.ConsumeToAny('&', '<', nullChar);
t.Emit(data);
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)
{
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.Transition(CommentStartDash);
break;
case nullChar:
t.Error(this);
t.commentPending.data.Append(replacementChar);
t.Transition(Comment);
break;
case '>':
t.Error(this);
t.EmitCommentPending();
t.Transition(Data);
break;
case eof:
t.EofError(this);
t.EmitCommentPending();
t.Transition(Data);
break;
default:
t.commentPending.data.Append(c);
t.Transition(Comment);
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
char c = r.Consume();
switch (c)
{
case '\t':
case '\n':
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);
// NOT force quirks
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', '\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);
}
}
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)
{
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)
{
string value = r.ConsumeToAny('\t', '\n', '\f', ' ', '&', '>', nullChar, '"', '\'', '<', '=', '`');
if (value.Length > 0)
{
t.tagPending.AppendAttributeValue(value);
}
char c = r.Consume();
switch (c)
{
case '\t':
case '\n':
case '\f':
case ' ':
t.Transition(BeforeAttributeName);
break;
case '&':
string ref2 = t.ConsumeCharacterReference('>', true);
if (ref2 == null)
{
t.tagPending.AppendAttributeValue('&');
}
else
{
t.tagPending.AppendAttributeValue(ref2);
}
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 data = r.ConsumeTo("]]>");
t.Emit(data);
r.MatchConsume("]]>");
t.Transition(Data);
}
public override void Read(Tokeniser t, CharacterReader r)
{
char c = r.Consume();
switch (c)
{
case '\t':
case '\n':
case '\f':
case ' ':
// ignore
break;
case '"':
t.Transition(AttributeValue_doubleQuoted);
break;
case '&':
r.Unconsume();
t.Transition(AttributeValue_unquoted);
break;
case '\'':
t.Transition(AttributeValue_singleQuoted);
break;
case nullChar:
t.Error(this);
t.tagPending.AppendAttributeValue(replacementChar);
t.Transition(AttributeValue_unquoted);
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(AttributeValue_unquoted);
break;
default:
r.Unconsume();
t.Transition(AttributeValue_unquoted);
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
if (r.MatchesLetter())
{
string name = r.ConsumeLetterSequence();
t.tagPending.AppendTagName(name.ToLowerInvariant());
t.dataBuffer.Append(name);
return;
}
char c = r.Consume();
switch (c)
{
case '\t':
case '\n':
case '\f':
case ' ':
if (t.IsAppropriateEndTagToken())
{
t.Transition(BeforeAttributeName);
}
else
{
AnythingElse(t, r);
}
break;
case '/':
if (t.IsAppropriateEndTagToken())
{
t.Transition(SelfClosingStartTag);
}
else
{
AnythingElse(t, r);
}
break;
case '>':
if (t.IsAppropriateEndTagToken())
{
t.EmitTagPending();
t.Transition(Data);
}
else
{
AnythingElse(t, r);
}
break;
default:
AnythingElse(t, r);
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
if (r.Matches('-'))
{
t.Emit('-');
t.AdvanceTransition(ScriptDataEscapedDashDash);
}
else
{
t.Transition(ScriptData);
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
char c = r.Consume();
switch (c)
{
case '\t':
case '\n':
case '\f':
case ' ':
// ignore
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);
t.Transition(AttributeName);
break;
case eof:
t.EofError(this);
t.Transition(Data);
break;
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;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
if (r.Matches('/'))
{
t.CreateTempBuffer();
t.AdvanceTransition(RawtextEndTagOpen);
}
else
{
t.Emit('<');
t.Transition(Rawtext);
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
// TODO: handle bogus comment starting from eof. when does that trigger?
// rewind to capture char that lead us here
r.Unconsume();
Token.Comment comment = new Token.Comment();
comment.data.Append(r.ConsumeTo('>'));
comment.IsBogus = true;
// TODO: replace nullChar with replaceChar
t.Emit(comment);
t.AdvanceTransition(Data);
}
public override void Read(Tokeniser t, CharacterReader r)
{
if (r.Matches('/'))
{
t.Emit('/');
t.CreateTempBuffer();
t.AdvanceTransition(ScriptDataDoubleEscapeEnd);
}
else
{
t.Transition(ScriptDataDoubleEscaped);
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
if (r.MatchesLetter())
{
t.CreateTagPending(false);
t.Transition(ScriptDataEndTagName);
}
else
{
t.Emit("</");
t.Transition(ScriptData);
}
}
protected virtual void InitialiseParse(string input, Uri baseUri, HtmlParseErrorCollection errors)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
this.doc = CreateDocument(baseUri);
this.reader = new CharacterReader(input);
this.errors = errors;
this.tokeniser = new Tokeniser(reader, errors);
this.stack = new DescendableLinkedList <DomContainer>();
this.baseUri = baseUri;
}
// from before attribute name
public override void Read(Tokeniser t, CharacterReader r)
{
string name = r.ConsumeToAny('\t', '\n', '\f', ' ', '/', '=', '>', nullChar, '"', '\'', '<');
t.tagPending.AppendAttributeName(name.ToLowerInvariant());
char c = r.Consume();
switch (c)
{
case '\t':
case '\n':
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);
// no default, as covered in consumeToAny
break;
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
if (r.MatchesLetter())
{
t.CreateTagPending(false);
t.tagPending.AppendTagName(char.ToLowerInvariant(r.Current));
t.dataBuffer.Append(r.Current);
t.AdvanceTransition(ScriptDataEscapedEndTagName);
}
else
{
t.Emit("</");
t.Transition(ScriptDataEscaped);
}
}
// from & in data
public override void Read(Tokeniser t, CharacterReader r)
{
string c = t.ConsumeCharacterReference(null, false);
if (c == null)
{
t.Emit('&');
}
else
{
t.Emit(c);
}
t.Transition(Data);
}
public override void Read(Tokeniser t, CharacterReader r)
{
char c = r.Consume();
switch (c)
{
case '\t':
case '\n':
case '\f':
case ' ':
t.Transition(BeforeDoctypeSystemIdentifier);
break;
case '>':
t.Error(this);
t.doctypePending.forceQuirks = true;
t.EmitDoctypePending();
t.Transition(Data);
break;
case '"':
t.Error(this);
// system id empty
t.Transition(DoctypeSystemIdentifier_doubleQuoted);
break;
case '\'':
t.Error(this);
// system id empty
t.Transition(DoctypeSystemIdentifier_singleQuoted);
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.EmitDoctypePending();
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 '\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)
{
string value = r.ConsumeToAny('\'', '&', nullChar);
if (value.Length > 0)
{
t.tagPending.AppendAttributeValue(value);
}
char c = r.Consume();
switch (c)
{
case '\'':
t.Transition(AfterAttributeValue_quoted);
break;
case '&':
string ref2 = t.ConsumeCharacterReference('\'', true);
if (ref2 == null)
{
t.tagPending.AppendAttributeValue('&');
}
else
{
t.tagPending.AppendAttributeValue(ref2);
}
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
}
}
public override void Read(Tokeniser t, CharacterReader r)
{
if (r.MatchesLetter())
{
t.CreateTempBuffer();
t.dataBuffer.Append(char.ToLowerInvariant(r.Current));
t.Emit("<" + r.Current);
t.AdvanceTransition(ScriptDataDoubleEscapeStart);
}
else if (r.Matches('/'))
{
t.CreateTempBuffer();
t.AdvanceTransition(ScriptDataEscapedEndTagOpen);
}
else
{
t.Emit('<');
t.Transition(ScriptDataEscaped);
}
}
