mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-16 17:10:20 -10:00
This fixes an issue when building dotnet/corefx and all the SR.cs files are modified because Mono used a HashTable internally in ResXResourceReader and it returned the elements in a different order than MS.NET. Even though this isn't explicitly mentioned in the docs, the MS.NET implementation returns the elements in the same order as they appear in the resx and we should do the same.
444 lines
12 KiB
C#
444 lines
12 KiB
C#
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
// Copyright (c) 2004-2005 Novell, Inc.
|
|
//
|
|
// Authors:
|
|
// Duncan Mak [email protected]
|
|
// Nick Drochak [email protected]
|
|
// Paolo Molaro [email protected]
|
|
// Peter Bartok [email protected]
|
|
// Gert Driesen [email protected]
|
|
// Olivier Dufour [email protected]
|
|
// Gary Barnett [email protected]
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.Design;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Resources;
|
|
using System.Runtime.Serialization.Formatters.Binary;
|
|
using System.Xml;
|
|
using System.Reflection;
|
|
using System.Drawing;
|
|
using System.Runtime.Serialization;
|
|
|
|
namespace System.Resources
|
|
{
|
|
#if INSIDE_SYSTEM_WEB
|
|
internal
|
|
#else
|
|
public
|
|
#endif
|
|
class ResXResourceReader : IResourceReader, IDisposable
|
|
{
|
|
#region Local Variables
|
|
private string fileName;
|
|
private Stream stream;
|
|
private TextReader reader;
|
|
private OrderedDictionary hasht;
|
|
private ITypeResolutionService typeresolver;
|
|
private XmlTextReader xmlReader;
|
|
private string basepath;
|
|
private bool useResXDataNodes;
|
|
private AssemblyName [] assemblyNames;
|
|
private OrderedDictionary hashtm;
|
|
#endregion // Local Variables
|
|
|
|
#region Constructors & Destructor
|
|
public ResXResourceReader (Stream stream)
|
|
{
|
|
if (stream == null)
|
|
throw new ArgumentNullException ("stream");
|
|
|
|
if (!stream.CanRead)
|
|
throw new ArgumentException ("Stream was not readable.");
|
|
|
|
this.stream = stream;
|
|
}
|
|
|
|
public ResXResourceReader (Stream stream, ITypeResolutionService typeResolver)
|
|
: this (stream)
|
|
{
|
|
this.typeresolver = typeResolver;
|
|
}
|
|
|
|
public ResXResourceReader (string fileName)
|
|
{
|
|
this.fileName = fileName;
|
|
}
|
|
|
|
public ResXResourceReader (string fileName, ITypeResolutionService typeResolver)
|
|
: this (fileName)
|
|
{
|
|
this.typeresolver = typeResolver;
|
|
}
|
|
|
|
public ResXResourceReader (TextReader reader)
|
|
{
|
|
this.reader = reader;
|
|
}
|
|
|
|
public ResXResourceReader (TextReader reader, ITypeResolutionService typeResolver)
|
|
: this (reader)
|
|
{
|
|
this.typeresolver = typeResolver;
|
|
}
|
|
|
|
public ResXResourceReader (Stream stream, AssemblyName [] assemblyNames)
|
|
: this (stream)
|
|
{
|
|
this.assemblyNames = assemblyNames;
|
|
}
|
|
|
|
public ResXResourceReader (string fileName, AssemblyName [] assemblyNames)
|
|
: this (fileName)
|
|
{
|
|
this.assemblyNames = assemblyNames;
|
|
}
|
|
|
|
public ResXResourceReader (TextReader reader, AssemblyName [] assemblyNames)
|
|
: this (reader)
|
|
{
|
|
this.assemblyNames = assemblyNames;
|
|
}
|
|
|
|
~ResXResourceReader ()
|
|
{
|
|
Dispose (false);
|
|
}
|
|
#endregion // Constructors & Destructor
|
|
|
|
public string BasePath {
|
|
get { return basepath; }
|
|
set { basepath = value; }
|
|
}
|
|
|
|
public bool UseResXDataNodes {
|
|
get { return useResXDataNodes; }
|
|
set {
|
|
if (xmlReader != null)
|
|
throw new InvalidOperationException ();
|
|
useResXDataNodes = value;
|
|
}
|
|
}
|
|
|
|
#region Private Methods
|
|
private void LoadData ()
|
|
{
|
|
hasht = new OrderedDictionary ();
|
|
hashtm = new OrderedDictionary ();
|
|
if (fileName != null) {
|
|
stream = File.OpenRead (fileName);
|
|
}
|
|
|
|
try {
|
|
xmlReader = null;
|
|
if (stream != null) {
|
|
xmlReader = new XmlTextReader (stream);
|
|
} else if (reader != null) {
|
|
xmlReader = new XmlTextReader (reader);
|
|
}
|
|
|
|
if (xmlReader == null) {
|
|
throw new InvalidOperationException ("ResourceReader is closed.");
|
|
}
|
|
|
|
xmlReader.WhitespaceHandling = WhitespaceHandling.None;
|
|
|
|
ResXHeader header = new ResXHeader ();
|
|
try {
|
|
while (xmlReader.Read ()) {
|
|
if (xmlReader.NodeType != XmlNodeType.Element)
|
|
continue;
|
|
|
|
switch (xmlReader.LocalName) {
|
|
case "resheader":
|
|
ParseHeaderNode (header);
|
|
break;
|
|
case "data":
|
|
ParseDataNode (false);
|
|
break;
|
|
case "metadata":
|
|
ParseDataNode (true);
|
|
break;
|
|
}
|
|
}
|
|
} catch (XmlException ex) {
|
|
throw new ArgumentException ("Invalid ResX input.", ex);
|
|
} catch (SerializationException ex) {
|
|
throw ex;
|
|
} catch (TargetInvocationException ex) {
|
|
throw ex;
|
|
} catch (Exception ex) {
|
|
XmlException xex = new XmlException (ex.Message, ex,
|
|
xmlReader.LineNumber, xmlReader.LinePosition);
|
|
throw new ArgumentException ("Invalid ResX input.", xex);
|
|
}
|
|
header.Verify ();
|
|
} finally {
|
|
if (fileName != null) {
|
|
stream.Close ();
|
|
stream = null;
|
|
}
|
|
xmlReader = null;
|
|
}
|
|
}
|
|
|
|
private void ParseHeaderNode (ResXHeader header)
|
|
{
|
|
string v = GetAttribute ("name");
|
|
if (v == null)
|
|
return;
|
|
|
|
if (String.Compare (v, "resmimetype", true) == 0) {
|
|
header.ResMimeType = GetHeaderValue ();
|
|
} else if (String.Compare (v, "reader", true) == 0) {
|
|
header.Reader = GetHeaderValue ();
|
|
} else if (String.Compare (v, "version", true) == 0) {
|
|
header.Version = GetHeaderValue ();
|
|
} else if (String.Compare (v, "writer", true) == 0) {
|
|
header.Writer = GetHeaderValue ();
|
|
}
|
|
}
|
|
|
|
private string GetHeaderValue ()
|
|
{
|
|
string value = null;
|
|
xmlReader.ReadStartElement ();
|
|
if (xmlReader.NodeType == XmlNodeType.Element) {
|
|
value = xmlReader.ReadElementString ();
|
|
} else {
|
|
value = xmlReader.Value.Trim ();
|
|
}
|
|
return value;
|
|
}
|
|
|
|
private string GetAttribute (string name)
|
|
{
|
|
if (!xmlReader.HasAttributes)
|
|
return null;
|
|
for (int i = 0; i < xmlReader.AttributeCount; i++) {
|
|
xmlReader.MoveToAttribute (i);
|
|
if (String.Compare (xmlReader.Name, name, true) == 0) {
|
|
string v = xmlReader.Value;
|
|
xmlReader.MoveToElement ();
|
|
return v;
|
|
}
|
|
}
|
|
xmlReader.MoveToElement ();
|
|
return null;
|
|
}
|
|
|
|
private string GetDataValue (bool meta, out string comment)
|
|
{
|
|
string value = null;
|
|
comment = null;
|
|
while (xmlReader.Read ()) {
|
|
if (xmlReader.NodeType == XmlNodeType.EndElement && xmlReader.LocalName == (meta ? "metadata" : "data"))
|
|
break;
|
|
|
|
if (xmlReader.NodeType == XmlNodeType.Element) {
|
|
if (xmlReader.Name.Equals ("value")) {
|
|
xmlReader.WhitespaceHandling = WhitespaceHandling.Significant;
|
|
value = xmlReader.ReadString ();
|
|
xmlReader.WhitespaceHandling = WhitespaceHandling.None;
|
|
} else if (xmlReader.Name.Equals ("comment")) {
|
|
xmlReader.WhitespaceHandling = WhitespaceHandling.Significant;
|
|
comment = xmlReader.ReadString ();
|
|
xmlReader.WhitespaceHandling = WhitespaceHandling.None;
|
|
if (xmlReader.NodeType == XmlNodeType.EndElement && xmlReader.LocalName == (meta ? "metadata" : "data"))
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
value = xmlReader.Value.Trim ();
|
|
}
|
|
return value;
|
|
}
|
|
|
|
private void ParseDataNode (bool meta)
|
|
{
|
|
OrderedDictionary hashtable = ((meta && ! useResXDataNodes) ? hashtm : hasht);
|
|
Point pos = new Point (xmlReader.LineNumber, xmlReader.LinePosition);
|
|
string name = GetAttribute ("name");
|
|
string type_name = GetAttribute ("type");
|
|
string mime_type = GetAttribute ("mimetype");
|
|
|
|
|
|
string comment = null;
|
|
string value = GetDataValue (meta, out comment);
|
|
|
|
ResXDataNode node = new ResXDataNode (name, mime_type, type_name, value, comment, pos, BasePath);
|
|
|
|
if (useResXDataNodes) {
|
|
hashtable [name] = node;
|
|
return;
|
|
}
|
|
|
|
if (name == null)
|
|
throw new ArgumentException (string.Format (CultureInfo.CurrentCulture,
|
|
"Could not find a name for a resource. The resource value was '{0}'.",
|
|
node.GetValue ((AssemblyName []) null).ToString()));
|
|
|
|
// useResXDataNodes is false, add to dictionary of values
|
|
if (assemblyNames != null) {
|
|
try {
|
|
hashtable [name] = node.GetValue (assemblyNames);
|
|
} catch (TypeLoadException ex) {
|
|
// different error messages depending on type of resource, hacky solution
|
|
if (node.handler is TypeConverterFromResXHandler)
|
|
hashtable [name] = null;
|
|
else
|
|
throw ex;
|
|
}
|
|
} else { // there is a typeresolver or its null
|
|
try {
|
|
hashtable [name] = node.GetValue (typeresolver);
|
|
} catch (TypeLoadException ex) {
|
|
if (node.handler is TypeConverterFromResXHandler)
|
|
hashtable [name] = null;
|
|
else
|
|
throw ex;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
#endregion // Private Methods
|
|
|
|
#region Public Methods
|
|
public void Close ()
|
|
{
|
|
if (reader != null) {
|
|
reader.Close ();
|
|
reader = null;
|
|
}
|
|
}
|
|
|
|
public IDictionaryEnumerator GetEnumerator ()
|
|
{
|
|
if (hasht == null) {
|
|
LoadData ();
|
|
}
|
|
return hasht.GetEnumerator ();
|
|
}
|
|
|
|
IEnumerator IEnumerable.GetEnumerator ()
|
|
{
|
|
return ((IResourceReader) this).GetEnumerator ();
|
|
}
|
|
|
|
void IDisposable.Dispose ()
|
|
{
|
|
Dispose (true);
|
|
GC.SuppressFinalize (this);
|
|
}
|
|
|
|
protected virtual void Dispose (bool disposing)
|
|
{
|
|
if (disposing) {
|
|
Close ();
|
|
}
|
|
}
|
|
|
|
public static ResXResourceReader FromFileContents (string fileContents)
|
|
{
|
|
return new ResXResourceReader (new StringReader (fileContents));
|
|
}
|
|
|
|
public static ResXResourceReader FromFileContents (string fileContents, ITypeResolutionService typeResolver)
|
|
{
|
|
return new ResXResourceReader (new StringReader (fileContents), typeResolver);
|
|
}
|
|
|
|
public static ResXResourceReader FromFileContents (string fileContents, AssemblyName [] assemblyNames)
|
|
{
|
|
return new ResXResourceReader (new StringReader (fileContents), assemblyNames);
|
|
}
|
|
|
|
public IDictionaryEnumerator GetMetadataEnumerator ()
|
|
{
|
|
if (hashtm == null)
|
|
LoadData ();
|
|
return hashtm.GetEnumerator ();
|
|
}
|
|
|
|
#endregion // Public Methods
|
|
|
|
#region Internal Classes
|
|
private class ResXHeader
|
|
{
|
|
private string resMimeType;
|
|
private string reader;
|
|
private string version;
|
|
private string writer;
|
|
|
|
public string ResMimeType
|
|
{
|
|
get { return resMimeType; }
|
|
set { resMimeType = value; }
|
|
}
|
|
|
|
public string Reader {
|
|
get { return reader; }
|
|
set { reader = value; }
|
|
}
|
|
|
|
public string Version {
|
|
get { return version; }
|
|
set { version = value; }
|
|
}
|
|
|
|
public string Writer {
|
|
get { return writer; }
|
|
set { writer = value; }
|
|
}
|
|
|
|
public void Verify ()
|
|
{
|
|
if (!IsValid)
|
|
throw new ArgumentException ("Invalid ResX input. Could "
|
|
+ "not find valid \"resheader\" tags for the ResX "
|
|
+ "reader & writer type names.");
|
|
}
|
|
|
|
public bool IsValid {
|
|
get {
|
|
if (string.Compare (ResMimeType, ResXResourceWriter.ResMimeType) != 0)
|
|
return false;
|
|
if (Reader == null || Writer == null)
|
|
return false;
|
|
string readerType = Reader.Split (',') [0].Trim ();
|
|
if (readerType != typeof (ResXResourceReader).FullName)
|
|
return false;
|
|
string writerType = Writer.Split (',') [0].Trim ();
|
|
if (writerType != typeof (ResXResourceWriter).FullName)
|
|
return false;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
}
|
|
}
|