mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-17 01:41:17 -10:00
* AppResourcesCompiler.cs: implemented a type resolver for ResXResourceReader so that it can correctly resolve System.Resources types which are normally found in System.Windows.Forms but are included by System.Web directly. Without the type resolver, code comparing types inside ResXResourceReader when file references are used in side the .resx file will not work correctly. The reason for that is that .resx files will name "System.Resources.ResXFileRef, System.Windows.Forms" as the file reference handler, while inside System.Web ResXFileRef will be of type "System.Resources.ResXFileRef, System.Web". Fixes bug #466059 svn path=/trunk/mcs/; revision=125945
758 lines
23 KiB
C#
758 lines
23 KiB
C#
//
|
|
// System.Web.Compilation.AppResourceFilesCollection
|
|
//
|
|
// Authors:
|
|
// Marek Habersack ([email protected])
|
|
//
|
|
// (C) 2006 Marek Habersack
|
|
// (C) 2007-2009 Novell, Inc http://novell.com/
|
|
//
|
|
|
|
//
|
|
// 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.
|
|
//
|
|
#if NET_2_0
|
|
using System;
|
|
using System.CodeDom;
|
|
using System.CodeDom.Compiler;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.ComponentModel.Design;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Resources;
|
|
using System.Web;
|
|
using System.Web.Caching;
|
|
using System.Web.Configuration;
|
|
using System.Web.Util;
|
|
|
|
namespace System.Web.Compilation
|
|
{
|
|
class AppResourcesCompiler
|
|
{
|
|
// This class fixes bug #466059
|
|
class TypeResolutionService : ITypeResolutionService
|
|
{
|
|
List <Assembly> referencedAssemblies;
|
|
Dictionary <string, Type> mappedTypes;
|
|
|
|
public Assembly GetAssembly (AssemblyName name)
|
|
{
|
|
return GetAssembly (name, false);
|
|
}
|
|
|
|
public Assembly GetAssembly (AssemblyName name, bool throwOnError)
|
|
{
|
|
try {
|
|
return Assembly.Load (name);
|
|
} catch {
|
|
if (throwOnError)
|
|
throw;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public void ReferenceAssembly (AssemblyName name)
|
|
{
|
|
if (referencedAssemblies == null)
|
|
referencedAssemblies = new List <Assembly> ();
|
|
|
|
Assembly asm = GetAssembly (name, false);
|
|
if (asm == null)
|
|
return;
|
|
|
|
if (referencedAssemblies.Contains (asm))
|
|
return;
|
|
|
|
referencedAssemblies.Add (asm);
|
|
}
|
|
|
|
public string GetPathOfAssembly (AssemblyName name)
|
|
{
|
|
if (name == null)
|
|
return null;
|
|
|
|
Assembly asm = GetAssembly (name, false);
|
|
if (asm == null)
|
|
return null;
|
|
|
|
return asm.Location;
|
|
}
|
|
|
|
public Type GetType (string name)
|
|
{
|
|
return GetType (name, false, false);
|
|
}
|
|
|
|
public Type GetType (string name, bool throwOnError)
|
|
{
|
|
return GetType (name, throwOnError, false);
|
|
}
|
|
|
|
public Type GetType (string name, bool throwOnError, bool ignoreCase)
|
|
{
|
|
if (String.IsNullOrEmpty (name)) {
|
|
if (throwOnError)
|
|
throw new ArgumentNullException ("name");
|
|
else
|
|
return null;
|
|
}
|
|
|
|
int idx = name.IndexOf (',');
|
|
Type type = null;
|
|
if (idx == -1) {
|
|
type = MapType (name, false);
|
|
if (type != null)
|
|
return type;
|
|
|
|
type = FindInAssemblies (name, ignoreCase);
|
|
if (type == null) {
|
|
if (throwOnError)
|
|
throw new InvalidOperationException ("Type '" + name + "' is not fully qualified and there are no referenced assemblies.");
|
|
else
|
|
return null;
|
|
}
|
|
|
|
return type;
|
|
}
|
|
|
|
type = MapType (name, true);
|
|
if (type != null)
|
|
return type;
|
|
|
|
return Type.GetType (name, throwOnError, ignoreCase);
|
|
}
|
|
|
|
Type MapType (string name, bool full)
|
|
{
|
|
if (mappedTypes == null)
|
|
mappedTypes = new Dictionary <string, Type> (StringComparer.Ordinal);
|
|
|
|
Type ret;
|
|
if (mappedTypes.TryGetValue (name, out ret))
|
|
return ret;
|
|
|
|
if (!full) {
|
|
if (String.Compare (name, "ResXDataNode", StringComparison.Ordinal) == 0)
|
|
return AddMappedType (name, typeof (ResXDataNode));
|
|
if (String.Compare (name, "ResXFileRef", StringComparison.Ordinal) == 0)
|
|
return AddMappedType (name, typeof (ResXFileRef));
|
|
if (String.Compare (name, "ResXNullRef", StringComparison.Ordinal) == 0)
|
|
return AddMappedType (name, typeof (ResXNullRef));
|
|
if (String.Compare (name, "ResXResourceReader", StringComparison.Ordinal) == 0)
|
|
return AddMappedType (name, typeof (ResXResourceReader));
|
|
if (String.Compare (name, "ResXResourceWriter", StringComparison.Ordinal) == 0)
|
|
return AddMappedType (name, typeof (ResXResourceWriter));
|
|
|
|
return null;
|
|
}
|
|
|
|
if (name.IndexOf ("System.Windows.Forms") == -1)
|
|
return null;
|
|
|
|
if (name.IndexOf ("ResXDataNode", StringComparison.Ordinal) != -1)
|
|
return AddMappedType (name, typeof (ResXDataNode));
|
|
if (name.IndexOf ("ResXFileRef", StringComparison.Ordinal) != -1)
|
|
return AddMappedType (name, typeof (ResXFileRef));
|
|
if (name.IndexOf ("ResXNullRef", StringComparison.Ordinal) != -1)
|
|
return AddMappedType (name, typeof (ResXNullRef));
|
|
if (name.IndexOf ("ResXResourceReader", StringComparison.Ordinal) != -1)
|
|
return AddMappedType (name, typeof (ResXResourceReader));
|
|
if (name.IndexOf ("ResXResourceWriter", StringComparison.Ordinal) != -1)
|
|
return AddMappedType (name, typeof (ResXResourceWriter));
|
|
|
|
return null;
|
|
}
|
|
|
|
Type AddMappedType (string name, Type type)
|
|
{
|
|
mappedTypes.Add (name, type);
|
|
return type;
|
|
}
|
|
|
|
Type FindInAssemblies (string name, bool ignoreCase)
|
|
{
|
|
Type ret = Type.GetType (name, false);
|
|
if (ret != null)
|
|
return ret;
|
|
|
|
if (referencedAssemblies == null || referencedAssemblies.Count == 0)
|
|
return null;
|
|
|
|
foreach (Assembly asm in referencedAssemblies) {
|
|
ret = asm.GetType (name, false, ignoreCase);
|
|
if (ret != null)
|
|
return ret;
|
|
}
|
|
|
|
return null;
|
|
}
|
|
}
|
|
|
|
const string cachePrefix = "@@LocalResourcesAssemblies";
|
|
public const string DefaultCultureKey = ".:!DefaultCulture!:.";
|
|
|
|
bool isGlobal;
|
|
AppResourceFilesCollection files;
|
|
string tempDirectory;
|
|
string virtualPath;
|
|
Dictionary <string, List <string>> cultureFiles;
|
|
|
|
string TempDirectory {
|
|
get {
|
|
if (tempDirectory != null)
|
|
return tempDirectory;
|
|
return (tempDirectory = AppDomain.CurrentDomain.SetupInformation.DynamicBase);
|
|
}
|
|
}
|
|
|
|
public Dictionary <string, List <string>> CultureFiles {
|
|
get { return cultureFiles; }
|
|
}
|
|
|
|
public AppResourcesCompiler (HttpContext context)
|
|
{
|
|
this.isGlobal = true;
|
|
this.files = new AppResourceFilesCollection (context);
|
|
this.cultureFiles = new Dictionary <string, List <string>> ();
|
|
}
|
|
|
|
public AppResourcesCompiler (string virtualPath)
|
|
{
|
|
|
|
this.virtualPath = virtualPath;
|
|
this.isGlobal = false;
|
|
this.files = new AppResourceFilesCollection (HttpContext.Current.Request.MapPath (virtualPath));
|
|
this.cultureFiles = new Dictionary <string, List <string>> ();
|
|
}
|
|
|
|
public Assembly Compile ()
|
|
{
|
|
files.Collect ();
|
|
if (!files.HasFiles)
|
|
return null;
|
|
if (isGlobal)
|
|
return CompileGlobal ();
|
|
else
|
|
return CompileLocal ();
|
|
}
|
|
|
|
Assembly CompileGlobal ()
|
|
{
|
|
string assemblyPath = FileUtils.CreateTemporaryFile (TempDirectory,
|
|
"App_GlobalResources",
|
|
"dll",
|
|
OnCreateRandomFile) as string;
|
|
|
|
if (assemblyPath == null)
|
|
throw new ApplicationException ("Failed to create global resources assembly");
|
|
|
|
List <string>[] fileGroups = GroupGlobalFiles ();
|
|
if (fileGroups == null || fileGroups.Length == 0)
|
|
return null;
|
|
|
|
CodeCompileUnit unit = new CodeCompileUnit ();
|
|
CodeNamespace ns = new CodeNamespace (null);
|
|
ns.Imports.Add (new CodeNamespaceImport ("System"));
|
|
ns.Imports.Add (new CodeNamespaceImport ("System.Globalization"));
|
|
ns.Imports.Add (new CodeNamespaceImport ("System.Reflection"));
|
|
ns.Imports.Add (new CodeNamespaceImport ("System.Resources"));
|
|
unit.Namespaces.Add (ns);
|
|
|
|
AppResourcesAssemblyBuilder builder = new AppResourcesAssemblyBuilder ("App_GlobalResources", assemblyPath,
|
|
this);
|
|
CodeDomProvider provider = builder.Provider;
|
|
|
|
Dictionary <string,bool> assemblies = new Dictionary<string,bool> ();
|
|
foreach (List<string> ls in fileGroups)
|
|
DomFromResource (ls [0], unit, assemblies, provider);
|
|
|
|
foreach (KeyValuePair<string,bool> de in assemblies)
|
|
unit.ReferencedAssemblies.Add (de.Key);
|
|
|
|
builder.Build (unit);
|
|
HttpContext.AppGlobalResourcesAssembly = builder.MainAssembly;
|
|
|
|
return builder.MainAssembly;
|
|
}
|
|
|
|
Assembly CompileLocal ()
|
|
{
|
|
if (String.IsNullOrEmpty (virtualPath))
|
|
return null;
|
|
|
|
Assembly cached = GetCachedLocalResourcesAssembly (virtualPath);
|
|
if (cached != null)
|
|
return cached;
|
|
|
|
string prefix;
|
|
if (virtualPath == "/")
|
|
prefix = "App_LocalResources.root";
|
|
else
|
|
prefix = "App_LocalResources" + virtualPath.Replace ('/', '.');
|
|
|
|
string assemblyPath = FileUtils.CreateTemporaryFile (TempDirectory,
|
|
prefix,
|
|
"dll",
|
|
OnCreateRandomFile) as string;
|
|
if (assemblyPath == null)
|
|
throw new ApplicationException ("Failed to create local resources assembly");
|
|
|
|
List<AppResourceFileInfo> files = this.files.Files;
|
|
foreach (AppResourceFileInfo arfi in files)
|
|
GetResourceFile (arfi, true);
|
|
|
|
AppResourcesAssemblyBuilder builder = new AppResourcesAssemblyBuilder ("App_LocalResources", assemblyPath,
|
|
this);
|
|
builder.Build ();
|
|
Assembly ret = builder.MainAssembly;
|
|
|
|
if (ret != null)
|
|
AddAssemblyToCache (virtualPath, ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
internal static Assembly GetCachedLocalResourcesAssembly (string path)
|
|
{
|
|
Dictionary <string, Assembly> cache;
|
|
|
|
cache = HttpRuntime.InternalCache[cachePrefix] as Dictionary <string, Assembly>;
|
|
if (cache == null || !cache.ContainsKey (path))
|
|
return null;
|
|
return cache [path];
|
|
}
|
|
|
|
void AddAssemblyToCache (string path, Assembly asm)
|
|
{
|
|
Cache runtimeCache = HttpRuntime.InternalCache;
|
|
Dictionary <string, Assembly> cache;
|
|
|
|
cache = runtimeCache[cachePrefix] as Dictionary <string, Assembly>;
|
|
if (cache == null)
|
|
cache = new Dictionary <string, Assembly> ();
|
|
cache [path] = asm;
|
|
runtimeCache.Insert (cachePrefix, cache);
|
|
}
|
|
|
|
uint CountChars (char c, string s)
|
|
{
|
|
uint ret = 0;
|
|
foreach (char ch in s) {
|
|
if (ch == c)
|
|
ret++;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
string IsFileCultureValid (string fileName)
|
|
{
|
|
string tmp = Path.GetFileNameWithoutExtension (fileName);
|
|
tmp = Path.GetExtension (tmp);
|
|
if (tmp != null && tmp.Length > 0) {
|
|
tmp = tmp.Substring (1);
|
|
try {
|
|
CultureInfo.GetCultureInfo (tmp);
|
|
return tmp;
|
|
} catch {
|
|
return null;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
string GetResourceFile (AppResourceFileInfo arfi, bool local)
|
|
{
|
|
string resfile;
|
|
if (arfi.Kind == AppResourceFileKind.ResX)
|
|
resfile = CompileResource (arfi, local);
|
|
else
|
|
resfile = arfi.Info.FullName;
|
|
if (!String.IsNullOrEmpty (resfile)) {
|
|
string culture = IsFileCultureValid (resfile);
|
|
if (culture == null)
|
|
culture = DefaultCultureKey;
|
|
|
|
List <string> cfiles;
|
|
if (cultureFiles.ContainsKey (culture))
|
|
cfiles = cultureFiles [culture];
|
|
else {
|
|
cfiles = new List <string> (1);
|
|
cultureFiles [culture] = cfiles;
|
|
}
|
|
cfiles.Add (resfile);
|
|
}
|
|
|
|
return resfile;
|
|
}
|
|
|
|
List <string>[] GroupGlobalFiles ()
|
|
{
|
|
List<AppResourceFileInfo> files = this.files.Files;
|
|
List<List<string>> groups = new List<List<string>> ();
|
|
AppResourcesLengthComparer<List<string>> lcList = new AppResourcesLengthComparer<List<string>> ();
|
|
|
|
string tmp, s, basename;
|
|
uint basedots, filedots;
|
|
AppResourceFileInfo defaultFile;
|
|
|
|
foreach (AppResourceFileInfo arfi in files) {
|
|
if (arfi.Kind != AppResourceFileKind.ResX && arfi.Kind != AppResourceFileKind.Resource)
|
|
continue;
|
|
|
|
s = arfi.Info.FullName;
|
|
basename = Path.GetFileNameWithoutExtension (s);
|
|
basedots = CountChars ('.', basename);
|
|
defaultFile = null;
|
|
|
|
// If there are any files that start with this baseName, we have a default file
|
|
foreach (AppResourceFileInfo fi in files) {
|
|
if (fi.Seen)
|
|
continue;
|
|
|
|
string s2 = fi.Info.FullName;
|
|
if (s2 == null || s == s2)
|
|
continue;
|
|
tmp = Path.GetFileNameWithoutExtension (s2);
|
|
filedots = CountChars ('.', tmp);
|
|
|
|
if (filedots == basedots + 1 && tmp.StartsWith (basename)) {
|
|
if (IsFileCultureValid (s2) != null) {
|
|
// A valid translated file for this name
|
|
defaultFile = arfi;
|
|
break;
|
|
} else {
|
|
// This file shares the base name, but the culture is invalid - we must
|
|
// ignore it since the name of the generated strongly typed class for this
|
|
// resource will clash with the one generated from the default file with
|
|
// the given basename.
|
|
fi.Seen = true;
|
|
}
|
|
}
|
|
}
|
|
if (defaultFile != null) {
|
|
List<string> al = new List<string> ();
|
|
al.Add (GetResourceFile (arfi, false));
|
|
arfi.Seen = true;
|
|
groups.Add (al);
|
|
|
|
}
|
|
}
|
|
groups.Sort (lcList);
|
|
|
|
string tmp2;
|
|
// Now find their translated counterparts
|
|
foreach (List<string> al in groups) {
|
|
s = al [0];
|
|
tmp = Path.GetFileNameWithoutExtension (s);
|
|
if (tmp.StartsWith ("Resources."))
|
|
tmp = tmp.Substring (10);
|
|
foreach (AppResourceFileInfo arfi in files) {
|
|
if (arfi.Seen)
|
|
continue;
|
|
s = arfi.Info.FullName;
|
|
if (s == null)
|
|
continue;
|
|
tmp2 = arfi.Info.Name;
|
|
if (tmp2.StartsWith (tmp)) {
|
|
al.Add (GetResourceFile (arfi, false));
|
|
arfi.Seen = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Anything that's left here might be orphans or lone default files.
|
|
// For those files we check the part following the last dot
|
|
// before the .resx/.resource extensions and test whether it's a registered
|
|
// culture or not. If it is not a culture, then we have a
|
|
// default file that doesn't have any translations. Otherwise,
|
|
// the file is ignored (it's the same thing MS.NET does)
|
|
foreach (AppResourceFileInfo arfi in files) {
|
|
if (arfi.Seen)
|
|
continue;
|
|
|
|
if (IsFileCultureValid (arfi.Info.FullName) != null)
|
|
continue; // Culture found, we reject the file
|
|
|
|
// A single default file, create a group
|
|
List<string> al = new List<string> ();
|
|
al.Add (GetResourceFile (arfi, false));
|
|
groups.Add (al);
|
|
}
|
|
groups.Sort (lcList);
|
|
return groups.ToArray ();
|
|
}
|
|
|
|
// CodeDOM generation
|
|
void DomFromResource (string resfile, CodeCompileUnit unit, Dictionary <string,bool> assemblies,
|
|
CodeDomProvider provider)
|
|
{
|
|
if (String.IsNullOrEmpty (resfile))
|
|
return;
|
|
|
|
string fname, nsname, classname;
|
|
|
|
fname = Path.GetFileNameWithoutExtension (resfile);
|
|
nsname = Path.GetFileNameWithoutExtension (fname);
|
|
classname = Path.GetExtension (fname);
|
|
if (classname == null || classname.Length == 0) {
|
|
classname = nsname;
|
|
nsname = "Resources";
|
|
} else {
|
|
if (!nsname.StartsWith ("Resources", StringComparison.InvariantCulture))
|
|
nsname = String.Concat ("Resources.", nsname);
|
|
classname = classname.Substring(1);
|
|
}
|
|
|
|
if (!String.IsNullOrEmpty (classname))
|
|
classname = classname.Replace ('.', '_');
|
|
if (!String.IsNullOrEmpty (nsname))
|
|
nsname = nsname.Replace ('.', '_');
|
|
|
|
if (!provider.IsValidIdentifier (nsname) || !provider.IsValidIdentifier (classname))
|
|
throw new ApplicationException ("Invalid resource file name.");
|
|
|
|
ResourceReader res;
|
|
try {
|
|
res = new ResourceReader (resfile);
|
|
} catch (ArgumentException) {
|
|
// invalid stream, probably empty - ignore silently and abort
|
|
return;
|
|
}
|
|
|
|
CodeNamespace ns = new CodeNamespace (nsname);
|
|
CodeTypeDeclaration cls = new CodeTypeDeclaration (classname);
|
|
cls.IsClass = true;
|
|
cls.TypeAttributes = TypeAttributes.Public | TypeAttributes.Sealed;
|
|
|
|
CodeMemberField cmf = new CodeMemberField (typeof(CultureInfo), "_culture");
|
|
cmf.InitExpression = new CodePrimitiveExpression (null);
|
|
cmf.Attributes = MemberAttributes.Private | MemberAttributes.Final | MemberAttributes.Static;
|
|
cls.Members.Add (cmf);
|
|
|
|
cmf = new CodeMemberField (typeof(ResourceManager), "_resourceManager");
|
|
cmf.InitExpression = new CodePrimitiveExpression (null);
|
|
cmf.Attributes = MemberAttributes.Private | MemberAttributes.Final | MemberAttributes.Static;
|
|
cls.Members.Add (cmf);
|
|
|
|
// Property: ResourceManager
|
|
CodeMemberProperty cmp = new CodeMemberProperty ();
|
|
cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Static;
|
|
cmp.Name = "ResourceManager";
|
|
cmp.HasGet = true;
|
|
cmp.Type = new CodeTypeReference (typeof(ResourceManager));
|
|
CodePropertyResourceManagerGet (cmp.GetStatements, resfile, classname);
|
|
cls.Members.Add (cmp);
|
|
|
|
// Property: Culture
|
|
cmp = new CodeMemberProperty ();
|
|
cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final;
|
|
cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Static;
|
|
cmp.Name = "Culture";
|
|
cmp.HasGet = true;
|
|
cmp.HasSet = true;
|
|
cmp.Type = new CodeTypeReference (typeof(CultureInfo));
|
|
CodePropertyGenericGet (cmp.GetStatements, "_culture", classname);
|
|
CodePropertyGenericSet (cmp.SetStatements, "_culture", classname);
|
|
cls.Members.Add (cmp);
|
|
|
|
// Add the resource properties
|
|
Dictionary<string,bool> imports = new Dictionary<string,bool> ();
|
|
try {
|
|
foreach (DictionaryEntry de in res) {
|
|
Type type = de.Value.GetType ();
|
|
|
|
if (!imports.ContainsKey (type.Namespace))
|
|
imports [type.Namespace] = true;
|
|
|
|
string asname = new AssemblyName (type.Assembly.FullName).Name;
|
|
if (!assemblies.ContainsKey (asname))
|
|
assemblies [asname] = true;
|
|
|
|
cmp = new CodeMemberProperty ();
|
|
cmp.Attributes = MemberAttributes.Public | MemberAttributes.Final | MemberAttributes.Static;
|
|
cmp.Name = SanitizeResourceName ((string)de.Key);
|
|
cmp.HasGet = true;
|
|
CodePropertyResourceGet (cmp.GetStatements, (string)de.Key, type, classname);
|
|
cmp.Type = new CodeTypeReference (type);
|
|
cls.Members.Add (cmp);
|
|
}
|
|
} catch (Exception ex) {
|
|
throw new ApplicationException ("Failed to compile global resources.", ex);
|
|
}
|
|
foreach (KeyValuePair<string,bool> de in imports)
|
|
ns.Imports.Add (new CodeNamespaceImport(de.Key));
|
|
|
|
ns.Types.Add (cls);
|
|
unit.Namespaces.Add (ns);
|
|
}
|
|
|
|
string SanitizeResourceName (string name)
|
|
{
|
|
return name.Replace (' ', '_').Replace ('-', '_').Replace ('.', '_');
|
|
}
|
|
|
|
CodeObjectCreateExpression NewResourceManager (string name, string typename)
|
|
{
|
|
CodeExpression resname = new CodePrimitiveExpression (name);
|
|
CodePropertyReferenceExpression asm = new CodePropertyReferenceExpression (
|
|
new CodeTypeOfExpression (new CodeTypeReference (typename)),
|
|
"Assembly");
|
|
|
|
return new CodeObjectCreateExpression ("System.Resources.ResourceManager",
|
|
new CodeExpression [] {resname, asm});
|
|
}
|
|
|
|
void CodePropertyResourceManagerGet (CodeStatementCollection csc, string resfile, string typename)
|
|
{
|
|
string name = Path.GetFileNameWithoutExtension (resfile);
|
|
CodeStatement st;
|
|
CodeExpression exp;
|
|
|
|
exp = new CodeFieldReferenceExpression (new CodeTypeReferenceExpression (typename), "_resourceManager");
|
|
st = new CodeConditionStatement (
|
|
new CodeBinaryOperatorExpression (
|
|
exp,
|
|
CodeBinaryOperatorType.IdentityInequality,
|
|
new CodePrimitiveExpression (null)),
|
|
new CodeStatement [] { new CodeMethodReturnStatement (exp) });
|
|
csc.Add (st);
|
|
|
|
st = new CodeAssignStatement (exp, NewResourceManager (name, typename));
|
|
csc.Add (st);
|
|
csc.Add (new CodeMethodReturnStatement (exp));
|
|
}
|
|
|
|
void CodePropertyResourceGet (CodeStatementCollection csc, string resname, Type restype, string typename)
|
|
{
|
|
CodeStatement st = new CodeVariableDeclarationStatement (
|
|
typeof (ResourceManager),
|
|
"rm",
|
|
new CodePropertyReferenceExpression (
|
|
new CodeTypeReferenceExpression (typename), "ResourceManager"));
|
|
csc.Add (st);
|
|
|
|
st = new CodeConditionStatement (
|
|
new CodeBinaryOperatorExpression (
|
|
new CodeVariableReferenceExpression ("rm"),
|
|
CodeBinaryOperatorType.IdentityEquality,
|
|
new CodePrimitiveExpression (null)),
|
|
new CodeStatement [] { new CodeMethodReturnStatement (new CodePrimitiveExpression (null)) });
|
|
csc.Add (st);
|
|
|
|
bool gotstr = (restype == typeof (string));
|
|
CodeExpression exp = new CodeMethodInvokeExpression (
|
|
new CodeVariableReferenceExpression ("rm"),
|
|
gotstr ? "GetString" : "GetObject",
|
|
new CodeExpression [] { new CodePrimitiveExpression (resname),
|
|
new CodeFieldReferenceExpression (
|
|
new CodeTypeReferenceExpression (typename), "_culture") });
|
|
st = new CodeVariableDeclarationStatement (
|
|
restype,
|
|
"obj",
|
|
gotstr ? exp : new CodeCastExpression (restype, exp));
|
|
csc.Add (st);
|
|
csc.Add (new CodeMethodReturnStatement (new CodeVariableReferenceExpression ("obj")));
|
|
}
|
|
|
|
void CodePropertyGenericGet (CodeStatementCollection csc, string field, string typename)
|
|
{
|
|
csc.Add(new CodeMethodReturnStatement (
|
|
new CodeFieldReferenceExpression (
|
|
new CodeTypeReferenceExpression (typename), field)));
|
|
}
|
|
|
|
void CodePropertyGenericSet (CodeStatementCollection csc, string field, string typename)
|
|
{
|
|
csc.Add(new CodeAssignStatement (
|
|
new CodeFieldReferenceExpression (new CodeTypeReferenceExpression (typename), field),
|
|
new CodeVariableReferenceExpression ("value")));
|
|
}
|
|
|
|
string CompileResource (AppResourceFileInfo arfi, bool local)
|
|
{
|
|
string path = arfi.Info.FullName;
|
|
string rname = Path.GetFileNameWithoutExtension (path) + ".resources";
|
|
if (!local)
|
|
rname = "Resources." + rname;
|
|
|
|
string resource = Path.Combine (TempDirectory, rname);
|
|
FileStream source = null, destination = null;
|
|
IResourceReader reader = null;
|
|
ResourceWriter writer = null;
|
|
|
|
try {
|
|
source = new FileStream (path, FileMode.Open, FileAccess.Read);
|
|
destination = new FileStream (resource, FileMode.Create, FileAccess.Write);
|
|
reader = GetReaderForKind (arfi.Kind, source, path);
|
|
writer = new ResourceWriter (destination);
|
|
foreach (DictionaryEntry de in reader) {
|
|
object val = de.Value;
|
|
if (val is string)
|
|
writer.AddResource ((string)de.Key, (string)val);
|
|
else
|
|
writer.AddResource ((string)de.Key, val);
|
|
}
|
|
} catch (Exception ex) {
|
|
throw new HttpException ("Failed to compile resource file", ex);
|
|
} finally {
|
|
if (reader != null)
|
|
reader.Close ();
|
|
else if (source != null)
|
|
source.Close ();
|
|
if (writer != null)
|
|
writer.Close ();
|
|
else if (destination != null)
|
|
destination.Close ();
|
|
}
|
|
|
|
return resource;
|
|
}
|
|
|
|
IResourceReader GetReaderForKind (AppResourceFileKind kind, Stream stream, string path)
|
|
{
|
|
switch (kind) {
|
|
case AppResourceFileKind.ResX:
|
|
var ret = new ResXResourceReader (stream, new TypeResolutionService ());
|
|
if (!String.IsNullOrEmpty (path))
|
|
ret.BasePath = Path.GetDirectoryName (path);
|
|
return ret;
|
|
|
|
case AppResourceFileKind.Resource:
|
|
return new ResourceReader (stream);
|
|
|
|
default:
|
|
return null;
|
|
}
|
|
}
|
|
|
|
|
|
object OnCreateRandomFile (string path)
|
|
{
|
|
FileStream f = new FileStream (path, FileMode.CreateNew);
|
|
f.Close ();
|
|
return path;
|
|
}
|
|
};
|
|
};
|
|
#endif
|