public DiffConfiguration(string description,
WhitespaceHandling whitespaceHandling)
: this(description,
DEFAULT_USE_VALIDATING_PARSER,
whitespaceHandling)
{
}
public DiffConfiguration(string description,
bool useValidatingParser,
WhitespaceHandling whitespaceHandling)
: this(description, useValidatingParser, whitespaceHandling,
DEFAULT_IGNORE_ATTRIBUTE_ORDER,DEFAULT_IGNORE_ATTRIBUTE)
{
}
public DiffConfiguration(string description,
bool useValidatingParser,
WhitespaceHandling whitespaceHandling)
: this(description, useValidatingParser, whitespaceHandling,
DEFAULT_IGNORE_ATTRIBUTE_ORDER)
{
}
public DiffConfiguration(string description,
WhitespaceHandling whitespaceHandling)
: this(description,
DEFAULT_USE_VALIDATING_PARSER,
whitespaceHandling)
{
}
///<summary>
/// Constructor.
///</summary>
public DiffConfiguration(string description,
bool useValidatingParser,
WhitespaceHandling whitespaceHandling) {
_description = description;
_useValidatingParser = useValidatingParser;
_whitespaceHandling = whitespaceHandling;
}
//
// Copy a configuration section to a string, and advance the reader.
//
internal string CopySection()
{
ResetCachedStringWriter();
// Preserve whitespace for sections for backcompat
WhitespaceHandling originalHandling = _reader.WhitespaceHandling;
_reader.WhitespaceHandling = WhitespaceHandling.All;
// Create string writer to write to
XmlUtilWriter utilWriter = new XmlUtilWriter(_cachedStringWriter, false);
// Copy the element
CopyElement(utilWriter);
// Reset whitespace handling
_reader.WhitespaceHandling = originalHandling;
if ((originalHandling == WhitespaceHandling.None) &&
(Reader.NodeType == XmlNodeType.Whitespace))
{
// If we were previously suppose to skip whitespace, and now we
// are at it, then lets jump to the next item
_reader.Read();
}
utilWriter.Flush();
string s = ((StringWriter)utilWriter.Writer).ToString();
return(s);
}
private static IDisposable GetWhitespaceHandlingRestorer(XmlReader reader, WhitespaceHandling handling)
{
if (reader is XmlaReader)
{
return(((XmlaReader)reader).GetWhitespaceHandlingRestorer(handling));
}
return(FormattersHelpers.emptyRestorer);
}
public DiffConfiguration(string description,
bool useValidatingParser,
WhitespaceHandling whitespaceHandling)
{
_description = description;
_useValidatingParser = useValidatingParser;
_whitespaceHandling = whitespaceHandling;
}
public static StringCollection GetXMLTextLines(string strFileName, WhitespaceHandling eWS)
{
using (XmlTextReader Reader = new XmlTextReader(strFileName))
{
Reader.WhitespaceHandling = eWS;
StringCollection Coll = GetXMLTextLines(Reader, eWS);
return(Coll);
}
}
public static StringCollection GetXMLTextLinesFromXML(string strXML, WhitespaceHandling eWS)
{
using (StringReader SR = new StringReader(strXML))
using (XmlTextReader XR = new XmlTextReader(SR))
{
StringCollection Coll = Functions.GetXMLTextLines(XR, eWS);
return(Coll);
}
}
public DiffConfiguration(string description,
bool useValidatingParser,
WhitespaceHandling whitespaceHandling,
bool ignoreAttributeOrder) {
_description = description;
_useValidatingParser = useValidatingParser;
_whitespaceHandling = whitespaceHandling;
this.ignoreAttributeOrder = ignoreAttributeOrder;
}
public DiffConfiguration(string description,
bool useValidatingParser,
WhitespaceHandling whitespaceHandling,
bool ignoreAttributeOrder)
{
_description = description;
_useValidatingParser = useValidatingParser;
_whitespaceHandling = whitespaceHandling;
this.ignoreAttributeOrder = ignoreAttributeOrder;
}
public QueryReaderSettings(XmlReader reader)
{
#pragma warning disable 618
XmlValidatingReader?valReader = reader as XmlValidatingReader;
#pragma warning restore 618
if (valReader != null)
{
// Unwrap validation reader
_validatingReader = true;
reader = valReader.Impl.Reader;
}
_xmlReaderSettings = reader.Settings;
if (_xmlReaderSettings != null)
{
_xmlReaderSettings = _xmlReaderSettings.Clone();
_xmlReaderSettings.NameTable = reader.NameTable;
_xmlReaderSettings.CloseInput = true;
_xmlReaderSettings.LineNumberOffset = 0;
_xmlReaderSettings.LinePositionOffset = 0;
XmlTextReaderImpl?impl = reader as XmlTextReaderImpl;
if (impl != null)
{
_xmlReaderSettings.XmlResolver = impl.GetResolver();
}
}
else
{
_xmlNameTable = reader.NameTable;
XmlTextReader?xmlTextReader = reader as XmlTextReader;
if (xmlTextReader != null)
{
XmlTextReaderImpl impl = xmlTextReader.Impl;
_entityHandling = impl.EntityHandling;
_namespaces = impl.Namespaces;
_normalization = impl.Normalization;
_prohibitDtd = (impl.DtdProcessing == DtdProcessing.Prohibit);
_whitespaceHandling = impl.WhitespaceHandling;
_xmlResolver = impl.GetResolver();
}
else
{
_entityHandling = EntityHandling.ExpandEntities;
_namespaces = true;
_normalization = true;
_prohibitDtd = true;
_whitespaceHandling = WhitespaceHandling.All;
_xmlResolver = null;
}
}
}
public QueryReaderSettings(XmlReader reader)
{
#pragma warning disable 618
XmlValidatingReader valReader = reader as XmlValidatingReader;
#pragma warning restore 618
if (valReader != null)
{
// Unwrap validation reader
_validatingReader = true;
reader = valReader.Impl.Reader;
}
_xmlReaderSettings = reader.Settings;
if (_xmlReaderSettings != null)
{
_xmlReaderSettings = _xmlReaderSettings.Clone();
_xmlReaderSettings.NameTable = reader.NameTable;
_xmlReaderSettings.CloseInput = true;
_xmlReaderSettings.LineNumberOffset = 0;
_xmlReaderSettings.LinePositionOffset = 0;
XmlTextReaderImpl impl = reader as XmlTextReaderImpl;
if (impl != null)
{
_xmlReaderSettings.XmlResolver = impl.GetResolver();
}
}
else
{
_xmlNameTable = reader.NameTable;
XmlTextReader xmlTextReader = reader as XmlTextReader;
if (xmlTextReader != null)
{
XmlTextReaderImpl impl = xmlTextReader.Impl;
_entityHandling = impl.EntityHandling;
_namespaces = impl.Namespaces;
_normalization = impl.Normalization;
_prohibitDtd = (impl.DtdProcessing == DtdProcessing.Prohibit);
_whitespaceHandling = impl.WhitespaceHandling;
_xmlResolver = impl.GetResolver();
}
else
{
_entityHandling = EntityHandling.ExpandEntities;
_namespaces = true;
_normalization = true;
_prohibitDtd = true;
_whitespaceHandling = WhitespaceHandling.All;
_xmlResolver = null;
}
}
}
public QueryReaderSettings(XmlReader reader)
{
#pragma warning disable 618
XmlValidatingReader valReader = reader as XmlValidatingReader;
#pragma warning restore 618
if (valReader != null)
{
// Unwrap validation reader
validatingReader = true;
reader = valReader.Impl.Reader;
}
xmlReaderSettings = reader.Settings;
if (xmlReaderSettings != null)
{
xmlReaderSettings = xmlReaderSettings.Clone();
xmlReaderSettings.NameTable = reader.NameTable;
xmlReaderSettings.CloseInput = true;
xmlReaderSettings.LineNumberOffset = 0;
xmlReaderSettings.LinePositionOffset = 0;
XmlTextReaderImpl impl = reader as XmlTextReaderImpl;
if (impl != null)
{
xmlReaderSettings.XmlResolver = impl.GetResolver();
}
}
else
{
xmlNameTable = reader.NameTable;
XmlTextReader xmlTextReader = reader as XmlTextReader;
if (xmlTextReader != null)
{
XmlTextReaderImpl impl = xmlTextReader.Impl;
entityHandling = impl.EntityHandling;
namespaces = impl.Namespaces;
normalization = impl.Normalization;
prohibitDtd = impl.ProhibitDtd;
whitespaceHandling = impl.WhitespaceHandling;
xmlResolver = impl.GetResolver();
}
else
{
entityHandling = EntityHandling.ExpandEntities;
namespaces = true;
normalization = true;
prohibitDtd = true;
whitespaceHandling = WhitespaceHandling.All;
xmlResolver = null;
}
}
}
public QueryReaderSettings(XmlReader reader)
{
XmlValidatingReader reader2 = reader as XmlValidatingReader;
if (reader2 != null)
{
this.validatingReader = true;
reader = reader2.Impl.Reader;
}
this.xmlReaderSettings = reader.Settings;
if (this.xmlReaderSettings != null)
{
this.xmlReaderSettings = this.xmlReaderSettings.Clone();
this.xmlReaderSettings.NameTable = reader.NameTable;
this.xmlReaderSettings.CloseInput = true;
this.xmlReaderSettings.LineNumberOffset = 0;
this.xmlReaderSettings.LinePositionOffset = 0;
XmlTextReaderImpl impl = reader as XmlTextReaderImpl;
if (impl != null)
{
this.xmlReaderSettings.XmlResolver = impl.GetResolver();
}
}
else
{
this.xmlNameTable = reader.NameTable;
XmlTextReader reader3 = reader as XmlTextReader;
if (reader3 != null)
{
XmlTextReaderImpl impl2 = reader3.Impl;
this.entityHandling = impl2.EntityHandling;
this.namespaces = impl2.Namespaces;
this.normalization = impl2.Normalization;
this.prohibitDtd = impl2.DtdProcessing == DtdProcessing.Prohibit;
this.whitespaceHandling = impl2.WhitespaceHandling;
this.xmlResolver = impl2.GetResolver();
}
else
{
this.entityHandling = EntityHandling.ExpandEntities;
this.namespaces = true;
this.normalization = true;
this.prohibitDtd = true;
this.whitespaceHandling = WhitespaceHandling.All;
this.xmlResolver = null;
}
}
}
/// <summary>
/// 反序列化 链接
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="fileUrl"></param>
/// <param name="whitespaceHandling"></param>
/// <returns></returns>
public static T Deserialize <T>(string fileUrl, WhitespaceHandling whitespaceHandling = WhitespaceHandling.All) where T : class
{
try
{
using (XmlTextReader reader = new XmlTextReader(fileUrl))
{
reader.WhitespaceHandling = whitespaceHandling;
XmlSerializer serializer = new XmlSerializer(typeof(T));
return(serializer.Deserialize(reader) as T);
}
}
catch (Exception)
{
return(null);
}
}
public QueryReaderSettings(XmlReader reader)
{
XmlValidatingReader reader2 = reader as XmlValidatingReader;
if (reader2 != null)
{
this.validatingReader = true;
reader = reader2.Impl.Reader;
}
this.xmlReaderSettings = reader.Settings;
if (this.xmlReaderSettings != null)
{
this.xmlReaderSettings = this.xmlReaderSettings.Clone();
this.xmlReaderSettings.NameTable = reader.NameTable;
this.xmlReaderSettings.CloseInput = true;
this.xmlReaderSettings.LineNumberOffset = 0;
this.xmlReaderSettings.LinePositionOffset = 0;
XmlTextReaderImpl impl = reader as XmlTextReaderImpl;
if (impl != null)
{
this.xmlReaderSettings.XmlResolver = impl.GetResolver();
}
}
else
{
this.xmlNameTable = reader.NameTable;
XmlTextReader reader3 = reader as XmlTextReader;
if (reader3 != null)
{
XmlTextReaderImpl impl2 = reader3.Impl;
this.entityHandling = impl2.EntityHandling;
this.namespaces = impl2.Namespaces;
this.normalization = impl2.Normalization;
this.prohibitDtd = impl2.DtdProcessing == DtdProcessing.Prohibit;
this.whitespaceHandling = impl2.WhitespaceHandling;
this.xmlResolver = impl2.GetResolver();
}
else
{
this.entityHandling = EntityHandling.ExpandEntities;
this.namespaces = true;
this.normalization = true;
this.prohibitDtd = true;
this.whitespaceHandling = WhitespaceHandling.All;
this.xmlResolver = null;
}
}
}
internal string CopySection()
{
this.ResetCachedStringWriter();
WhitespaceHandling whitespaceHandling = this._reader.WhitespaceHandling;
this._reader.WhitespaceHandling = WhitespaceHandling.All;
XmlUtilWriter utilWriter = new XmlUtilWriter(this._cachedStringWriter, false);
this.CopyElement(utilWriter);
this._reader.WhitespaceHandling = whitespaceHandling;
if ((whitespaceHandling == WhitespaceHandling.None) && (this.Reader.NodeType == XmlNodeType.Whitespace))
{
this._reader.Read();
}
utilWriter.Flush();
return(((StringWriter)utilWriter.Writer).ToString());
}
public static List <ResXItem> ParseResxMarkup(string resxMarkup)
{
List <ResXItem> items = new List <ResXItem>();
XmlTextReader resxReader = new XmlTextReader(new StringReader(resxMarkup));
while (resxReader.Read())
{
if ((resxReader.NodeType == XmlNodeType.Element) &&
(String.CompareOrdinal(resxReader.LocalName, "data") == 0))
{
string name = resxReader["name"];
string value = null;
string comment = null;
while (resxReader.Read())
{
if (resxReader.NodeType == XmlNodeType.Element)
{
if (String.CompareOrdinal(resxReader.LocalName, "value") == 0)
{
WhitespaceHandling oldWhitespace = resxReader.WhitespaceHandling;
resxReader.WhitespaceHandling = WhitespaceHandling.Significant;
value = resxReader.ReadString();
resxReader.WhitespaceHandling = oldWhitespace;
}
else if (String.CompareOrdinal(resxReader.LocalName, "comment") == 0)
{
comment = resxReader.ReadString();
}
}
else if ((resxReader.NodeType == XmlNodeType.EndElement) &&
(String.CompareOrdinal(resxReader.LocalName, "data") == 0))
{
break;
}
}
items.Add(new ResXItem(name, value, comment));
}
}
return(items);
}
public static void ReadXML(XmlParserContext context, string xmlFrag, WhitespaceHandling ws)
{
//Create the reader and specify the WhitespaceHandling setting.
XmlTextReader reader = new XmlTextReader(xmlFrag, XmlNodeType.Element, context);
reader.WhitespaceHandling = ws;
//Parse the XML and display each of the nodes.
while (reader.Read())
{
switch (reader.NodeType)
{
case XmlNodeType.Element:
Console.WriteLine("{0}: <{1}>", reader.NodeType, reader.Name);
break;
case XmlNodeType.Text:
Console.WriteLine("{0}: {1}", reader.NodeType, reader.Value);
break;
case XmlNodeType.EndElement:
Console.WriteLine("{0}: </{1}>", reader.NodeType, reader.Name);
break;
case XmlNodeType.Whitespace:
Console.WriteLine("{0}:", reader.NodeType);
break;
case XmlNodeType.SignificantWhitespace:
Console.WriteLine("{0}:", reader.NodeType);
break;
}
}
//Close the reader.
reader.Close();
}
// Initializes a new instance of the XmlTextReaderImpl class with the specified XmlNameTable.
// This constructor is used when creating XmlTextReaderImpl for V1 XmlTextReader
internal XmlTextReaderImpl(XmlNameTable nt)
{
Debug.Assert(nt != null);
_v1Compat = true;
_outerReader = this;
_nameTable = nt;
nt.Add(string.Empty);
if (!System.Xml.XmlReaderSettings.EnableLegacyXmlSettings())
{
_xmlResolver = null;
}
else
{
_xmlResolver = new XmlUrlResolver();
}
_xml = nt.Add("xml");
_xmlNs = nt.Add("xmlns");
Debug.Assert(_index == 0);
_nodes = new NodeData[NodesInitialSize];
_nodes[0] = new NodeData();
_curNode = _nodes[0];
_stringBuilder = new StringBuilder();
_xmlContext = new XmlContext();
_parsingFunction = ParsingFunction.SwitchToInteractiveXmlDecl;
_nextParsingFunction = ParsingFunction.DocumentContent;
_entityHandling = EntityHandling.ExpandCharEntities;
_whitespaceHandling = WhitespaceHandling.All;
_closeInput = true;
_maxCharactersInDocument = 0;
// Breaking change: entity expansion is enabled, but limit it to 10,000,000 chars (like XLinq)
_maxCharactersFromEntities = (long)1e7;
_charactersInDocument = 0;
_charactersFromEntities = 0;
_ps.lineNo = 1;
_ps.lineStartPos = -1;
}
// Initializes a new instance of the XmlTextReaderImpl class with the specified XmlNameTable.
// This constructor is used when creating XmlTextReaderImpl for V1 XmlTextReader
internal XmlTextReaderImpl( XmlNameTable nt ) {
Debug.Assert( nt != null );
v1Compat = true;
outerReader = this;
nameTable = nt;
nt.Add( string.Empty );
xmlResolver = new XmlUrlResolver();
Xml = nt.Add( "xml" );
XmlNs = nt.Add( "xmlns" );
Debug.Assert( index == 0 );
nodes = new NodeData[ NodesInitialSize ];
nodes[0] = new NodeData();
curNode = nodes[0];
stringBuilder = new BufferBuilder();
xmlContext = new XmlContext();
parsingFunction = ParsingFunction.SwitchToInteractiveXmlDecl;
nextParsingFunction = ParsingFunction.DocumentContent;
entityHandling = EntityHandling.ExpandCharEntities;
whitespaceHandling = WhitespaceHandling.All;
closeInput = true;
ps.lineNo = 1;
ps.lineStartPos = -1;
}
internal XmlReader AddConformanceWrapper(XmlReader baseReader)
{
XmlReaderSettings baseReaderSettings = baseReader.Settings;
bool checkChars = false;
bool noWhitespace = false;
bool noComments = false;
bool noPIs = false;
DtdProcessing dtdProc = (DtdProcessing)(-1);
bool needWrap = false;
if (baseReaderSettings == null)
{
#pragma warning disable 618
if (_conformanceLevel != ConformanceLevel.Auto && _conformanceLevel != XmlReader.GetV1ConformanceLevel(baseReader))
{
throw new InvalidOperationException(SR.Format(SR.Xml_IncompatibleConformanceLevel, _conformanceLevel.ToString()));
}
// get the V1 XmlTextReader ref
XmlTextReader v1XmlTextReader = baseReader as XmlTextReader;
if (v1XmlTextReader == null)
{
XmlValidatingReader vr = baseReader as XmlValidatingReader;
if (vr != null)
{
v1XmlTextReader = (XmlTextReader)vr.Reader;
}
}
// assume the V1 readers already do all conformance checking;
// wrap only if IgnoreWhitespace, IgnoreComments, IgnoreProcessingInstructions or ProhibitDtd is true;
if (_ignoreWhitespace)
{
WhitespaceHandling wh = WhitespaceHandling.All;
// special-case our V1 readers to see if whey already filter whitespaces
if (v1XmlTextReader != null)
{
wh = v1XmlTextReader.WhitespaceHandling;
}
if (wh == WhitespaceHandling.All)
{
noWhitespace = true;
needWrap = true;
}
}
if (_ignoreComments)
{
noComments = true;
needWrap = true;
}
if (_ignorePIs)
{
noPIs = true;
needWrap = true;
}
// DTD processing
DtdProcessing baseDtdProcessing = DtdProcessing.Parse;
if (v1XmlTextReader != null)
{
baseDtdProcessing = v1XmlTextReader.DtdProcessing;
}
if ((_dtdProcessing == DtdProcessing.Prohibit && baseDtdProcessing != DtdProcessing.Prohibit) ||
(_dtdProcessing == DtdProcessing.Ignore && baseDtdProcessing == DtdProcessing.Parse))
{
dtdProc = _dtdProcessing;
needWrap = true;
}
#pragma warning restore 618
}
else
{
if (_conformanceLevel != baseReaderSettings.ConformanceLevel && _conformanceLevel != ConformanceLevel.Auto)
{
throw new InvalidOperationException(SR.Format(SR.Xml_IncompatibleConformanceLevel, _conformanceLevel.ToString()));
}
if (_checkCharacters && !baseReaderSettings.CheckCharacters)
{
checkChars = true;
needWrap = true;
}
if (_ignoreWhitespace && !baseReaderSettings.IgnoreWhitespace)
{
noWhitespace = true;
needWrap = true;
}
if (_ignoreComments && !baseReaderSettings.IgnoreComments)
{
noComments = true;
needWrap = true;
}
if (_ignorePIs && !baseReaderSettings.IgnoreProcessingInstructions)
{
noPIs = true;
needWrap = true;
}
if ((_dtdProcessing == DtdProcessing.Prohibit && baseReaderSettings.DtdProcessing != DtdProcessing.Prohibit) ||
(_dtdProcessing == DtdProcessing.Ignore && baseReaderSettings.DtdProcessing == DtdProcessing.Parse))
{
dtdProc = _dtdProcessing;
needWrap = true;
}
}
if (needWrap)
{
IXmlNamespaceResolver readerAsNSResolver = baseReader as IXmlNamespaceResolver;
if (readerAsNSResolver != null)
{
return(new XmlCharCheckingReaderWithNS(baseReader, readerAsNSResolver, checkChars, noWhitespace, noComments, noPIs, dtdProc));
}
else
{
return(new XmlCharCheckingReader(baseReader, checkChars, noWhitespace, noComments, noPIs, dtdProc));
}
}
else
{
return(baseReader);
}
}
private void ParseDataNode(XmlTextReader reader, bool isMetaData)
{
DataNodeInfo nodeInfo = new DataNodeInfo
{
Name = reader[ResXResourceWriter.NameStr]
};
string typeName = reader[ResXResourceWriter.TypeStr];
string alias = null;
AssemblyName assemblyName = null;
if (!string.IsNullOrEmpty(typeName))
{
alias = GetAliasFromTypeName(typeName);
}
if (!string.IsNullOrEmpty(alias))
{
assemblyName = _aliasResolver.ResolveAlias(alias);
}
if (assemblyName != null)
{
nodeInfo.TypeName = GetTypeFromTypeName(typeName) + ", " + assemblyName.FullName;
}
else
{
nodeInfo.TypeName = reader[ResXResourceWriter.TypeStr];
}
nodeInfo.MimeType = reader[ResXResourceWriter.MimeTypeStr];
bool finishedReadingDataNode = false;
nodeInfo.ReaderPosition = GetPosition(reader);
while (!finishedReadingDataNode && reader.Read())
{
if (reader.NodeType == XmlNodeType.EndElement && (reader.LocalName.Equals(ResXResourceWriter.DataStr) || reader.LocalName.Equals(ResXResourceWriter.MetadataStr)))
{
// we just found </data>, quit or </metadata>
finishedReadingDataNode = true;
}
else
{
// could be a <value> or a <comment>
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name.Equals(ResXResourceWriter.ValueStr))
{
WhitespaceHandling oldValue = reader.WhitespaceHandling;
try
{
// based on the documentation at http://msdn.microsoft.com/library/default.asp?url=/library/en-us/cpref/html/frlrfsystemxmlxmltextreaderclasswhitespacehandlingtopic.asp
// this is ok because:
// "Because the XmlTextReader does not have DTD information available to it,
// SignificantWhitepsace nodes are only returned within the an xml:space='preserve' scope."
// the xml:space would not be present for anything else than string and char (see ResXResourceWriter)
// so this would not cause any breaking change while reading data from Everett (we never outputed
// xml:space then) or from whidbey that is not specifically either a string or a char.
// However please note that manually editing a resx file in Everett and in Whidbey because of the addition
// of xml:space=preserve might have different consequences...
reader.WhitespaceHandling = WhitespaceHandling.Significant;
nodeInfo.ValueData = reader.ReadString();
}
finally
{
reader.WhitespaceHandling = oldValue;
}
}
else if (reader.Name.Equals(ResXResourceWriter.CommentStr))
{
nodeInfo.Comment = reader.ReadString();
}
}
else
{
// weird, no <xxxx> tag, just the inside of <data> as text
nodeInfo.ValueData = reader.Value.Trim();
}
}
}
if (nodeInfo.Name == null)
{
throw new ArgumentException(string.Format(SR.InvalidResXResourceNoName, nodeInfo.ValueData));
}
ResXDataNode dataNode = new ResXDataNode(nodeInfo, BasePath);
if (UseResXDataNodes)
{
_resData[nodeInfo.Name] = dataNode;
}
else
{
IDictionary data = (isMetaData ? _resMetadata : _resData);
if (_assemblyNames == null)
{
data[nodeInfo.Name] = dataNode.GetValue(_typeResolver);
}
else
{
data[nodeInfo.Name] = dataNode.GetValue(_assemblyNames);
}
}
}
//
// Public Methods and Properties
//
public virtual bool Load(XmlReader rXmlReader)
{
//Hook up your reader as my reader
_rXmlReader = rXmlReader;
if (rXmlReader is XmlTextReader)
{
_eWhitespaceMode = ((XmlTextReader)rXmlReader).WhitespaceHandling;
_fNamespaces = ((XmlTextReader)rXmlReader).Namespaces;
_eValidationMode = ValidationType.None;
}
#pragma warning disable 0618
if (rXmlReader is XmlValidatingReader)
{
if (((XmlValidatingReader)rXmlReader).Reader is XmlTextReader)
{
_eWhitespaceMode = ((XmlTextReader)((XmlValidatingReader)rXmlReader).Reader).WhitespaceHandling;
}
else
{
_eWhitespaceMode = WhitespaceHandling.None;
}
_fNamespaces = ((XmlValidatingReader)rXmlReader).Namespaces;
_eValidationMode = ((XmlValidatingReader)rXmlReader).ValidationType;
_eEntityMode = ((XmlValidatingReader)rXmlReader).EntityHandling;
}
#pragma warning restore 0618
DebugTrace("Setting ValidationMode=" + _eValidationMode.ToString());
DebugTrace("Setting EntityMode=" + _eEntityMode.ToString());
DebugTrace("Setting WhitespaceMode=" + _eWhitespaceMode.ToString());
//Process the Document
try
{
_rDocumentRootNode = new CXmlNode("", "", XmlNodeType.Element);
_rDocumentRootNode._eFlags = NodeFlags.DocumentRoot | NodeFlags.Indent;
Process(_rDocumentRootNode);
for (_rRootNode = _rDocumentRootNode.FirstChild; _rRootNode != null && _rRootNode.NodeType != XmlNodeType.Element; _rRootNode = _rRootNode.NextNode)
{
;
}
}
catch (Exception e)
{
//Unhook your reader
_rXmlReader = null;
_strParseError = e.ToString();
if (_fThrow)
{
throw (e);
}
if (_hr == 0)
{
_hr = -1;
}
return(false);
}
//Unhook your reader
_rXmlReader = null;
return(true);
}
public static StringCollection GetXMLTextLines(XmlReader Reader, WhitespaceHandling eWS)
{
StringCollection Coll = new StringCollection();
StringBuilder B = new StringBuilder();
bool bTrimWSInSplit = eWS != WhitespaceHandling.All;
//Read each node in the tree.
string strIndent = "";
int iCurrentDepth = 0;
while (Reader.Read())
{
int iDepth = Reader.Depth;
if (iDepth != iCurrentDepth)
{
strIndent = GetIndentString(iDepth);
iCurrentDepth = iDepth;
}
switch (Reader.NodeType)
{
case XmlNodeType.Attribute: //This should never be returned by XmlReader
Coll.Add(String.Format("{2}{0}={3}{1}{3}", Reader.Name, Reader.Value, strIndent, Reader.QuoteChar));
break;
case XmlNodeType.Comment:
SplitAndAddXMLLines(Coll, String.Format("<!-- {0} -->", Reader.Value), strIndent, bTrimWSInSplit);
break;
case XmlNodeType.Element:
B.Length = 0;
B.AppendFormat("{1}<{0}", Reader.Name, strIndent);
//We have to check for this before we move to the attributes.
bool bIsEmptyElement = Reader.IsEmptyElement;
while (Reader.MoveToNextAttribute())
{
B.AppendFormat(" {0}={2}{1}{2}", Reader.Name, Reader.Value, Reader.QuoteChar);
}
if (bIsEmptyElement)
B.Append("/>");
else
B.Append(">");
Coll.Add(B.ToString());
break;
case XmlNodeType.EndElement:
Coll.Add(String.Format("{1}</{0}>", Reader.Name, strIndent));
break;
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.XmlDeclaration:
Coll.Add(String.Format("{2}<?{0} {1}?>", Reader.Name, Reader.Value, strIndent));
break;
case XmlNodeType.SignificantWhitespace:
if (eWS != WhitespaceHandling.None)
{
Coll.Add(String.Format("{1}{0}", Reader.Value, strIndent));
}
break;
case XmlNodeType.Whitespace:
if (eWS == WhitespaceHandling.All)
{
Coll.Add(String.Format("{1}{0}", Reader.Value, strIndent));
}
break;
case XmlNodeType.CDATA:
Coll.Add(String.Format("{1}<![CDATA[{0}]]>", Reader.Value, strIndent));
break;
case XmlNodeType.Document:
case XmlNodeType.DocumentFragment:
Coll.Add(String.Format("{1}{0}", Reader.Value, strIndent));
break;
case XmlNodeType.DocumentType:
Coll.Add(String.Format("{1}<!DOCTYPE {0} [", Reader.Name, strIndent));
SplitAndAddXMLLines(Coll, Reader.Value, GetIndentString(iDepth + 1), bTrimWSInSplit);
Coll.Add(String.Format("{0}]>", strIndent));
break;
case XmlNodeType.Entity:
Coll.Add(String.Format("{2}<!ENTITY {0} [{1}]", Reader.Name, Reader.Value, strIndent));
SplitAndAddXMLLines(Coll, Reader.Value, GetIndentString(iDepth + 1), bTrimWSInSplit);
Coll.Add(String.Format("{0}]>", strIndent));
break;
case XmlNodeType.EntityReference:
Coll.Add(String.Format("{1}&{0}", Reader.Value, strIndent));
break;
case XmlNodeType.Notation:
Coll.Add(String.Format("{2}<!NOTATION {0} [{1}]>", Reader.Name, Reader.Value, strIndent));
break;
case XmlNodeType.EndEntity:
case XmlNodeType.None:
case XmlNodeType.Text:
SplitAndAddXMLLines(Coll, Reader.Value, strIndent, bTrimWSInSplit);
break;
}
}
return Coll;
}
private void ParseDataNode(XmlTextReader reader, bool isMetaData)
{
DataNodeInfo nodeInfo = new DataNodeInfo {
Name = reader["name"]
};
string str = reader["type"];
string aliasFromTypeName = null;
AssemblyName name = null;
if (!string.IsNullOrEmpty(str))
{
aliasFromTypeName = this.GetAliasFromTypeName(str);
}
if (!string.IsNullOrEmpty(aliasFromTypeName))
{
name = this.aliasResolver.ResolveAlias(aliasFromTypeName);
}
if (name != null)
{
nodeInfo.TypeName = this.GetTypeFromTypeName(str) + ", " + name.FullName;
}
else
{
nodeInfo.TypeName = reader["type"];
}
nodeInfo.MimeType = reader["mimetype"];
bool flag = false;
nodeInfo.ReaderPosition = this.GetPosition(reader);
while (!flag && reader.Read())
{
if ((reader.NodeType == XmlNodeType.EndElement) && (reader.LocalName.Equals("data") || reader.LocalName.Equals("metadata")))
{
flag = true;
}
else
{
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.Name.Equals("value"))
{
WhitespaceHandling whitespaceHandling = reader.WhitespaceHandling;
try
{
reader.WhitespaceHandling = WhitespaceHandling.Significant;
nodeInfo.ValueData = reader.ReadString();
continue;
}
finally
{
reader.WhitespaceHandling = whitespaceHandling;
}
}
if (reader.Name.Equals("comment"))
{
nodeInfo.Comment = reader.ReadString();
}
continue;
}
nodeInfo.ValueData = reader.Value.Trim();
}
}
if (nodeInfo.Name == null)
{
throw new ArgumentException(System.Windows.Forms.SR.GetString("InvalidResXResourceNoName", new object[] { nodeInfo.ValueData }));
}
ResXDataNode node = new ResXDataNode(nodeInfo, this.BasePath);
if (this.UseResXDataNodes)
{
this.resData[nodeInfo.Name] = node;
}
else
{
IDictionary dictionary = isMetaData ? this.resMetadata : this.resData;
if (this.assemblyNames == null)
{
dictionary[nodeInfo.Name] = node.GetValue(this.typeResolver);
}
else
{
dictionary[nodeInfo.Name] = node.GetValue(this.assemblyNames);
}
}
}
/// <summary>
/// Creates new instance of <c>XIncludingReader</c> class with
/// specified underlying <c>XmlReader</c> reader.
/// </summary>
/// <param name="reader">Underlying reader to read from</param>
public XIncludingReader(XmlReader reader)
{
XmlTextReader xtr = reader as XmlTextReader;
if (xtr != null)
{
XmlValidatingReader vr = new XmlValidatingReader(reader);
vr.ValidationType = ValidationType.None;
vr.EntityHandling = EntityHandling.ExpandEntities;
vr.ValidationEventHandler += new ValidationEventHandler(
ValidationCallback);
_normalization = xtr.Normalization;
_whiteSpaceHandling = xtr.WhitespaceHandling;
_reader = vr;
}
else
{
_reader = reader;
}
_nameTable = reader.NameTable;
_keywords = new XIncludeKeywords(NameTable);
if (_reader.BaseURI != "")
_topBaseUri = new Uri(_reader.BaseURI);
else
{
_relativeBaseUri = false;
_topBaseUri = new Uri(Assembly.GetExecutingAssembly().Location);
}
_readers = new Stack<XmlReader>();
_state = XIncludingReaderState.Default;
}
// protected constructor, users should not be using this
/// <include file='doc\XmlTextReader.uex' path='docs/doc[@for="XmlTextReader.XmlTextReader1"]/*' />
/// <internalonly/>
/// <devdoc>
/// <para>Initializes a new instance of the XmlTextReader class with the specified XmlNameTable.</para>
/// </devdoc>
protected XmlTextReader( XmlNameTable nt ) {
//
// internal variables
//
_ElementDepth = -1;
_EntityDepthOffset = 0;
_ReadCount = -1;
//
// variables for properties
//
_ReadState = ReadState.Initial;
_NextState = 1;
//
// create interal components
//
_NameTable = nt;
_ElementStack = new HWStack(STACK_INCREMENT);
_ScannerStack = new HWStack(STACK_INCREMENT);
//
//create atom
//
_StringName = _NameTable.Add("String");
_MicrosoftSystemNamespace = _NameTable.Add("System");
_Decimal = _NameTable.Add("#decimal");
_Hex = _NameTable.Add("#hexidecimal");
_Amp = _NameTable.Add("amp");
_Lt = _NameTable.Add("lt");
_Gt = _NameTable.Add("gt");
_Quot = _NameTable.Add("quot");
_Apos = _NameTable.Add("apos");
_XmlNs = _NameTable.Add("xmlns");
_XmlSpaceAtom = _NameTable.Add("xml:space");
_XmlLangAtom = _NameTable.Add("xml:lang");
//
//fields collection
//
_Used = -1;
_MarkScannerCount = 10000;
//
_XmlSpace = XmlSpace.None;
_XmlLang = String.Empty;
_WhitespaceHandling = WhitespaceHandling.All;
_XmlResolver = new XmlUrlResolver();
_CheckNamespaces = true;
_TmpToken = new XmlNSElementTokenInfo(_Scanner, _NsMgr, XmlNodeType.None, String.Empty,-1, -1, -1, 0,false);
_CurrentToken = _TmpToken;
// PERF: these node types are not common therefore they
// will only be constructed when used
//
_CommentToken = null;
_CDATAToken = null;
_DocTypeToken = null;
_PIToken = null;
_EndEntityToken = null;
_NextFunction = _InitReader;
_StringBuilder = new StringBuilder(100);
}
// This constructor is used when creating XmlTextReaderImpl reader via "XmlReader.Create(..)"
private XmlTextReaderImpl( XmlResolver resolver, XmlReaderSettings settings, XmlParserContext context ) {
v1Compat = false;
outerReader = this;
xmlContext = new XmlContext();
// create or get nametable and namespace manager from XmlParserContext
XmlNameTable nt = settings.NameTable;
if ( context == null ) {
if ( nt == null ) {
nt = new NameTable();
Debug.Assert( nameTableFromSettings == false );
}
else {
nameTableFromSettings = true;
}
nameTable = nt;
namespaceManager = new XmlNamespaceManager( nt );
}
else {
SetupFromParserContext( context, settings );
nt = nameTable;
}
nt.Add( string.Empty );
Xml = nt.Add( "xml" );
XmlNs = nt.Add( "xmlns" );
xmlResolver = resolver;
Debug.Assert( index == 0 );
nodes = new NodeData[ NodesInitialSize ];
nodes[0] = new NodeData();
curNode = nodes[0];
stringBuilder = new BufferBuilder();
entityHandling = EntityHandling.ExpandEntities;
whitespaceHandling = ( settings.IgnoreWhitespace ) ? WhitespaceHandling.Significant : WhitespaceHandling.All;
normalize = true;
ignorePIs = settings.IgnoreProcessingInstructions;
ignoreComments = settings.IgnoreComments;
checkCharacters = settings.CheckCharacters;
lineNumberOffset = settings.LineNumberOffset;
linePositionOffset = settings.LinePositionOffset;
ps.lineNo = lineNumberOffset + 1;
ps.lineStartPos = - linePositionOffset - 1;
curNode.SetLineInfo( ps.LineNo - 1, ps.LinePos - 1 );
prohibitDtd = settings.ProhibitDtd;
fragmentParserContext = context;
parsingFunction = ParsingFunction.SwitchToInteractiveXmlDecl;
nextParsingFunction = ParsingFunction.DocumentContent;
switch ( settings.ConformanceLevel ) {
case ConformanceLevel.Auto:
fragmentType = XmlNodeType.None;
fragment = true;
break;
case ConformanceLevel.Fragment:
fragmentType = XmlNodeType.Element;
fragment = true;
break;
case ConformanceLevel.Document:
fragmentType = XmlNodeType.Document;
break;
default:
Debug.Assert( false );
goto case ConformanceLevel.Document;
}
}
// This constructor is used when creating XmlTextReaderImpl reader via "XmlReader.Create(..)"
private XmlTextReaderImpl(XmlResolver resolver, XmlReaderSettings settings, XmlParserContext context)
{
_useAsync = settings.Async;
_v1Compat = false;
_outerReader = this;
_xmlContext = new XmlContext();
// create or get nametable and namespace manager from XmlParserContext
XmlNameTable nt = settings.NameTable;
if (context == null)
{
if (nt == null)
{
nt = new NameTable();
Debug.Assert(_nameTableFromSettings == false);
}
else
{
_nameTableFromSettings = true;
}
_nameTable = nt;
_namespaceManager = new XmlNamespaceManager(nt);
}
else
{
SetupFromParserContext(context, settings);
nt = _nameTable;
}
nt.Add(string.Empty);
_xml = nt.Add("xml");
_xmlNs = nt.Add("xmlns");
_xmlResolver = resolver;
Debug.Assert(_index == 0);
_nodes = new NodeData[NodesInitialSize];
_nodes[0] = new NodeData();
_curNode = _nodes[0];
_stringBuilder = new StringBuilder();
// Needed only for XmlTextReader (reporting of entities)
_entityHandling = EntityHandling.ExpandEntities;
_xmlResolverIsSet = settings.IsXmlResolverSet;
_whitespaceHandling = (settings.IgnoreWhitespace) ? WhitespaceHandling.Significant : WhitespaceHandling.All;
_normalize = true;
_ignorePIs = settings.IgnoreProcessingInstructions;
_ignoreComments = settings.IgnoreComments;
_checkCharacters = settings.CheckCharacters;
_lineNumberOffset = settings.LineNumberOffset;
_linePositionOffset = settings.LinePositionOffset;
_ps.lineNo = _lineNumberOffset + 1;
_ps.lineStartPos = -_linePositionOffset - 1;
_curNode.SetLineInfo(_ps.LineNo - 1, _ps.LinePos - 1);
_dtdProcessing = settings.DtdProcessing;
_maxCharactersInDocument = settings.MaxCharactersInDocument;
_maxCharactersFromEntities = settings.MaxCharactersFromEntities;
_charactersInDocument = 0;
_charactersFromEntities = 0;
_fragmentParserContext = context;
_parsingFunction = ParsingFunction.SwitchToInteractiveXmlDecl;
_nextParsingFunction = ParsingFunction.DocumentContent;
switch (settings.ConformanceLevel)
{
case ConformanceLevel.Auto:
_fragmentType = XmlNodeType.None;
_fragment = true;
break;
case ConformanceLevel.Fragment:
_fragmentType = XmlNodeType.Element;
_fragment = true;
break;
case ConformanceLevel.Document:
_fragmentType = XmlNodeType.Document;
break;
default:
Debug.Assert(false);
goto case ConformanceLevel.Document;
}
}
public static StringCollection GetXMLTextLines(string strFileName, WhitespaceHandling eWS)
{
using (XmlTextReader Reader = new XmlTextReader(strFileName))
{
Reader.WhitespaceHandling = eWS;
StringCollection Coll = GetXMLTextLines(Reader, eWS);
return Coll;
}
}
// Conversion of an XML-structure (in a string or in a file) to a Prolog BaseTerm
public static BaseTerm XmlToTerm(BaseTerm settings, string s, bool inFile)
{
XmlTextReader xrd = null;
StreamReader sr = null;
Encoding encoding = GetEncodingFromString("UTF-8");
WhitespaceHandling whitespace = WhitespaceHandling.None;
bool normalization = false;
bool comment = true;
Node result;
string settingValue = null;
if (settings != null)
{
foreach (BaseTerm setting in (ListTerm)settings) // traverse ...
{
string settingName = setting.FunctorToString;
if (setting.Arity == 1)
{
settingValue = setting.Arg(0).FunctorToString;
}
else
{
IO.Error("xml_term/3: Unknown setting '{0}'", setting);
}
switch (settingName)
{
// Expected string or file encoding. Superseded by explicit encoding attribute setting found in xml
case "comment":
switch (settingValue)
{
case "on":
case "true":
comment = true;
break;
case "off":
case "false":
comment = false;
break;
default:
IO.Error("xml_term/3: Unknown 'comment' value setting '{0}'", settingValue);
break;
}
break;
case "encoding":
encoding = GetEncodingFromString(settingValue); // default is UTF-8
break;
case "whitespace": // whitespace handling
switch (settingValue)
{
case "all":
whitespace = WhitespaceHandling.All;
break;
case "significant":
whitespace = WhitespaceHandling.Significant;
break;
case "none":
whitespace = WhitespaceHandling.None;
break;
default:
IO.Error("xml_term/3: Unknown 'whitespace' value setting '{0}'", settingValue);
break;
}
break;
case "normalisation":
switch (settingValue)
{
case "false":
normalization = false;
break;
case "true":
normalization = true;
break;
default:
IO.Error("xml_term/3: Unknown 'normalization' value setting '{0}'", settingValue);
break;
}
break;
default:
IO.Error("Unknown setting in xml_term/3: '{0}'", setting);
break;
}
}
}
try
{
if (inFile)
{
sr = new StreamReader(s, encoding);
xrd = new XmlTextReader(sr);
}
else
{
xrd = new XmlTextReader(new StringReader(s));
}
//xrd.ProhibitDtd = true;
xrd.Namespaces = false;
xrd.Normalization = normalization;
xrd.WhitespaceHandling = whitespace;
result = new Node();
result.TagName = "<root>";
result.type = XmlNodeType.Element;
result.ToNode(xrd, 0, comment); // first, create an intermediate representation (a Node) containing the XML structure
}
catch (Exception e)
{
string source = inFile ? string.Format(" file '{0}'", s) : null;
throw new ApplicationException(
string.Format("Error in XML input{0}. Message was:\r\n{1}", source, e.Message));
}
finally
{
if (sr != null)
{
sr.Close();
}
if (xrd != null)
{
xrd.Close();
}
}
return(result.ToTerm()); // Convert the Node to a Prolog BaseTerm
}
public static StringCollection GetXMLTextLinesFromXML(string strXML, WhitespaceHandling eWS)
{
using (StringReader SR = new StringReader(strXML))
using (XmlTextReader XR = new XmlTextReader(SR))
{
StringCollection Coll = Functions.GetXMLTextLines(XR, eWS);
return Coll;
}
}
public static StringCollection GetXMLTextLines(XmlReader Reader, WhitespaceHandling eWS)
{
StringCollection Coll = new StringCollection();
StringBuilder B = new StringBuilder();
bool bTrimWSInSplit = eWS != WhitespaceHandling.All;
//Read each node in the tree.
string strIndent = "";
int iCurrentDepth = 0;
while (Reader.Read())
{
int iDepth = Reader.Depth;
if (iDepth != iCurrentDepth)
{
strIndent = GetIndentString(iDepth);
iCurrentDepth = iDepth;
}
switch (Reader.NodeType)
{
case XmlNodeType.Attribute: //This should never be returned by XmlReader
Coll.Add(String.Format("{2}{0}={3}{1}{3}", Reader.Name, Reader.Value, strIndent, Reader.QuoteChar));
break;
case XmlNodeType.Comment:
SplitAndAddXMLLines(Coll, String.Format("<!-- {0} -->", Reader.Value), strIndent, bTrimWSInSplit);
break;
case XmlNodeType.Element:
B.Length = 0;
B.AppendFormat("{1}<{0}", Reader.Name, strIndent);
//We have to check for this before we move to the attributes.
bool bIsEmptyElement = Reader.IsEmptyElement;
while (Reader.MoveToNextAttribute())
{
B.AppendFormat(" {0}={2}{1}{2}", Reader.Name, Reader.Value, Reader.QuoteChar);
}
if (bIsEmptyElement)
{
B.Append("/>");
}
else
{
B.Append(">");
}
Coll.Add(B.ToString());
break;
case XmlNodeType.EndElement:
Coll.Add(String.Format("{1}</{0}>", Reader.Name, strIndent));
break;
case XmlNodeType.ProcessingInstruction:
case XmlNodeType.XmlDeclaration:
Coll.Add(String.Format("{2}<?{0} {1}?>", Reader.Name, Reader.Value, strIndent));
break;
case XmlNodeType.SignificantWhitespace:
if (eWS != WhitespaceHandling.None)
{
Coll.Add(String.Format("{1}{0}", Reader.Value, strIndent));
}
break;
case XmlNodeType.Whitespace:
if (eWS == WhitespaceHandling.All)
{
Coll.Add(String.Format("{1}{0}", Reader.Value, strIndent));
}
break;
case XmlNodeType.CDATA:
Coll.Add(String.Format("{1}<![CDATA[{0}]]>", Reader.Value, strIndent));
break;
case XmlNodeType.Document:
case XmlNodeType.DocumentFragment:
Coll.Add(String.Format("{1}{0}", Reader.Value, strIndent));
break;
case XmlNodeType.DocumentType:
Coll.Add(String.Format("{1}<!DOCTYPE {0} [", Reader.Name, strIndent));
SplitAndAddXMLLines(Coll, Reader.Value, GetIndentString(iDepth + 1), bTrimWSInSplit);
Coll.Add(String.Format("{0}]>", strIndent));
break;
case XmlNodeType.Entity:
Coll.Add(String.Format("{2}<!ENTITY {0} [{1}]", Reader.Name, Reader.Value, strIndent));
SplitAndAddXMLLines(Coll, Reader.Value, GetIndentString(iDepth + 1), bTrimWSInSplit);
Coll.Add(String.Format("{0}]>", strIndent));
break;
case XmlNodeType.EntityReference:
Coll.Add(String.Format("{1}&{0}", Reader.Value, strIndent));
break;
case XmlNodeType.Notation:
Coll.Add(String.Format("{2}<!NOTATION {0} [{1}]>", Reader.Name, Reader.Value, strIndent));
break;
case XmlNodeType.EndEntity:
case XmlNodeType.None:
case XmlNodeType.Text:
SplitAndAddXMLLines(Coll, Reader.Value, strIndent, bTrimWSInSplit);
break;
}
}
return(Coll);
}
internal XmlReader AddConformanceWrapper(XmlReader baseReader)
{
XmlReaderSettings settings = baseReader.Settings;
bool checkCharacters = false;
bool ignoreWhitespace = false;
bool ignoreComments = false;
bool ignorePis = false;
System.Xml.DtdProcessing dtdProcessing = ~System.Xml.DtdProcessing.Prohibit;
bool flag5 = false;
if (settings == null)
{
if ((this.conformanceLevel != System.Xml.ConformanceLevel.Auto) && (this.conformanceLevel != XmlReader.GetV1ConformanceLevel(baseReader)))
{
throw new InvalidOperationException(Res.GetString("Xml_IncompatibleConformanceLevel", new object[] { this.conformanceLevel.ToString() }));
}
XmlTextReader reader = baseReader as XmlTextReader;
if (reader == null)
{
XmlValidatingReader reader2 = baseReader as XmlValidatingReader;
if (reader2 != null)
{
reader = (XmlTextReader)reader2.Reader;
}
}
if (this.ignoreWhitespace)
{
WhitespaceHandling all = WhitespaceHandling.All;
if (reader != null)
{
all = reader.WhitespaceHandling;
}
if (all == WhitespaceHandling.All)
{
ignoreWhitespace = true;
flag5 = true;
}
}
if (this.ignoreComments)
{
ignoreComments = true;
flag5 = true;
}
if (this.ignorePIs)
{
ignorePis = true;
flag5 = true;
}
System.Xml.DtdProcessing parse = System.Xml.DtdProcessing.Parse;
if (reader != null)
{
parse = reader.DtdProcessing;
}
if (((this.dtdProcessing == System.Xml.DtdProcessing.Prohibit) && (parse != System.Xml.DtdProcessing.Prohibit)) || ((this.dtdProcessing == System.Xml.DtdProcessing.Ignore) && (parse == System.Xml.DtdProcessing.Parse)))
{
dtdProcessing = this.dtdProcessing;
flag5 = true;
}
}
else
{
if ((this.conformanceLevel != settings.ConformanceLevel) && (this.conformanceLevel != System.Xml.ConformanceLevel.Auto))
{
throw new InvalidOperationException(Res.GetString("Xml_IncompatibleConformanceLevel", new object[] { this.conformanceLevel.ToString() }));
}
if (this.checkCharacters && !settings.CheckCharacters)
{
checkCharacters = true;
flag5 = true;
}
if (this.ignoreWhitespace && !settings.IgnoreWhitespace)
{
ignoreWhitespace = true;
flag5 = true;
}
if (this.ignoreComments && !settings.IgnoreComments)
{
ignoreComments = true;
flag5 = true;
}
if (this.ignorePIs && !settings.IgnoreProcessingInstructions)
{
ignorePis = true;
flag5 = true;
}
if (((this.dtdProcessing == System.Xml.DtdProcessing.Prohibit) && (settings.DtdProcessing != System.Xml.DtdProcessing.Prohibit)) || ((this.dtdProcessing == System.Xml.DtdProcessing.Ignore) && (settings.DtdProcessing == System.Xml.DtdProcessing.Parse)))
{
dtdProcessing = this.dtdProcessing;
flag5 = true;
}
}
if (!flag5)
{
return(baseReader);
}
IXmlNamespaceResolver readerAsNSResolver = baseReader as IXmlNamespaceResolver;
if (readerAsNSResolver != null)
{
return(new XmlCharCheckingReaderWithNS(baseReader, readerAsNSResolver, checkCharacters, ignoreWhitespace, ignoreComments, ignorePis, dtdProcessing));
}
return(new XmlCharCheckingReader(baseReader, checkCharacters, ignoreWhitespace, ignoreComments, ignorePis, dtdProcessing));
}
internal XmlReader AddConformanceWrapper(XmlReader baseReader)
{
XmlReaderSettings baseReaderSettings = baseReader.Settings;
bool checkChars = false;
bool noWhitespace = false;
bool noComments = false;
bool noPIs = false;
DtdProcessing dtdProc = (DtdProcessing)(-1);
bool needWrap = false;
if (baseReaderSettings == null)
{
#pragma warning disable 618
#if SILVERLIGHT
// Starting from Windows phone 8.1 (TargetsAtLeast_Desktop_V4_5_1) we converge with the desktop behavior so we'll let the reader
// not throw exception if has different conformance level than Auto.
if (BinaryCompatibility.TargetsAtLeast_Desktop_V4_5_1)
{
if (this.conformanceLevel != ConformanceLevel.Auto && this.conformanceLevel != XmlReader.GetV1ConformanceLevel(baseReader))
{
throw new InvalidOperationException(Res.GetString(Res.Xml_IncompatibleConformanceLevel, this.conformanceLevel.ToString()));
}
}
else if (this.conformanceLevel != ConformanceLevel.Auto)
{
throw new InvalidOperationException(Res.GetString(Res.Xml_IncompatibleConformanceLevel, this.conformanceLevel.ToString()));
}
#else
if (this.conformanceLevel != ConformanceLevel.Auto && this.conformanceLevel != XmlReader.GetV1ConformanceLevel(baseReader))
{
throw new InvalidOperationException(Res.GetString(Res.Xml_IncompatibleConformanceLevel, this.conformanceLevel.ToString()));
}
#endif
#if !SILVERLIGHT
// get the V1 XmlTextReader ref
XmlTextReader v1XmlTextReader = baseReader as XmlTextReader;
if (v1XmlTextReader == null)
{
XmlValidatingReader vr = baseReader as XmlValidatingReader;
if (vr != null)
{
v1XmlTextReader = (XmlTextReader)vr.Reader;
}
}
#endif
// assume the V1 readers already do all conformance checking;
// wrap only if IgnoreWhitespace, IgnoreComments, IgnoreProcessingInstructions or ProhibitDtd is true;
if (this.ignoreWhitespace)
{
WhitespaceHandling wh = WhitespaceHandling.All;
#if !SILVERLIGHT
// special-case our V1 readers to see if whey already filter whitespaces
if (v1XmlTextReader != null)
{
wh = v1XmlTextReader.WhitespaceHandling;
}
#endif
if (wh == WhitespaceHandling.All)
{
noWhitespace = true;
needWrap = true;
}
}
if (this.ignoreComments)
{
noComments = true;
needWrap = true;
}
if (this.ignorePIs)
{
noPIs = true;
needWrap = true;
}
// DTD processing
DtdProcessing baseDtdProcessing = DtdProcessing.Parse;
#if !SILVERLIGHT
if (v1XmlTextReader != null)
{
baseDtdProcessing = v1XmlTextReader.DtdProcessing;
}
#endif
if ((this.dtdProcessing == DtdProcessing.Prohibit && baseDtdProcessing != DtdProcessing.Prohibit) ||
(this.dtdProcessing == DtdProcessing.Ignore && baseDtdProcessing == DtdProcessing.Parse))
{
dtdProc = this.dtdProcessing;
needWrap = true;
}
#pragma warning restore 618
}
else
{
if (this.conformanceLevel != baseReaderSettings.ConformanceLevel && this.conformanceLevel != ConformanceLevel.Auto)
{
throw new InvalidOperationException(Res.GetString(Res.Xml_IncompatibleConformanceLevel, this.conformanceLevel.ToString()));
}
if (this.checkCharacters && !baseReaderSettings.CheckCharacters)
{
checkChars = true;
needWrap = true;
}
if (this.ignoreWhitespace && !baseReaderSettings.IgnoreWhitespace)
{
noWhitespace = true;
needWrap = true;
}
if (this.ignoreComments && !baseReaderSettings.IgnoreComments)
{
noComments = true;
needWrap = true;
}
if (this.ignorePIs && !baseReaderSettings.IgnoreProcessingInstructions)
{
noPIs = true;
needWrap = true;
}
if ((this.dtdProcessing == DtdProcessing.Prohibit && baseReaderSettings.DtdProcessing != DtdProcessing.Prohibit) ||
(this.dtdProcessing == DtdProcessing.Ignore && baseReaderSettings.DtdProcessing == DtdProcessing.Parse))
{
dtdProc = this.dtdProcessing;
needWrap = true;
}
}
if (needWrap)
{
IXmlNamespaceResolver readerAsNSResolver = baseReader as IXmlNamespaceResolver;
if (readerAsNSResolver != null)
{
return(new XmlCharCheckingReaderWithNS(baseReader, readerAsNSResolver, checkChars, noWhitespace, noComments, noPIs, dtdProc));
}
else
{
return(new XmlCharCheckingReader(baseReader, checkChars, noWhitespace, noComments, noPIs, dtdProc));
}
}
else
{
return(baseReader);
}
}
public DiffConfiguration(WhitespaceHandling whitespaceHandling)
: this(DEFAULT_DESCRIPTION,
DEFAULT_USE_VALIDATING_PARSER,
whitespaceHandling)
{
}
//
// Public Methods and Properties
//
public virtual bool Load(XmlReader rXmlReader)
{
//Hook up your reader as my reader
_rXmlReader = rXmlReader;
if (rXmlReader is XmlTextReader)
{
_eWhitespaceMode = ((XmlTextReader)rXmlReader).WhitespaceHandling;
_fNamespaces = ((XmlTextReader)rXmlReader).Namespaces;
_eValidationMode = ValidationType.None;
// _eEntityMode = ((XmlValidatingReader)rXmlReader).EntityHandling;
}
#pragma warning disable 0618
if (rXmlReader is XmlValidatingReader)
{
if (((XmlValidatingReader)rXmlReader).Reader is XmlTextReader)
{
_eWhitespaceMode = ((XmlTextReader)((XmlValidatingReader)rXmlReader).Reader).WhitespaceHandling;
}
else
{
_eWhitespaceMode = WhitespaceHandling.None;
}
_fNamespaces = ((XmlValidatingReader)rXmlReader).Namespaces;
_eValidationMode = ((XmlValidatingReader)rXmlReader).ValidationType;
_eEntityMode = ((XmlValidatingReader)rXmlReader).EntityHandling;
}
#pragma warning restore 0618
DebugTrace("Setting ValidationMode=" + _eValidationMode.ToString());
DebugTrace("Setting EntityMode=" + _eEntityMode.ToString());
DebugTrace("Setting WhitespaceMode=" + _eWhitespaceMode.ToString());
//Process the Document
try
{
_rDocumentRootNode = new CXmlNode("", "", XmlNodeType.Element);
_rDocumentRootNode._eFlags = NodeFlags.DocumentRoot | NodeFlags.Indent;
Process(_rDocumentRootNode);
for (_rRootNode = _rDocumentRootNode.FirstChild; _rRootNode != null && _rRootNode.NodeType != XmlNodeType.Element; _rRootNode = _rRootNode.NextNode) ;
}
catch (Exception e)
{
//Unhook your reader
_rXmlReader = null;
_strParseError = e.ToString();
if (_fThrow)
{
throw (e);
}
if (_hr == 0)
_hr = -1;
return false;
}
//Unhook your reader
_rXmlReader = null;
return true;
}
/// <summary>
/// Reads an ini file asynchronously
/// </summary>
/// <param name="SR">Open Stream Reader</param>
/// <returns>Task</returns>
private async Task ReadData(StreamReader SR)
{
int LineCount = 0;
var TempSections = new List <IniSection>();
//Currently active section
IniSection CurrentSection = null;
//Comment cache
var Comments = new List <string>();
//Matches sections and extracts the name
var Section = new Regex(@"^\s*\[(.*)\]\s*$");
//Matches settings and extracts name + value
var Setting = new Regex(@"^([^=]*)=(.*)$");
//Currently processed line
string Line;
do
{
++LineCount;
Line = await SR.ReadLineAsync();
if (Line != null)
{
//Skip over empty lines
if (Line.Trim() == "")
{
continue;
}
if (Line[0] == CommentChar)
{
//Add the comment without the comment character
//Comments are always preserved regardless of the IgnoreWhitespace setting
Comments.Add(Line.Substring(1));
}
else if (Section.IsMatch(Line))
{
var SectionName = Section.Match(Line).Groups[1].Value;
if (WhitespaceHandling.HasFlag(WhitespaceMode.TrimSections))
{
SectionName = SectionName.Trim();
}
//Save old section
if (CurrentSection != null && !TempSections.Contains(CurrentSection))
{
TempSections.Add(CurrentSection);
}
//Get existing section of the same name (if any)
CurrentSection = TempSections.FirstOrDefault(m => SecEq(SectionName, m.Name));
if (CurrentSection == null)
{
CurrentSection = new IniSection(SectionName);
}
if (Comments.Count > 0)
{
//Add new comments (if any) to the existing section
if (Tools.IsEmpty(CurrentSection.Comments))
{
CurrentSection.Comments = Comments.ToArray();
}
else
{
CurrentSection.Comments = CurrentSection.Comments.Concat(Comments).ToArray();
}
Comments.Clear();
}
}
else if (Setting.IsMatch(Line))
{
//Setting for the current section
var Matches = Setting.Match(Line);
var SettingName = Matches.Groups[1].Value;
var SettingValue = Matches.Groups[2].Value;
if (WhitespaceHandling.HasFlag(WhitespaceMode.TrimNames))
{
SettingName = SettingName.Trim();
}
if (WhitespaceHandling.HasFlag(WhitespaceMode.TrimValues))
{
SettingValue = SettingValue.Trim();
}
var CurrentSetting = new IniSetting(SettingName, SettingValue);
//Create a "null" section for settings that appear before the first section
if (CurrentSection == null)
{
CurrentSection = new IniSection();
}
if (Comments.Count > 0)
{
CurrentSetting.Comments = Comments.ToArray();
Comments.Clear();
}
CurrentSection.Settings.Add(CurrentSetting);
}
else
{
switch (InvalidLineHandling)
{
case InvalidLineMode.Throw:
throw new InvalidDataException($"Line {LineCount} is neither section, setting, comment, or empty: {Line}");
case InvalidLineMode.Skip:
break;
case InvalidLineMode.Convert:
Comments.Add(Line);
break;
default:
throw new NotImplementedException(nameof(InvalidLineMode));
}
}
}
} while (Line != null);
//Apply case handling to all sections
foreach (var Entry in TempSections)
{
Entry.CaseHandling = CaseHandling;
}
_sections = TempSections;
//Add last section
if (CurrentSection != null)
{
_sections.Add(CurrentSection);
}
if (Comments.Count > 0)
{
EndComments = Comments.ToArray();
}
}
// Initializes a new instance of the XmlTextReaderImpl class with the specified XmlNameTable.
// This constructor is used when creating XmlTextReaderImpl for V1 XmlTextReader
internal XmlTextReaderImpl( XmlNameTable nt ) {
Debug.Assert( nt != null );
v1Compat = true;
outerReader = this;
nameTable = nt;
nt.Add( string.Empty );
xmlResolver = new XmlUrlResolver();
Xml = nt.Add( "xml" );
XmlNs = nt.Add( "xmlns" );
Debug.Assert( index == 0 );
nodes = new NodeData[ NodesInitialSize ];
nodes[0] = new NodeData();
curNode = nodes[0];
stringBuilder = new BufferBuilder();
xmlContext = new XmlContext();
parsingFunction = ParsingFunction.SwitchToInteractiveXmlDecl;
nextParsingFunction = ParsingFunction.DocumentContent;
entityHandling = EntityHandling.ExpandCharEntities;
whitespaceHandling = WhitespaceHandling.All;
closeInput = true;
maxCharactersInDocument = 0;
// Breaking change: entity expansion is enabled, but limit it to 10,000,000 chars (like XLinq)
maxCharactersFromEntities = (long)1e7;
charactersInDocument = 0;
charactersFromEntities = 0;
ps.lineNo = 1;
ps.lineStartPos = -1;
}
protected XmlTextReader(XmlNameTable nt)
{
if(nt == null)
{
throw new ArgumentNullException("nt");
}
namespaces = true;
normalize = false;
depth = 0;
readState = ReadState.Initial;
whitespace = WhitespaceHandling.All;
xmlBaseName = nt.Add("xml:base");
xmlLangName = nt.Add("xml:lang");
xmlSpaceName = nt.Add("xml:space");
xmlNSPrefix = nt.Add("xmlns");
xmlCompareQuick = nt.Add("xml");
contextSupport = false;
hasRoot = true;
incDepth = false;
xmlPopScope = false;
xmlnsPopScope = false;
sawPreserve = -1;
state = State.XmlDeclaration;
elementNames = new Stack();
nodes = new NodeManager(nt, new ErrorHandler(Error));
input = new XmlParserInput
(null, nt, new EOFHandler(HandleEOF), new ErrorHandler(Error));
context = new XmlParserContext
(nt, new XmlNamespaceManager(nt), String.Empty, XmlSpace.None);
resolver = new XmlUrlResolver();
dtdReader = new XmlDTDReader(context);
}
// This constructor is used when creating XmlTextReader reader via "XmlReader.Create(..)"
private XmlTextReader(XmlReaderSettings settings)
{
xmlContext = new XmlContext();
// create nametable
XmlNameTable nt = settings.NameTable;
if (nt == null)
{
nt = new NameTable();
Debug.Assert(nameTableFromSettings == false);
}
else
{
nameTableFromSettings = true;
}
nameTable = nt;
nt.Add("");
Xml = nt.Add("xml");
XmlNs = nt.Add("xmlns");
Debug.Assert(index == 0);
nodes = new NodeData[NodesInitialSize];
nodes[0] = new NodeData();
curNode = nodes[0];
stringBuilder = new BufferBuilder();
entityHandling = EntityHandling.ExpandEntities;
whitespaceHandling = (settings.IgnoreWhitespace) ? WhitespaceHandling.Significant : WhitespaceHandling.All;
normalize = true;
ignorePIs = settings.IgnoreProcessingInstructions;
ignoreComments = settings.IgnoreComments;
checkCharacters = settings.CheckCharacters;
lineNumberOffset = settings.LineNumberOffset;
linePositionOffset = settings.LinePositionOffset;
ps.lineNo = lineNumberOffset + 1;
ps.lineStartPos = -linePositionOffset - 1;
curNode.SetLineInfo(ps.LineNo - 1, ps.LinePos - 1);
parsingFunction = ParsingFunction.SwitchToInteractiveXmlDecl;
nextParsingFunction = ParsingFunction.DocumentContent;
switch (settings.ConformanceLevel)
{
case ConformanceLevel.Auto:
fragmentType = XmlNodeType.None;
break;
case ConformanceLevel.Fragment:
fragmentType = XmlNodeType.Element;
break;
case ConformanceLevel.Document:
fragmentType = XmlNodeType.Document;
break;
default:
Debug.Assert(false);
goto case ConformanceLevel.Document;
}
}
public DiffConfiguration(WhitespaceHandling whitespaceHandling)
: this(DEFAULT_DESCRIPTION,
DEFAULT_USE_VALIDATING_PARSER,
whitespaceHandling)
{
}
public DelimReader(char[] delimiter,
string comment,
CommentHandling commentHandling,
ExceptionHandling exceptionHandling,
WhitespaceHandling whitespaceHandling,
bool ignoreBlankLines,
bool ignoreBlankTokens,
bool ignoreLinesStartingWithDelimiter,
ICollection<char> stripChars
)
{
m_delimiter = delimiter;
m_comment = comment;
m_commentHandling = commentHandling;
m_exceptionHandling = exceptionHandling;
m_whitespaceHandling = whitespaceHandling;
m_ignoreBlankLines = ignoreBlankLines;
IgnoreBlankTokens = ignoreBlankTokens;
m_ignoreLinesStartingWithDelimiter = ignoreLinesStartingWithDelimiter;
m_stripChars = stripChars;
}
