mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
620 lines
17 KiB
C#
620 lines
17 KiB
C#
// -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
|
|
//
|
|
// System.Xml.XmlInputSource.cs
|
|
// port of Open Xml TXmlInputSource class
|
|
//
|
|
// Author:
|
|
// Daniel Weber ([email protected]
|
|
//
|
|
// (C) 2001 Daniel Weber
|
|
//
|
|
//
|
|
|
|
using System;
|
|
using System.IO;
|
|
|
|
namespace System.Xml
|
|
{
|
|
internal class XmlInputSource
|
|
{
|
|
private DomEncodingType Fencoding;
|
|
|
|
private string FpublicID;
|
|
private string FsystemID;
|
|
public string FrootName;
|
|
|
|
private Stream FStream;
|
|
|
|
private bool FLastCharWasCR;
|
|
|
|
// locator
|
|
int FColumnNumber;
|
|
int FStartColumnNumber;
|
|
int FStartLineNumber;
|
|
bool FLastWCharWasLF;
|
|
int FLineNumber;
|
|
bool FPieceEndSet;
|
|
|
|
// Buffer storage for UTF-8 surrogates
|
|
// see http://www.ietf.org/rfc/rfc2279.txt for a complete description of UTF-8 encoding
|
|
private int FLastUcs4;
|
|
|
|
|
|
//FLocator: TdomStandardLocator;
|
|
|
|
// public properties
|
|
//===========================================================================
|
|
public DomEncodingType encoding
|
|
{
|
|
get
|
|
{
|
|
return Fencoding;
|
|
}
|
|
}
|
|
|
|
//property locator: TdomStandardLocator read FLocator;
|
|
public string publicId
|
|
{
|
|
get
|
|
{
|
|
return FpublicID;
|
|
}
|
|
}
|
|
|
|
public string rootName
|
|
{
|
|
get
|
|
{
|
|
return FrootName;
|
|
}
|
|
}
|
|
|
|
public Stream stream
|
|
{
|
|
get
|
|
{
|
|
return FStream;
|
|
}
|
|
}
|
|
|
|
public string streamAsWideString
|
|
{
|
|
get
|
|
{
|
|
return string.Empty;
|
|
//wideString read getStreamAsWideString;
|
|
}
|
|
}
|
|
|
|
public string systemId
|
|
{
|
|
get
|
|
{
|
|
return FsystemID;
|
|
}
|
|
}
|
|
|
|
public int columnNumber
|
|
{
|
|
get { return FColumnNumber; }
|
|
}
|
|
|
|
public int lineNumber
|
|
{
|
|
get { return FLineNumber; }
|
|
}
|
|
|
|
public int startColumnNumber
|
|
{
|
|
get { return FStartColumnNumber; }
|
|
}
|
|
|
|
public int startLineNumber
|
|
{
|
|
get { return FStartLineNumber; }
|
|
}
|
|
|
|
// private methods
|
|
//===========================================================================
|
|
/// <summary>
|
|
/// Analyze the first bytes of an XML document to try and determine encoding
|
|
/// </summary>
|
|
/// <returns>Determined encoding type, defaults to UTF-8</returns>
|
|
private void setEncodingType()
|
|
{
|
|
try
|
|
{
|
|
byte[] buf = new byte[4];
|
|
|
|
FStream.Seek(0, SeekOrigin.Begin);
|
|
FStream.Read(buf, 0, 4);
|
|
|
|
// UTF-16 code streams should begin with 0xfeff for big-endian systems
|
|
// or 0xfffe for little endian systems.
|
|
// check that first....
|
|
if ( (buf[0] == 0xfe) & (buf[1] == 0xff) )
|
|
Fencoding = DomEncodingType.etUTF16BE;
|
|
else if ( (buf[0] == 0xff) & (buf[1] == 0xfe) )
|
|
Fencoding = DomEncodingType.etUTF16LE;
|
|
else
|
|
{
|
|
// assume utf-8, look for encoding in <?xml version="1.0" encoding="ISO-8859-6"> tag, eg
|
|
Fencoding = DomEncodingType.etUTF8;
|
|
|
|
// Check if the stream begins with <?[X|x][M|m][L|l]
|
|
if ( (buf[0] == 0x3c) & (buf[1] == 0x3f) & // "<?"
|
|
((buf[2] == 0x78) | (buf[2] ==0x58) ) & // "x" or "X"
|
|
( (buf[2] == 0x6d) | (buf[3] ==0x4d) ) & // "m" or "M"
|
|
( (buf[2] == 0x6c) | (buf[2] ==0x4c) ) ) // "l" or "L"
|
|
{
|
|
|
|
string tag = "";
|
|
while (FStream.Position != FStream.Length)
|
|
{
|
|
char c = getNextChar();
|
|
tag += c;
|
|
|
|
if (c == '>')
|
|
break;
|
|
}
|
|
|
|
// start from the location of "encoding", and scan for quotes
|
|
string encodeString = readEncodingAttrFromTag(tag);
|
|
encodeString = encodeString.ToUpper();
|
|
|
|
if ( (encodeString.IndexOf("ISO-8859-1") != -1) |
|
|
(encodeString.IndexOf("LATIN-1") != -1) )
|
|
Fencoding = DomEncodingType.etLatin1;
|
|
else if ( (encodeString.IndexOf("ISO-8859-2") != -1) |
|
|
(encodeString.IndexOf("LATIN-2") != -1) )
|
|
Fencoding = DomEncodingType.etLatin2;
|
|
else if ( (encodeString.IndexOf("ISO-8859-3") != -1) |
|
|
(encodeString.IndexOf("LATIN-3") != -1) )
|
|
Fencoding = DomEncodingType.etLatin3;
|
|
else if ( (encodeString.IndexOf("ISO-8859-4") != -1) |
|
|
(encodeString.IndexOf("LATIN-4") != -1) )
|
|
Fencoding = DomEncodingType.etLatin4;
|
|
else if ( (encodeString.IndexOf("ISO-8859-5") != -1) |
|
|
(encodeString.IndexOf("CYRILLIC") != -1) )
|
|
Fencoding = DomEncodingType.etCyrillic;
|
|
else if ( (encodeString.IndexOf("ISO-8859-6") != -1) |
|
|
(encodeString.IndexOf("ARABIC") != -1) )
|
|
Fencoding = DomEncodingType.etArabic;
|
|
else if ( (encodeString.IndexOf("ISO-8859-7") != -1) |
|
|
(encodeString.IndexOf("GREEK") != -1) )
|
|
Fencoding = DomEncodingType.etGreek;
|
|
else if ( (encodeString.IndexOf("ISO-8859-8") != -1) |
|
|
(encodeString.IndexOf("HEBREW") != -1) )
|
|
Fencoding = DomEncodingType.etHebrew;
|
|
else if ( (encodeString.IndexOf("ISO-8859-9") != -1) |
|
|
(encodeString.IndexOf("LATIN-5") != -1) )
|
|
Fencoding = DomEncodingType.etLatin5;
|
|
else if ( (encodeString.IndexOf("ISO-8859-10") != -1) |
|
|
(encodeString.IndexOf("LATIN-6") != -1) )
|
|
Fencoding = DomEncodingType.etLatin6;
|
|
else if ( (encodeString.IndexOf("ISO-8859-13") != -1) |
|
|
(encodeString.IndexOf("LATIN-7") != -1) )
|
|
Fencoding = DomEncodingType.etLatin7;
|
|
else if ( (encodeString.IndexOf("ISO-8859-14") != -1) |
|
|
(encodeString.IndexOf("LATIN-8") != -1) )
|
|
Fencoding = DomEncodingType.etLatin8;
|
|
else if ( (encodeString.IndexOf("ISO-8859-15") != -1) |
|
|
(encodeString.IndexOf("LATIN-9") != -1) )
|
|
Fencoding = DomEncodingType.etLatin9;
|
|
else if (encodeString.IndexOf("KOI8-R") != -1)
|
|
Fencoding = DomEncodingType.etKOI8R;
|
|
else if (encodeString.IndexOf("CP10000_MACROMAN") != -1)
|
|
Fencoding = DomEncodingType.etcp10000_MacRoman;
|
|
else if ( (encodeString.IndexOf("Windows-1250") != -1) |
|
|
(encodeString.IndexOf("CP1250") != -1) )
|
|
Fencoding = DomEncodingType.etcp1250;
|
|
else if ( (encodeString.IndexOf("Windows-1251") != -1) |
|
|
(encodeString.IndexOf("CP1251") != -1) )
|
|
Fencoding = DomEncodingType.etcp1251;
|
|
else if ( (encodeString.IndexOf("Windows-1252") != -1) |
|
|
(encodeString.IndexOf("CP1252") != -1) )
|
|
Fencoding = DomEncodingType.etcp1252;
|
|
}
|
|
}
|
|
|
|
}
|
|
catch
|
|
{
|
|
Fencoding = DomEncodingType.etUTF8;
|
|
}
|
|
|
|
FStream.Seek(0, SeekOrigin.Begin);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Helper function to try and find the encoding attribute value in
|
|
/// declaration tag. Does not do well-formedness checks.
|
|
/// </summary>
|
|
/// <param name="tag">string to scan</param>
|
|
/// <exception cref="InvalidOperationException">If bad encoding char found, mis-matched quotes, or no equals sign.</exception>
|
|
/// <returns>encoding, or string.Empty if it is not found.</returns>
|
|
private string readEncodingAttrFromTag( string tag )
|
|
{
|
|
int encodeIndex = tag.IndexOf("encoding");
|
|
if ( encodeIndex == -1)
|
|
return string.Empty;
|
|
else
|
|
{
|
|
int curIndex = encodeIndex + "encoding".Length;
|
|
bool firstQuoteFound = false;
|
|
bool equalsFound = false;
|
|
char quoteChar = (char) 0xffff; // c# insists on initialization...
|
|
string encoding = "";
|
|
|
|
while ( curIndex != tag.Length )
|
|
{
|
|
char c = tag[curIndex];
|
|
curIndex++;
|
|
|
|
if ( c == '=')
|
|
{
|
|
equalsFound = true;
|
|
continue;
|
|
}
|
|
|
|
if ( (c== '\"') | (c=='\'') )
|
|
{
|
|
if ( !firstQuoteFound & !equalsFound)
|
|
throw new InvalidOperationException("No equals sign found in encoding attribute");
|
|
else if ( firstQuoteFound )
|
|
{
|
|
if (c == quoteChar)
|
|
return encoding;
|
|
else
|
|
throw new InvalidOperationException("non-matching quotes in attribute value");
|
|
}
|
|
else
|
|
{
|
|
firstQuoteFound = true;
|
|
quoteChar = c;
|
|
continue;
|
|
}
|
|
}
|
|
else if (firstQuoteFound)
|
|
{
|
|
if ( ( c >= 'a') & ( c <= 'z')) encoding += c;
|
|
else if ( ( c >= 'A') & ( c <= 'Z')) encoding += c;
|
|
else if ( ( c >= '0') & ( c <= '9')) encoding += c;
|
|
else if ( c == '_' ) encoding += c;
|
|
else if ( c == '-') encoding += c;
|
|
else if (c == '.') encoding += c;
|
|
else
|
|
throw new InvalidOperationException("invalid character in encoding attribute");
|
|
}
|
|
}
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
private void evaluate(char c)
|
|
{
|
|
if (FLastWCharWasLF)
|
|
{
|
|
FLineNumber++;
|
|
FLastWCharWasLF = false;
|
|
FColumnNumber = 1;
|
|
}
|
|
else
|
|
FColumnNumber++;
|
|
|
|
if (c == (char) 10 )
|
|
FLastWCharWasLF = true;
|
|
|
|
if (FPieceEndSet)
|
|
pieceStart();
|
|
}
|
|
|
|
public void pieceEnd()
|
|
{
|
|
FPieceEndSet = true;
|
|
}
|
|
|
|
public void pieceStart()
|
|
{
|
|
FStartColumnNumber = FColumnNumber;
|
|
FStartLineNumber = FLineNumber;
|
|
FPieceEndSet = false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return true if input stream is at EOF.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool atEOF()
|
|
{
|
|
return (FStream.Length == FStream.Position);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sets the internal root name by analyzing the tags at the beginning of the stream.
|
|
/// root name is:
|
|
/// - the element tag of the first element found
|
|
/// - the root name listed in a !DOCTYPE tag
|
|
/// - empty if a parse error occurs, or no applicable tags are found.
|
|
/// Does not do well-formedness checks - skips comments and proc. instructions
|
|
/// </summary>
|
|
private void getRootName()
|
|
{
|
|
reset();
|
|
FrootName = string.Empty;
|
|
|
|
while ( ! atEOF() )
|
|
{
|
|
string tag = "<";
|
|
char c = getNextChar();
|
|
|
|
// skip whitespace to first tag
|
|
while ( !atEOF() && (XmlNames_1_0.IsXmlWhiteSpace( c )) )
|
|
c = getNextChar();
|
|
if ( (c != '<') | atEOF() ) break;
|
|
|
|
while ( !atEOF() & ( c != '>' ) )
|
|
{
|
|
c = getNextChar();
|
|
tag += c;
|
|
}
|
|
if ( atEOF() ) break;
|
|
|
|
// Only allow 1) comments, 2) processing instructions before <!DOCTYPE ...>
|
|
if ( tag.StartsWith("<?") ) // Processing instruction
|
|
continue;
|
|
else if ( tag.StartsWith("<--") ) // comment
|
|
continue;
|
|
else if ( tag.StartsWith("<!DOCTYPE") ) // what we're looking for...
|
|
{
|
|
setRootName( tag );
|
|
break;
|
|
}
|
|
// no DOCTYPE tag? Use the first element tag as the root
|
|
else if ( tag.StartsWith( "<" ) )
|
|
setRootName( tag );
|
|
// we hit a non-comment, processing instruction or declaration, we ain't gonna get it
|
|
else
|
|
{
|
|
FrootName = string.Empty;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void setRootName( string doctypeTag )
|
|
{
|
|
int start = doctypeTag.IndexOf("<DOCTYPE");
|
|
if ( start == -1 )
|
|
start = 1; // set from element
|
|
else
|
|
start += "<DOCTYPE".Length;
|
|
while ( ( start != doctypeTag.Length ) & XmlNames_1_0.IsXmlWhiteSpace( doctypeTag[start] ) )
|
|
start++;
|
|
|
|
string tmp = string.Empty;
|
|
|
|
while ( ( start != doctypeTag.Length ) &&
|
|
!XmlNames_1_0.IsXmlWhiteSpace(doctypeTag[start]) &&
|
|
(doctypeTag[start] != '>') &&
|
|
(doctypeTag[start] != '[') &&
|
|
(doctypeTag[start] != '/') )
|
|
tmp += doctypeTag[start];
|
|
|
|
if (XmlNames_1_0.isXmlName(tmp) ) FrootName = tmp;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Read in the next character (either UTF-8 or UTF-16) and convert by charset
|
|
/// Normalize CR/LF pairs to single CR.
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public char getNextChar()
|
|
{
|
|
byte[] buf = new byte[2];
|
|
char retval = (char) 0xffff;
|
|
int bCount;
|
|
|
|
switch(Fencoding)
|
|
{
|
|
case DomEncodingType.etLatin1:
|
|
bCount = stream.Read(buf,0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.Iso8859_1ToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etLatin2:
|
|
bCount = stream.Read(buf, 0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.Iso8859_2ToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etLatin3:
|
|
bCount = stream.Read(buf, 0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.Iso8859_3ToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etLatin4:
|
|
bCount = stream.Read(buf, 0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.Iso8859_4ToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etCyrillic:
|
|
bCount = stream.Read(buf, 0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.Iso8859_5ToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etArabic:
|
|
bCount = stream.Read(buf, 0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.Iso8859_6ToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etGreek:
|
|
bCount = stream.Read(buf, 0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.Iso8859_7ToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etHebrew:
|
|
bCount = stream.Read(buf, 0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.Iso8859_8ToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etLatin5:
|
|
bCount = stream.Read(buf, 0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.Iso8859_9ToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etLatin6:
|
|
bCount = stream.Read(buf, 0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.Iso8859_10ToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etLatin7:
|
|
bCount = stream.Read(buf, 0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.Iso8859_13ToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etLatin8:
|
|
bCount = stream.Read(buf, 0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.Iso8859_14ToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etLatin9:
|
|
bCount = stream.Read(buf, 0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.Iso8859_15ToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etKOI8R:
|
|
bCount = stream.Read(buf, 0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.KOI8_RToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etcp10000_MacRoman:
|
|
bCount = stream.Read(buf, 0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.cp10000_MacRomanToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etcp1250:
|
|
bCount = stream.Read(buf, 0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.cp1250ToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etcp1251:
|
|
bCount = stream.Read(buf, 0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.cp1251ToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etcp1252:
|
|
bCount = stream.Read(buf, 0, 1);
|
|
if (bCount == 1)
|
|
retval = XmlUtil.cp1252ToUTF16Char(buf[0]);
|
|
break;
|
|
case DomEncodingType.etUTF8:
|
|
if ( FLastUcs4 >= 0x10000)
|
|
{
|
|
// Output low surrogate
|
|
retval = XmlUtil.Utf16LowSurrogate(FLastUcs4);
|
|
FLastUcs4 = 0;
|
|
}
|
|
else
|
|
{
|
|
FLastUcs4 = XmlUtil.ReadUTF8Char( stream );
|
|
if ( FLastUcs4 >= 0x10000)
|
|
retval = XmlUtil.Utf16HighSurrogate(FLastUcs4);
|
|
else
|
|
retval = (char) FLastUcs4;
|
|
}
|
|
break;
|
|
case DomEncodingType.etUTF16BE:
|
|
bCount = stream.Read(buf, 0, 2);
|
|
if (bCount == 2)
|
|
retval = System.Convert.ToChar( (buf[0] << 16) + buf[1] );
|
|
break;
|
|
case DomEncodingType.etUTF16LE:
|
|
bCount = stream.Read(buf, 0, 2);
|
|
if (bCount == 2)
|
|
retval = System.Convert.ToChar( (buf[1] << 16) + buf[0] );
|
|
break;
|
|
}
|
|
|
|
// normalize CRLF or a single CR to LF:
|
|
if ( (retval == 0x000D) & FLastCharWasCR) // 0x000d = CR
|
|
{
|
|
FLastCharWasCR = false;
|
|
return getNextChar();
|
|
}
|
|
else if ( retval == 0x000A) // 0x000a = LF
|
|
{
|
|
FLastCharWasCR = true;
|
|
return (char) 0x000D;
|
|
}
|
|
else
|
|
FLastCharWasCR = false;
|
|
|
|
evaluate(retval);
|
|
return retval;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reset the Input to the origin and clear internal variables.
|
|
/// </summary>
|
|
public void reset()
|
|
{
|
|
FLastUcs4 = 0;
|
|
FLastCharWasCR = false;
|
|
|
|
switch(Fencoding)
|
|
{
|
|
// skip the leading 0xfeff/oxfffe on UTF-16 streams
|
|
case DomEncodingType.etUTF16BE:
|
|
FStream.Seek(2, SeekOrigin.Begin);
|
|
break;
|
|
case DomEncodingType.etUTF16LE:
|
|
FStream.Seek(2, SeekOrigin.Begin);
|
|
break;
|
|
default:
|
|
FStream.Seek(0, SeekOrigin.Begin);
|
|
break;
|
|
}
|
|
|
|
FColumnNumber = 0;
|
|
FLineNumber = 0;
|
|
FStartColumnNumber = 0;
|
|
FStartLineNumber = 0;
|
|
FLastWCharWasLF = true;
|
|
pieceEnd();
|
|
}
|
|
|
|
/*
|
|
* private
|
|
|
|
|
|
protected
|
|
function getStreamAsWideString: wideString; virtual;
|
|
procedure skipTextDecl(const locator: TdomStandardLocator); virtual;
|
|
public
|
|
constructor create(const stream: TStream;
|
|
const publicId,
|
|
systemId: wideString); virtual;
|
|
destructor destroy; override;
|
|
|
|
|
|
*/
|
|
// Constructor
|
|
//===========================================================================
|
|
XmlInputSource(Stream inputStream, string publicID, string systemID)
|
|
{
|
|
if (inputStream == null)
|
|
throw new NullReferenceException("Null stream passed to XmlInputSource constructor");
|
|
|
|
FStream = inputStream;
|
|
FLastUcs4 = 0;
|
|
FLastCharWasCR = false;
|
|
FpublicID = publicID;
|
|
FsystemID = systemID;
|
|
setEncodingType();
|
|
//FLocator:= TdomStandardLocator.create(self);
|
|
getRootName();
|
|
}
|
|
}
|
|
|
|
}
|