/// <summary>
/// See 8.2.4.61 Between DOCTYPE public and system identifiers state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypeBetween(Char c, XmlDoctypeToken doctype)
{
while (c.IsSpaceCharacter())
c = _src.Next;
if (c == Specification.GT)
{
return doctype;
}
else if (c == Specification.DQ)
{
doctype.SystemIdentifier = String.Empty;
return DoctypeSystemIdentifierDoubleQuoted(_src.Next, doctype);
}
else if (c == Specification.SQ)
{
doctype.SystemIdentifier = String.Empty;
return DoctypeSystemIdentifierSingleQuoted(_src.Next, doctype);
}
else if (c == Specification.EOF)
{
RaiseErrorOccurred(ErrorCode.EOF);
_src.Back();
return doctype;
}
RaiseErrorOccurred(ErrorCode.DoctypeInvalidCharacter);
return BogusDoctype(_src.Next, doctype);
}
/// <summary>
/// See 8.2.4.55 After DOCTYPE name state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypeNameAfter(Char c, XmlDoctypeToken doctype)
{
while (c.IsSpaceCharacter())
c = _src.Next;
if (c == Specification.GT)
{
return doctype;
}
else if (c == Specification.EOF)
{
RaiseErrorOccurred(ErrorCode.EOF);
_src.Back();
return doctype;
}
else if (_src.ContinuesWith("PUBLIC", false))
{
_src.Advance(5);
return DoctypePublic(_src.Next, doctype);
}
else if (_src.ContinuesWith("SYSTEM", false))
{
_src.Advance(5);
return DoctypeSystem(_src.Next, doctype);
}
else if (c == Specification.SBO)
{
_src.Advance();
ScanInternalSubset(doctype);
return DoctypeAfter(_src.Next, doctype);
}
RaiseErrorOccurred(ErrorCode.DoctypeUnexpectedAfterName);
return BogusDoctype(_src.Next, doctype);
}
/// <summary>
/// See 8.2.4.54 DOCTYPE name state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypeName(Char c, XmlDoctypeToken doctype)
{
while (c.IsXmlName())
{
_stringBuffer.Append(c);
c = _src.Next;
}
doctype.Name = _stringBuffer.ToString();
_stringBuffer.Clear();
if (c == Specification.GT)
return doctype;
else if(c.IsSpaceCharacter())
return DoctypeNameAfter(_src.Next, doctype);
throw Errors.Xml(ErrorCode.DoctypeInvalid);
}
/// <summary>
/// The doctype finalizer.
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypeAfter(Char c, XmlDoctypeToken doctype)
{
while (c.IsSpaceCharacter())
c = _src.Next;
if (c == Specification.GT)
{
return doctype;
}
else if (c == Specification.EOF)
{
RaiseErrorOccurred(ErrorCode.EOF);
_src.Back();
return doctype;
}
RaiseErrorOccurred(ErrorCode.DoctypeInvalidCharacter);
return BogusDoctype(_src.Next, doctype);
}
/// <summary>
/// See 8.2.4.63 Before DOCTYPE system identifier state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypeSystemIdentifierBefore(Char c, XmlDoctypeToken doctype)
{
while (Specification.IsSpaceCharacter(c))
c = src.Next;
if (c == Specification.DQ)
{
doctype.SystemIdentifier = String.Empty;
return DoctypeSystemIdentifierDoubleQuoted(src.Next, doctype);
}
else if (c == Specification.SQ)
{
doctype.SystemIdentifier = String.Empty;
return DoctypeSystemIdentifierSingleQuoted(src.Next, doctype);
}
else if (c == Specification.GT)
{
RaiseErrorOccurred(ErrorCode.TagClosedWrong);
doctype.SystemIdentifier = stringBuffer.ToString();
return doctype;
}
else if (c == Specification.EOF)
{
RaiseErrorOccurred(ErrorCode.EOF);
doctype.SystemIdentifier = stringBuffer.ToString();
src.Back();
return doctype;
}
RaiseErrorOccurred(ErrorCode.DoctypeInvalidCharacter);
return BogusDoctype(src.Next, doctype);
}
/// <summary>
/// See 8.2.4.66 After DOCTYPE system identifier state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypeSystemIdentifierAfter(Char c, XmlDoctypeToken doctype)
{
while (Specification.IsSpaceCharacter(c))
c = src.Next;
if (c == Specification.GT)
{
return doctype;
}
else if (c == Specification.EOF)
{
RaiseErrorOccurred(ErrorCode.EOF);
src.Back();
return doctype;
}
RaiseErrorOccurred(ErrorCode.DoctypeInvalidCharacter);
return BogusDoctype(src.Next, doctype);
}
/// <summary>
/// See 8.2.4.57 Before DOCTYPE public identifier state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypePublicIdentifierBefore(Char c, XmlDoctypeToken doctype)
{
while (c.IsSpaceCharacter())
c = _src.Next;
if (c == Specification.DQ)
{
_stringBuffer.Clear();
doctype.PublicIdentifier = String.Empty;
return DoctypePublicIdentifierDoubleQuoted(_src.Next, doctype);
}
else if (c == Specification.SQ)
{
_stringBuffer.Clear();
doctype.PublicIdentifier = String.Empty;
return DoctypePublicIdentifierSingleQuoted(_src.Next, doctype);
}
else if (c == Specification.GT)
{
RaiseErrorOccurred(ErrorCode.TagClosedWrong);
return doctype;
}
else if (c == Specification.EOF)
{
RaiseErrorOccurred(ErrorCode.EOF);
_src.Back();
return doctype;
}
RaiseErrorOccurred(ErrorCode.DoctypePublicInvalid);
return BogusDoctype(_src.Next, doctype);
}
/// <summary>
/// See 8.2.4.56 After DOCTYPE public keyword state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypePublic(Char c, XmlDoctypeToken doctype)
{
if (Specification.IsSpaceCharacter(c))
{
return DoctypePublicIdentifierBefore(src.Next, doctype);
}
else if (c == Specification.DQ)
{
RaiseErrorOccurred(ErrorCode.DoubleQuotationMarkUnexpected);
doctype.PublicIdentifier = String.Empty;
return DoctypePublicIdentifierDoubleQuoted(src.Next, doctype);
}
else if (c == Specification.SQ)
{
RaiseErrorOccurred(ErrorCode.SingleQuotationMarkUnexpected);
doctype.PublicIdentifier = String.Empty;
return DoctypePublicIdentifierSingleQuoted(src.Next, doctype);
}
else if (c == Specification.GT)
{
RaiseErrorOccurred(ErrorCode.TagClosedWrong);
return doctype;
}
else if (c == Specification.EOF)
{
RaiseErrorOccurred(ErrorCode.EOF);
src.Back();
return doctype;
}
RaiseErrorOccurred(ErrorCode.DoctypePublicInvalid);
return BogusDoctype(src.Next, doctype);
}
/// <summary>
/// See 8.2.4.62 After DOCTYPE system keyword state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypeSystem(Char c, XmlDoctypeToken doctype)
{
if (c.IsSpaceCharacter())
{
while (c.IsSpaceCharacter())
c = _src.Next;
if (c == Specification.DQ || c == Specification.SQ)
{
doctype.SystemIdentifier = String.Empty;
return DoctypeSystemIdentifierValue(_src.Next, c, doctype);
}
}
throw Errors.Xml(ErrorCode.DoctypeInvalid);
}
/// <summary>
/// See 8.2.4.64 DOCTYPE system identifier (double-quoted) state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="q">The quote character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypeSystemIdentifierValue(Char c, Char q, XmlDoctypeToken doctype)
{
while (c != q)
{
if (c == Specification.EOF)
throw Errors.Xml(ErrorCode.EOF);
_stringBuffer.Append(c);
c = _src.Next;
}
doctype.SystemIdentifier = _stringBuffer.ToString();
_stringBuffer.Clear();
return DoctypeSystemIdentifierAfter(_src.Next, doctype);
}
/// <summary>
/// See 8.2.4.58 DOCTYPE public identifier (double-quoted) state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="q">The closing character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypePublicIdentifierValue(Char c, Char q, XmlDoctypeToken doctype)
{
while (c != q)
{
if (!c.IsPubidChar())
throw Errors.Xml(ErrorCode.XmlInvalidPubId);
_stringBuffer.Append(c);
c = _src.Next;
}
doctype.PublicIdentifier = _stringBuffer.ToString();
_stringBuffer.Clear();
return DoctypePublicIdentifierAfter(_src.Next, doctype);
}
/// <summary>
/// See 8.2.4.60 After DOCTYPE public identifier state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypePublicIdentifierAfter(Char c, XmlDoctypeToken doctype)
{
if (c == Specification.GT)
return doctype;
else if (c.IsSpaceCharacter())
return DoctypeBetween(_src.Next, doctype);
throw Errors.Xml(ErrorCode.DoctypeInvalid);
}
/// <summary>
/// See 8.2.4.55 After DOCTYPE name state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypeNameAfter(Char c, XmlDoctypeToken doctype)
{
while (c.IsSpaceCharacter())
c = _src.Next;
if (c == Specification.GT)
return doctype;
if (_src.ContinuesWith(PUBLIC, false))
{
_src.Advance(5);
return DoctypePublic(_src.Next, doctype);
}
else if (_src.ContinuesWith(SYSTEM, false))
{
_src.Advance(5);
return DoctypeSystem(_src.Next, doctype);
}
else if (c == Specification.SBO)
{
_src.Advance();
ScanInternalSubset(doctype);
return DoctypeAfter(_src.Next, doctype);
}
throw Errors.Xml(ErrorCode.DoctypeInvalid);
}
/// <summary>
/// See 8.2.4.54 DOCTYPE name state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypeName(Char c, XmlDoctypeToken doctype)
{
while (true)
{
if (Specification.IsSpaceCharacter(c))
{
doctype.Name = stringBuffer.ToString();
stringBuffer.Clear();
return DoctypeNameAfter(src.Next, doctype);
}
else if (c == Specification.GT)
{
doctype.Name = stringBuffer.ToString();
return doctype;
}
else if (c == Specification.NULL)
{
RaiseErrorOccurred(ErrorCode.NULL);
stringBuffer.Append(Specification.REPLACEMENT);
}
else if (c == Specification.EOF)
{
RaiseErrorOccurred(ErrorCode.EOF);
src.Back();
doctype.Name = stringBuffer.ToString();
return doctype;
}
else
stringBuffer.Append(c);
c = src.Next;
}
}
/// <summary>
/// See 8.2.4.58 DOCTYPE public identifier (double-quoted) state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypePublicIdentifierDoubleQuoted(Char c, XmlDoctypeToken doctype)
{
while (true)
{
if (c == Specification.DQ)
{
doctype.PublicIdentifier = _stringBuffer.ToString();
return DoctypePublicIdentifierAfter(_src.Next, doctype); ;
}
else if (c == Specification.NULL)
{
RaiseErrorOccurred(ErrorCode.NULL);
_stringBuffer.Append(Specification.REPLACEMENT);
}
else if (c == Specification.GT)
{
RaiseErrorOccurred(ErrorCode.TagClosedWrong);
doctype.PublicIdentifier = _stringBuffer.ToString();
return doctype;
}
else if (c == Specification.EOF)
{
RaiseErrorOccurred(ErrorCode.EOF);
_src.Back();
doctype.PublicIdentifier = _stringBuffer.ToString();
return doctype;
}
else
_stringBuffer.Append(c);
c = _src.Next;
}
}
/// <summary>
/// See 8.2.4.55 After DOCTYPE name state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypeNameAfter(Char c, XmlDoctypeToken doctype)
{
while (Specification.IsSpaceCharacter(c))
c = src.Next;
if (c == Specification.GT)
{
return doctype;
}
else if (c == Specification.EOF)
{
RaiseErrorOccurred(ErrorCode.EOF);
src.Back();
return doctype;
}
else if (src.ContinuesWith("PUBLIC", false))
{
src.Advance(5);
return DoctypePublic(src.Next, doctype);
}
else if (src.ContinuesWith("SYSTEM", false))
{
src.Advance(5);
return DoctypeSystem(src.Next, doctype);
}
RaiseErrorOccurred(ErrorCode.DoctypeUnexpectedAfterName);
return BogusDoctype(src.Next, doctype);
}
/// <summary>
/// See 8.2.4.62 After DOCTYPE system keyword state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypeSystem(Char c, XmlDoctypeToken doctype)
{
if (c.IsSpaceCharacter())
{
return DoctypeSystemIdentifierBefore(_src.Next, doctype);
}
else if (c == Specification.DQ)
{
RaiseErrorOccurred(ErrorCode.DoubleQuotationMarkUnexpected);
doctype.SystemIdentifier = String.Empty;
return DoctypeSystemIdentifierDoubleQuoted(_src.Next, doctype);
}
else if (c == Specification.SQ)
{
RaiseErrorOccurred(ErrorCode.SingleQuotationMarkUnexpected);
doctype.SystemIdentifier = String.Empty;
return DoctypeSystemIdentifierSingleQuoted(_src.Next, doctype);
}
else if (c == Specification.GT)
{
RaiseErrorOccurred(ErrorCode.TagClosedWrong);
doctype.SystemIdentifier = _stringBuffer.ToString();
return doctype;
}
else if (c == Specification.EOF)
{
RaiseErrorOccurred(ErrorCode.EOF);
_src.Back();
return doctype;
}
RaiseErrorOccurred(ErrorCode.DoctypeSystemInvalid);
return BogusDoctype(_src.Next, doctype);
}
/// <summary>
/// See 8.2.4.60 After DOCTYPE public identifier state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypePublicIdentifierAfter(Char c, XmlDoctypeToken doctype)
{
if (Specification.IsSpaceCharacter(c))
{
stringBuffer.Clear();
return DoctypeBetween(src.Next, doctype);
}
else if (c == Specification.GT)
{
return doctype;
}
else if (c == Specification.DQ)
{
RaiseErrorOccurred(ErrorCode.DoubleQuotationMarkUnexpected);
doctype.SystemIdentifier = String.Empty;
return DoctypeSystemIdentifierDoubleQuoted(src.Next, doctype);
}
else if (c == Specification.SQ)
{
RaiseErrorOccurred(ErrorCode.SingleQuotationMarkUnexpected);
doctype.SystemIdentifier = String.Empty;
return DoctypeSystemIdentifierSingleQuoted(src.Next, doctype);
}
else if (c == Specification.EOF)
{
RaiseErrorOccurred(ErrorCode.EOF);
src.Back();
return doctype;
}
RaiseErrorOccurred(ErrorCode.DoctypeInvalidCharacter);
return BogusDoctype(src.Next, doctype);
}
/// <summary>
/// See 8.2.4.66 After DOCTYPE system identifier state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypeSystemIdentifierAfter(Char c, XmlDoctypeToken doctype)
{
while (c.IsSpaceCharacter())
c = _src.Next;
if (c == Specification.SBO)
{
_src.Advance();
ScanInternalSubset(doctype);
c = _src.Next;
}
return DoctypeAfter(c, doctype);
}
/// <summary>
/// See 8.2.4.65 DOCTYPE system identifier (single-quoted) state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypeSystemIdentifierSingleQuoted(Char c, XmlDoctypeToken doctype)
{
while (true)
{
if (c == Specification.SQ)
{
doctype.SystemIdentifier = stringBuffer.ToString();
stringBuffer.Clear();
return DoctypeSystemIdentifierAfter(src.Next, doctype);
}
else if (c == Specification.NULL)
{
RaiseErrorOccurred(ErrorCode.NULL);
stringBuffer.Append(Specification.REPLACEMENT);
}
else if (c == Specification.GT)
{
RaiseErrorOccurred(ErrorCode.TagClosedWrong);
doctype.SystemIdentifier = stringBuffer.ToString();
return doctype;
}
else if (c == Specification.EOF)
{
RaiseErrorOccurred(ErrorCode.EOF);
doctype.SystemIdentifier = stringBuffer.ToString();
src.Back();
return doctype;
}
else
stringBuffer.Append(c);
c = src.Next;
}
}
void ScanInternalSubset(XmlDoctypeToken doctype)
{
var dtd = new DtdParser(_dtd, _src);
dtd.IsInternal = true;
dtd.ErrorOccurred += (s, e) => RaiseErrorOccurred(s, e);
dtd.Parse();
doctype.InternalSubset = dtd.Result.Text;
}
/// <summary>
/// See 8.2.4.67 Bogus DOCTYPE state
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken BogusDoctype(Char c, XmlDoctypeToken doctype)
{
while (true)
{
if (c == Specification.EOF)
{
src.Back();
return doctype;
}
else if (c == Specification.GT)
{
return doctype;
}
c = src.Next;
}
}
/// <summary>
/// The doctype finalizer.
/// </summary>
/// <param name="c">The next input character.</param>
/// <param name="doctype">The current doctype token.</param>
/// <returns>The emitted token.</returns>
XmlToken DoctypeAfter(Char c, XmlDoctypeToken doctype)
{
while (c.IsSpaceCharacter())
c = _src.Next;
if (c == Specification.GT)
return doctype;
throw Errors.Xml(ErrorCode.DoctypeInvalid);
}
