private void ListSupportedLanguages()
{
// Loop through information about all compilers.
CompilerInfo[] compiler_infos =
CodeDomProvider.GetAllCompilerInfo();
foreach (CompilerInfo info in compiler_infos)
{
if (info.IsCodeDomProviderTypeValid)
{
// Get information about this compiler.
CodeDomProvider provider = info.CreateProvider();
//string extensions = "";
string default_extension = provider.FileExtension;
if (default_extension[0] != '.')
{
default_extension = '.' + default_extension;
}
string default_language =
CodeDomProvider.GetLanguageFromExtension(default_extension);
toolStripComboBoxLang.Items.Add(default_language);
}
}
if (toolStripComboBoxLang.Items.Count > 0)
{
toolStripComboBoxLang.SelectedIndex = 0;
}
}
private CompilerResults CompileScript(string filePath)
{
if (string.IsNullOrEmpty(filePath) || !File.Exists(filePath))
{
return(null);
}
var language = CodeDomProvider.GetLanguageFromExtension(Path.GetExtension(filePath));
//var codeDomProvider = CodeDomProvider.CreateProvider(language);
var codeDomProvider = new CSharpCodeProvider(new Dictionary <string, string> {
{ "CompilerVersion", "v4.0" }
});
var compilerParams = new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = true,
IncludeDebugInformation = false,
CompilerOptions = "/optimize"
};
Log.Info("Scripting", "Compiling :" + filePath);
foreach (AssemblyName an in Assembly.GetExecutingAssembly().GetReferencedAssemblies())
{
compilerParams.ReferencedAssemblies.Add(an.Name + ".dll");
}
compilerParams.ReferencedAssemblies.Add("WorldServer.exe");
return(codeDomProvider.CompileAssemblyFromFile(compilerParams, filePath));
}
// Quick and dirty compile to probe for metadata.
private Assembly CompileTextToAssembly(string script)
{
bool VB = script.IndexOf("Imports System") != -1;
string Language = CodeDomProvider.GetLanguageFromExtension(".cs");
if (VB)
{
Language = CodeDomProvider.GetLanguageFromExtension(".vb");
}
CodeDomProvider Provider = CodeDomProvider.CreateProvider(Language);
CompilerParameters Params = new CompilerParameters();
Params.GenerateInMemory = true; //Assembly is created in memory
Params.TempFiles = new TempFileCollection(Path.GetTempPath(), false);
Params.TreatWarningsAsErrors = false;
Params.WarningLevel = 2;
Params.ReferencedAssemblies.Add("System.dll");
Params.ReferencedAssemblies.Add("System.Xml.dll");
Params.ReferencedAssemblies.Add("System.Core.dll");
Params.ReferencedAssemblies.Add("System.Data.Linq.dll");
Params.ReferencedAssemblies.Add(Path.Combine(Configuration.ApsimBinDirectory(), "CSDotNetComponentInterface.dll"));
Params.ReferencedAssemblies.Add(Path.Combine(Configuration.ApsimBinDirectory(), "DotNetProxies.dll"));
Params.ReferencedAssemblies.Add(Path.Combine(Configuration.ApsimBinDirectory(), "CMPServices.dll"));
Params.ReferencedAssemblies.Add(Path.Combine(Configuration.ApsimBinDirectory(), "CSGeneral.dll"));
Params.TempFiles = new TempFileCollection(".");
Params.TempFiles.KeepFiles = false;
CompilerResults results = Provider.CompileAssemblyFromSource(Params, new string [] { script });
return(results.CompiledAssembly);
}
/// <summary>
/// Compile the specified 'code' into an executable assembly. If 'assemblyFileName'
/// is null then compile to an in-memory assembly.
/// </summary>
/// <param name="code">The code to compile.</param>
/// <param name="referencedAssemblies">Any referenced assemblies.</param>
/// <returns>Any compile errors or null if compile was successful.</returns>
private CompilerResults CompileTextToAssembly(string code, IEnumerable <string> referencedAssemblies = null)
{
if (provider == null)
{
provider = CodeDomProvider.CreateProvider(CodeDomProvider.GetLanguageFromExtension(".cs"));
}
var assemblyFileNameToCreate = Path.ChangeExtension(Path.Combine(Path.GetTempPath(), tempFileNamePrefix + Guid.NewGuid().ToString()), ".dll");
CompilerParameters parameters = new CompilerParameters
{
GenerateInMemory = false,
OutputAssembly = assemblyFileNameToCreate
};
string sourceFileName = Path.ChangeExtension(assemblyFileNameToCreate, ".cs");
File.WriteAllText(sourceFileName, code);
parameters.OutputAssembly = Path.ChangeExtension(assemblyFileNameToCreate, ".dll");
parameters.TreatWarningsAsErrors = false;
parameters.IncludeDebugInformation = true;
parameters.WarningLevel = 2;
foreach (var referencedAssembly in referencedAssemblies)
{
parameters.ReferencedAssemblies.Add(referencedAssembly);
}
parameters.TempFiles = new TempFileCollection(Path.GetTempPath()); // ensure that any temp files are in a writeable area
parameters.TempFiles.KeepFiles = false;
return(provider.CompileAssemblyFromFile(parameters, new string[] { sourceFileName }));
}
internal static IDictionary <string, string> GetProviderOptionsCollection(string fileExt)
{
Dictionary <string, string> opts = new Dictionary <string, string>();
if (!CodeDomProvider.IsDefinedExtension(fileExt))
{
return(new ReadOnlyDictionary <string, string>(opts));
}
CompilerInfo ci = CodeDomProvider.GetCompilerInfo(CodeDomProvider.GetLanguageFromExtension(fileExt));
if (ci == null)
{
return(new ReadOnlyDictionary <string, string>(opts));
}
// There is a fun little comment about this property in the framework code about making it
// public after 3.5. Guess that didn't happen. Oh well. :)
PropertyInfo pi = ci.GetType().GetProperty("ProviderOptions",
BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.IgnoreCase | BindingFlags.Instance);
if (pi == null)
{
return(new ReadOnlyDictionary <string, string>(opts));
}
return(new ReadOnlyDictionary <string, string>((IDictionary <string, string>)pi.GetValue(ci, null)));
}
internal CompilerType GetCompilerInfoFromExtension(string extension, bool throwOnFail)
{
CompilerType compilerTypeInternal;
this.EnsureCompilerCacheInit();
object obj2 = this._compilerExtensions[extension];
Compiler compiler = obj2 as Compiler;
if (compiler != null)
{
compilerTypeInternal = compiler.CompilerTypeInternal;
this._compilerExtensions[extension] = compilerTypeInternal;
}
else
{
compilerTypeInternal = obj2 as CompilerType;
}
if ((compilerTypeInternal == null) && CodeDomProvider.IsDefinedExtension(extension))
{
CompilerInfo compilerInfo = CodeDomProvider.GetCompilerInfo(CodeDomProvider.GetLanguageFromExtension(extension));
compilerTypeInternal = new CompilerType(compilerInfo.CodeDomProviderType, compilerInfo.CreateDefaultCompilerParameters());
this._compilerExtensions[extension] = compilerTypeInternal;
}
if (compilerTypeInternal == null)
{
if (throwOnFail)
{
throw new HttpException(System.Web.SR.GetString("Invalid_lang_extension", new object[] { extension }));
}
return(null);
}
compilerTypeInternal = compilerTypeInternal.Clone();
compilerTypeInternal.CompilerParameters.IncludeDebugInformation = this.Debug;
return(compilerTypeInternal);
}
public static Task CreateIn(CodeGeneratorContext context, string directoryFullName)
{
CodeGeneration_Story.CreateProjectFile(context);
if (!context.RequestHandlers.ContainsKey("AMAZON.StopIntent"))
{
CodeGeneration_Interaction.AddIntent(context, new List <string> {
"stop"
}, new CodeStatementCollection());
}
UpdatePipeline((CodeCompileUnit)context.OtherFiles["Pipeline.cs"], context.RequestHandlers.Keys.ToArray());
CodeGeneration_Fallback.Ensure(context);
var json = JsonSerializer.Create(new JsonSerializerSettings {
Formatting = Newtonsoft.Json.Formatting.Indented
});
using (var csharp = CodeDomProvider.CreateProvider(CodeDomProvider.GetLanguageFromExtension(".cs")))
{
var sceneFileDirectory = Path.Combine(directoryFullName, "Scenes");
var handlerFileDirectory = Path.Combine(directoryFullName, "RequestHandlers");
Directory.CreateDirectory(sceneFileDirectory);
Directory.CreateDirectory(handlerFileDirectory);
return(Task.WhenAll(
OutputRootFiles(context.OtherFiles, csharp, json, directoryFullName),
OutputSkillManifest(context, json, directoryFullName),
OutputSceneFiles(context.SceneFiles, csharp, sceneFileDirectory),
OutputRequestHandlers(context.RequestHandlers, csharp, handlerFileDirectory)
));
}
}
public void Roundtrip_Extension()
{
CodeDomProvider provider = GetProvider();
string ext = provider.FileExtension;
CodeDomProvider provider2 = CodeDomProvider.CreateProvider(CodeDomProvider.GetLanguageFromExtension(ext));
Assert.Equal(provider.GetType(), provider2.GetType());
}
public static void CompileProxyDLL()
{
// Go open the proxy source file and read it's contents.
StreamReader In = new StreamReader(WriteableBaseProxyFileName);
string Contents = In.ReadToEnd();
In.Close();
In = new StreamReader(Path.Combine(Configuration.ApsimBinDirectory(), "DotNetProxies", "Properties", "AssemblyInfo.cs"));
string AssemblyInfoContents = In.ReadToEnd();
In.Close();
In = new StreamReader(Path.Combine(Configuration.ApsimBinDirectory(), "Build", "VersionInfo.cs"));
string VersionInfoContents = In.ReadToEnd();
In.Close();
string language = CodeDomProvider.GetLanguageFromExtension(".cs");
CodeDomProvider provider = CodeDomProvider.CreateProvider(language);
if (provider != null)
{
CompilerParameters Params = new CompilerParameters();
Params.GenerateInMemory = false;
Params.CompilerOptions = "/platform:AnyCPU";
Params.OutputAssembly = Path.Combine(Configuration.ApsimBinDirectory(), "DotNetProxies.dll");
Params.TreatWarningsAsErrors = false;
Params.WarningLevel = 2;
Params.IncludeDebugInformation = true;
Params.ReferencedAssemblies.Add("System.dll");
Params.ReferencedAssemblies.Add(Path.Combine(Configuration.ApsimBinDirectory(), "CSDotNetComponentInterface.dll"));
Params.ReferencedAssemblies.Add(Path.Combine(Configuration.ApsimBinDirectory(), "CSGeneral.dll"));
Params.ReferencedAssemblies.Add(Path.Combine(Configuration.ApsimBinDirectory(), "ApsimFile.dll"));
String[] Source = new String[3];
Source[0] = Contents;
Source[1] = AssemblyInfoContents;
Source[2] = VersionInfoContents;
CompilerResults Results = provider.CompileAssemblyFromSource(Params, Source);
string Errors = "";
foreach (CompilerError err in Results.Errors)
{
if (Errors != "")
{
Errors += "\r\n";
}
Errors += err.ErrorText + ". Line number: " + err.Line.ToString();
}
if (Errors != "")
{
throw new Exception(Errors);
}
}
}
protected virtual CodeDomProvider GetCodeDomProvider(IArtifactLink link)
{
if (link is ArtifactLink)
{
return(CodeDomProvider.CreateProvider(
CodeDomProvider.GetLanguageFromExtension(((ArtifactLink)link).DefaultExtension)));
}
return(new CSharp.CSharpCodeProvider());
}
public static CodeDomProvider GetCodeDomProvider(EnvDTE.Project project)
{
if (project != null)
{
return
(CodeDomProvider.CreateProvider(CodeDomProvider.GetLanguageFromExtension(GetDefaultExtension(project))));
}
return(CodeDomProvider.CreateProvider("C#"));
}
protected byte[] EnsureSilverlighCompatibility(byte[] generatedCodeBytes, CodeCompileUnit codeCompileUnit)
{
if (null == generatedCodeBytes)
{
throw new ArgumentNullException("generatedCodeBytes");
}
if (null == codeCompileUnit)
{
throw new ArgumentNullException("codeCompileUnit");
}
StringBuilder generatedCode = new StringBuilder(Encoding.UTF8.GetString(generatedCodeBytes));
string compilerlanguage = CodeDomProvider.GetLanguageFromExtension(this.CodeProvider.FileExtension);
switch (compilerlanguage)
{
case "c#":
case "cs":
case "csharp":
Match csMatch = Regex.Match(generatedCode.ToString(), CSharpObfuscationAttributeFinderRegex);
if ((null != csMatch) && csMatch.Success)
{
generatedCode.Insert(csMatch.Index, CSharpCompilationDirectiveStart);
generatedCode.Insert(csMatch.Index + CSharpCompilationDirectiveStart.Length +
csMatch.Length, CSharpCompilationDirectiveEnd);
}
break;
case "vb":
case "visualbasic":
string className = codeCompileUnit.Namespaces[0].Types[0].Name;
Match vbMatch = Regex.Match(generatedCode.ToString(), string.Format(VBClassAttributesFinderRegexTemplate, className));
if ((null != vbMatch) && vbMatch.Success)
{
string fullClassAttributesAndDeclaration = vbMatch.Value;
Match obfuscationAttributeMatch = Regex.Match(fullClassAttributesAndDeclaration, VBObfuscationAttributeFinderRegex);
if ((null != obfuscationAttributeMatch) && obfuscationAttributeMatch.Success)
{
string silverlightClassAttributesAndDeclaration = fullClassAttributesAndDeclaration.Remove(obfuscationAttributeMatch.Index,
obfuscationAttributeMatch.Length);
generatedCode.Insert(vbMatch.Index, VBCompilationDirectiveStart);
string elseDirectiveAndSilverlightAttributes = VBCompilationDirectiveElse + silverlightClassAttributesAndDeclaration +
VBCompilationDirectiveEndIf;
generatedCode.Insert(vbMatch.Index + VBCompilationDirectiveStart.Length + vbMatch.Length, elseDirectiveAndSilverlightAttributes);
}
}
break;
default:
throw new ApplicationException(string.Format("The '{0}' language is not currently supported by the resource generator."));
}
return(Encoding.UTF8.GetBytes(generatedCode.ToString()));
}
/*
* Return a CompilerType that a extension maps to.
*/
internal CompilerType GetCompilerInfoFromExtension(string extension, bool throwOnFail)
{
EnsureCompilerCacheInit();
// First, try the cache (i.e. old <compilers> section)
CompilerType compilerType;
object obj = _compilerExtensions[extension];
Compiler compiler = obj as Compiler;
if (compiler != null)
{
compilerType = compiler.CompilerTypeInternal;
_compilerExtensions[extension] = compilerType;
}
else
{
compilerType = obj as CompilerType;
}
if (compilerType == null)
{
// If not, try the <codedom> section
if (CodeDomProvider.IsDefinedExtension(extension))
{
string language = CodeDomProvider.GetLanguageFromExtension(extension);
CompilerInfo ci = CodeDomProvider.GetCompilerInfo(language);
compilerType = new CompilerType(
ci.CodeDomProviderType, ci.CreateDefaultCompilerParameters());
// Cache it
_compilerExtensions[extension] = compilerType;
}
}
if (compilerType == null)
{
if (!throwOnFail)
{
return(null);
}
// Unsupported extension: throw an exception
throw new HttpException(SR.GetString(SR.Invalid_lang_extension, extension));
}
// Clone it so the original is not modified
compilerType = compilerType.Clone();
// Set the value of the debug flag in the copy
compilerType.CompilerParameters.IncludeDebugInformation = Debug;
return(compilerType);
}
internal static IDictionary <string, string> GetProviderOptions(Type codeDomProviderType)
{
CodeDomProvider provider = (CodeDomProvider)Activator.CreateInstance(codeDomProviderType);
string fileExtension = provider.FileExtension;
if (CodeDomProvider.IsDefinedExtension(fileExtension))
{
return(GetProviderOptions(CodeDomProvider.GetCompilerInfo(CodeDomProvider.GetLanguageFromExtension(fileExtension))));
}
return(null);
}
static void DisplayAllCompilerInfo()
{
// <Snippet8>
CompilerInfo [] allCompilerInfo = CodeDomProvider.GetAllCompilerInfo();
foreach (CompilerInfo info in allCompilerInfo)
{
String defaultLanguage;
String defaultExtension;
CodeDomProvider provider = info.CreateProvider();
// Display information about this configured provider.
Console.WriteLine("Language provider: {0}",
provider.ToString());
Console.WriteLine();
Console.WriteLine(" Supported file extension(s):");
foreach (String extension in info.GetExtensions())
{
Console.WriteLine(" {0}", extension);
}
defaultExtension = provider.FileExtension;
if (defaultExtension[0] != '.')
{
defaultExtension = "." + defaultExtension;
}
Console.WriteLine(" Default file extension: {0}",
defaultExtension);
Console.WriteLine();
Console.WriteLine(" Supported language(s):");
foreach (String language in info.GetLanguages())
{
Console.WriteLine(" {0}", language);
}
defaultLanguage = CodeDomProvider.GetLanguageFromExtension(defaultExtension);
Console.WriteLine(" Default language: {0}",
defaultLanguage);
Console.WriteLine();
// Get the compiler settings for this provider.
CompilerParameters langCompilerConfig = info.CreateDefaultCompilerParameters();
Console.WriteLine(" Compiler options: {0}",
langCompilerConfig.CompilerOptions);
Console.WriteLine(" Compiler warning level: {0}",
langCompilerConfig.WarningLevel);
Console.WriteLine();
}
// </Snippet8>
}
internal static IDictionary <string, string> GetProviderOptions(Type codeDomProviderType)
{
// Using reflection to get the property for the time being.
// This could simply return CompilerInfo.PropertyOptions if it goes public in future.
CodeDomProvider provider = (CodeDomProvider)Activator.CreateInstance(codeDomProviderType);
string extension = provider.FileExtension;
if (CodeDomProvider.IsDefinedExtension(extension))
{
CompilerInfo ci = CodeDomProvider.GetCompilerInfo(CodeDomProvider.GetLanguageFromExtension(extension));
return(GetProviderOptions(ci));
}
return(null);
}
static void DisplayCompilerInfoUsingExtension(string fileExtension)
{
// <Snippet5>
if (fileExtension[0] != '.')
{
fileExtension = "." + fileExtension;
}
// Get the language associated with the file extension.
if (CodeDomProvider.IsDefinedExtension(fileExtension))
{
CodeDomProvider provider;
String language = CodeDomProvider.GetLanguageFromExtension(fileExtension);
Console.WriteLine("The language \"{0}\" is associated with file extension \"{1}\"",
language, fileExtension);
Console.WriteLine();
// Next, check for a corresponding language provider.
if (CodeDomProvider.IsDefinedLanguage(language))
{
provider = CodeDomProvider.CreateProvider(language);
// Display information about this language provider.
Console.WriteLine("Language provider: {0}",
provider.ToString());
Console.WriteLine();
// Get the compiler settings for this language.
CompilerInfo langCompilerInfo = CodeDomProvider.GetCompilerInfo(language);
CompilerParameters langCompilerConfig = langCompilerInfo.CreateDefaultCompilerParameters();
Console.WriteLine(" Compiler options: {0}",
langCompilerConfig.CompilerOptions);
Console.WriteLine(" Compiler warning level: {0}",
langCompilerConfig.WarningLevel);
}
}
else
{
// Tell the user that the language provider was not found.
Console.WriteLine("There is no language provider associated with input file extension \"{0}\".",
fileExtension);
}
// </Snippet5>
}
public static Language GetLanguage(this CodeDomProvider codeDomProvider)
{
switch (CodeDomProvider.GetLanguageFromExtension(codeDomProvider.FileExtension).ToLowerInvariant( ))
{
case "c#":
case "cs":
case "csharp":
return(Language.CSharp);
case "vb":
case "visualbasic":
return(Language.VisualBasic);
default:
return(Language.Unknown);
}
}
void GenerateSource(bool isSupportedVersion, string filePath, AssemblyBuilder assemblyBuilder, WorkflowService workflowService, out string codeFileName, out bool generatedSource, out string activityName)
{
// Get unique file and type name for the workflowservice
codeFileName = assemblyBuilder.GetTempFilePhysicalPath(assemblyBuilder.CodeDomProvider.FileExtension);
if (isSupportedVersion)
{
activityName = WorkflowServiceHostFactory.GetSupportedVersionGeneratedTypeName(filePath);
}
else
{
activityName = workflowService.Name.LocalName + "_" + Guid.NewGuid().ToString().Replace("-", "_");
}
TextExpressionCompilerSettings settings = new TextExpressionCompilerSettings
{
Activity = workflowService.Body,
ActivityName = activityName,
ActivityNamespace = GeneratedNamespace,
Language = CodeDomProvider.GetLanguageFromExtension(assemblyBuilder.CodeDomProvider.FileExtension),
GenerateAsPartialClass = false,
AlwaysGenerateSource = false,
ForImplementation = false
};
TextExpressionCompiler compiler = new TextExpressionCompiler(settings);
generatedSource = false;
using (StreamWriter fileStream = new StreamWriter(codeFileName))
{
try
{
generatedSource = compiler.GenerateSource(fileStream);
}
catch (Exception ex)
{
if (Fx.IsFatal(ex))
{
throw;
}
throw FxTrace.Exception.AsError(new HttpCompileException(SR.XamlBuildProviderExtensionException(ex.Message)));
}
}
}
private CompilerResults CompileFile(string filepath)
{
string language = CodeDomProvider.GetLanguageFromExtension(Path.GetExtension(filepath));
CodeDomProvider codeDomProvider = CodeDomProvider.CreateProvider(language);
CompilerParameters compilerParams = new CompilerParameters
{
GenerateExecutable = false,
GenerateInMemory = true,
IncludeDebugInformation = false
};
compilerParams.ReferencedAssemblies.AddRange(
Assembly.GetExecutingAssembly().GetReferencedAssemblies().Select(a => a.Name + ".dll").ToArray()
);
compilerParams.ReferencedAssemblies.Add("ActiveDirectory.Connector.dll");
return(codeDomProvider.CompileAssemblyFromFile(compilerParams, filepath));
}
private CodeTypeReference GlobalSelfReference(string type)
{
if (CodeDomProvider.GetLanguageFromExtension(_codeDomProvider.FileExtension) == "vb")
{
if (!string.IsNullOrEmpty(_rootNamespace))
{
return(new CodeTypeReference(string.Join(".", new string[] { _rootNamespace, type }), CodeTypeReferenceOptions.GlobalReference));
}
else
{
return(GlobalReference(type));
}
}
else
{
return(GlobalReference(type));
}
}
public void Defaults()
{
cdp = new CodeDomProviderTest(); // execute ctor not a full trust
Assert.AreEqual(String.Empty, cdp.FileExtension, "FileExtension");
Assert.AreEqual(LanguageOptions.None, cdp.LanguageOptions, "LanguageOptions");
Assert.IsNull(cdp.CreateCompiler(), "CreateCompiler");
Assert.IsNull(cdp.CreateGenerator(), "CreateGenerator");
Assert.IsNull(cdp.CreateGenerator(String.Empty), "CreateGenerator(string)");
Assert.IsNull(cdp.CreateGenerator(writer), "CreateGenerator(TextWriter)");
Assert.IsNull(cdp.CreateParser(), "CreateParser()");
Assert.IsNotNull(cdp.GetConverter(typeof(string)), "GetConverter");
Assert.IsNotNull(CodeDomProvider.GetAllCompilerInfo(), "GetAllCompilerInfo");
// mono returns null (missing config?)
CodeDomProvider.GetCompilerInfo("cs");
CodeDomProvider.GetLanguageFromExtension("cs");
Assert.IsFalse(CodeDomProvider.IsDefinedExtension(String.Empty), "String.Empty");
Assert.IsFalse(CodeDomProvider.IsDefinedLanguage(String.Empty), "String.Empty");
}
public Type[] GetScripts(string path)
{
string[] files = Directory.GetFiles(path, "*.*", SearchOption.AllDirectories);
string language = CodeDomProvider.GetLanguageFromExtension(Path.GetExtension(files[0]));
CodeDomProvider codeDomProvider = CodeDomProvider.CreateProvider(language);
var compilerParams = GetCompilerParameters();
CompilerResults results = codeDomProvider.CompileAssemblyFromFile(compilerParams,
files);
if (NotifyErrors(results))
{
Console.Read();
return(new Type[0]);
}
else
{
return(results.CompiledAssembly.GetTypes());
}
}
public override bool Execute()
{
// In Xamarin Studio, if the project name isn't a valid C# identifier
// then $(RootNamespace) is not set, and the generated Activity is
// placed into the "Application" namespace. VS just munges the project
// name to be a valid C# identifier.
// Use "Application" as the default namespace name to work with XS.
Namespace = Namespace ?? "Application";
Log.LogDebugMessage("GenerateResourceDesigner Task");
Log.LogDebugMessage(" NetResgenOutputFile: {0}", NetResgenOutputFile);
Log.LogDebugMessage(" JavaResgenInputFile: {0}", JavaResgenInputFile);
Log.LogDebugMessage(" Namespace: {0}", Namespace);
Log.LogDebugMessage(" ResourceDirectory: {0}", ResourceDirectory);
Log.LogDebugTaskItemsAndLogical(" AdditionalResourceDirectories:", AdditionalResourceDirectories);
Log.LogDebugMessage(" IsApplication: {0}", IsApplication);
Log.LogDebugMessage(" UseManagedResourceGenerator: {0}", UseManagedResourceGenerator);
Log.LogDebugTaskItemsAndLogical(" Resources:", Resources);
Log.LogDebugTaskItemsAndLogical(" References:", References);
if (!File.Exists(JavaResgenInputFile) && !UseManagedResourceGenerator)
{
return(true);
}
// ResourceDirectory may be a relative path, and
// we need to compare it to absolute paths
ResourceDirectory = Path.GetFullPath(ResourceDirectory);
// Create our capitalization maps so we can support mixed case resources
foreach (var item in Resources)
{
if (!item.ItemSpec.StartsWith(ResourceDirectory))
{
continue;
}
var name = item.ItemSpec.Substring(ResourceDirectory.Length);
var logical_name = item.GetMetadata("LogicalName").Replace('\\', '/');
AddRename(name.Replace('/', Path.DirectorySeparatorChar), logical_name.Replace('/', Path.DirectorySeparatorChar));
}
if (AdditionalResourceDirectories != null)
{
foreach (var additionalDir in AdditionalResourceDirectories)
{
var file = Path.Combine(ProjectDir, Path.GetDirectoryName(additionalDir.ItemSpec), "__res_name_case_map.txt");
if (File.Exists(file))
{
foreach (var line in File.ReadAllLines(file).Where(l => !string.IsNullOrEmpty(l)))
{
string [] tok = line.Split(';');
AddRename(tok [1].Replace('/', Path.DirectorySeparatorChar), tok [0].Replace('/', Path.DirectorySeparatorChar));
}
}
}
}
// Parse out the resources from the R.java file
CodeTypeDeclaration resources;
if (UseManagedResourceGenerator)
{
var parser = new ManagedResourceParser()
{
Log = Log
};
resources = parser.Parse(ResourceDirectory, AdditionalResourceDirectories?.Select(x => x.ItemSpec), IsApplication, resource_fixup);
}
else
{
var parser = new JavaResourceParser()
{
Log = Log
};
resources = parser.Parse(JavaResgenInputFile, IsApplication, resource_fixup);
}
var extension = Path.GetExtension(NetResgenOutputFile);
var language = string.Compare(extension, ".fs", StringComparison.OrdinalIgnoreCase) == 0 ? "F#" : CodeDomProvider.GetLanguageFromExtension(extension);
bool isVB = string.Equals(extension, ".vb", StringComparison.OrdinalIgnoreCase);
bool isFSharp = string.Equals(language, "F#", StringComparison.OrdinalIgnoreCase);
bool isCSharp = string.Equals(language, "C#", StringComparison.OrdinalIgnoreCase);
// Let VB put this in the default namespace
if (isVB)
{
Namespace = string.Empty;
}
// Create static resource overwrite methods for each Resource class in libraries.
var assemblyNames = new List <string> ();
if (IsApplication && References != null && References.Any())
{
// FIXME: should this be unified to some better code with ResolveLibraryProjectImports?
using (var resolver = new DirectoryAssemblyResolver(this.CreateTaskLogger(), loadDebugSymbols: false)) {
foreach (var assemblyName in References)
{
var suffix = assemblyName.ItemSpec.EndsWith(".dll") ? String.Empty : ".dll";
string hintPath = assemblyName.GetMetadata("HintPath").Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
string fileName = assemblyName.ItemSpec + suffix;
string fullPath = Path.GetFullPath(assemblyName.ItemSpec);
// Skip non existing files in DesignTimeBuild
if (!File.Exists(fullPath) && DesignTimeBuild)
{
Log.LogDebugMessage("Skipping non existant dependancy '{0}' due to design time build.", fullPath);
continue;
}
resolver.Load(fullPath);
if (!String.IsNullOrEmpty(hintPath) && !File.Exists(hintPath)) // ignore invalid HintPath
{
hintPath = null;
}
string assemblyPath = String.IsNullOrEmpty(hintPath) ? fileName : hintPath;
if (MonoAndroidHelper.IsFrameworkAssembly(fileName) && !MonoAndroidHelper.FrameworkEmbeddedJarLookupTargets.Contains(Path.GetFileName(fileName)))
{
continue;
}
Log.LogDebugMessage("Scan assembly {0} for resource generator", fileName);
assemblyNames.Add(assemblyPath);
}
var assemblies = assemblyNames.Select(assembly => resolver.GetAssembly(assembly));
new ResourceDesignerImportGenerator(Namespace, resources, Log)
.CreateImportMethods(assemblies);
}
}
AdjustConstructor(isFSharp, resources);
foreach (var member in resources.Members)
{
if (member is CodeTypeDeclaration)
{
AdjustConstructor(isFSharp, (CodeTypeDeclaration)member);
}
}
// Write out our Resources.Designer.cs file
WriteFile(NetResgenOutputFile, resources, language, isFSharp, isCSharp);
return(!Log.HasLoggedErrors);
}
static CompilerInfo GetCompilerInfo(string name)
{
return(CodeDomProvider.GetCompilerInfo(
CodeDomProvider.GetLanguageFromExtension(Path.GetExtension(name))));
}
/// <summary>
/// Compile the specified 'code' into an executable assembly. If 'assemblyFileName'
/// is null then compile to an in-memory assembly.
/// </summary>
public static Assembly CompileTextToAssembly(string code, string assemblyFileName)
{
// See if we've already compiled this code. If so then return the assembly.
if (AssemblyCache.ContainsKey(code))
{
return(AssemblyCache[code]);
}
lock (AssemblyCache)
{
if (AssemblyCache.ContainsKey(code))
{
return(AssemblyCache[code]);
}
bool VB = code.IndexOf("Imports System") != -1;
string Language;
if (VB)
{
Language = CodeDomProvider.GetLanguageFromExtension(".vb");
}
else
{
Language = CodeDomProvider.GetLanguageFromExtension(".cs");
}
if (Language != null && CodeDomProvider.IsDefinedLanguage(Language))
{
CodeDomProvider Provider = CodeDomProvider.CreateProvider(Language);
if (Provider != null)
{
CompilerParameters Params = new CompilerParameters();
string[] source = new string[1];
if (assemblyFileName == null)
{
Params.GenerateInMemory = true;
source[0] = code;
}
else
{
Params.GenerateInMemory = false;
Params.OutputAssembly = assemblyFileName;
string sourceFileName;
if (VB)
{
sourceFileName = Path.ChangeExtension(assemblyFileName, ".vb");
}
else
{
sourceFileName = Path.ChangeExtension(assemblyFileName, ".cs");
}
File.WriteAllText(sourceFileName, code);
source[0] = sourceFileName;
}
Params.TreatWarningsAsErrors = false;
Params.IncludeDebugInformation = true;
Params.WarningLevel = 2;
Params.ReferencedAssemblies.Add("System.dll");
Params.ReferencedAssemblies.Add("System.Xml.dll");
Params.ReferencedAssemblies.Add("System.Windows.Forms.dll");
Params.ReferencedAssemblies.Add("System.Data.dll");
Params.ReferencedAssemblies.Add("System.Core.dll");
//Params.ReferencedAssemblies.Add("APSIM.Shared.dll");
Params.ReferencedAssemblies.Add(System.IO.Path.Combine(Assembly.GetExecutingAssembly().Location));
if (Assembly.GetCallingAssembly() != Assembly.GetExecutingAssembly())
{
Params.ReferencedAssemblies.Add(System.IO.Path.Combine(Assembly.GetCallingAssembly().Location));
}
Params.TempFiles = new TempFileCollection(Path.GetTempPath()); // ensure that any temp files are in a writeable area
Params.TempFiles.KeepFiles = false;
CompilerResults results;
if (assemblyFileName == null)
{
results = Provider.CompileAssemblyFromSource(Params, source);
}
else
{
results = Provider.CompileAssemblyFromFile(Params, source);
}
string Errors = "";
foreach (CompilerError err in results.Errors)
{
if (Errors != "")
{
Errors += "\r\n";
}
Errors += err.ErrorText + ". Line number: " + err.Line.ToString();
}
if (Errors != "")
{
throw new Exception(Errors);
}
AssemblyCache.Add(code, results.CompiledAssembly);
return(results.CompiledAssembly);
}
}
throw new Exception("Cannot compile manager script to an assembly");
}
}
public Assembly Compile(bool debug, string languageOrExtension, params string[] sourceCode)
{
CodeDomProvider provider;
CompilerParameters parameters;
CompilerResults results;
string language = languageOrExtension;
if (!CodeDomProvider.IsDefinedLanguage(languageOrExtension) && CodeDomProvider.IsDefinedExtension(languageOrExtension))
{
language = CodeDomProvider.GetLanguageFromExtension(languageOrExtension);
}
if (ConfigurationManager.GetSection("system.codedom") != null)
{
CompilerInfo compilerInfo = CodeDomProvider.GetCompilerInfo(language);
provider = compilerInfo.CreateProvider();
parameters = compilerInfo.CreateDefaultCompilerParameters();
}
else
{
if ((!language.Equals("c#", StringComparison.OrdinalIgnoreCase) && !language.Equals("cs", StringComparison.OrdinalIgnoreCase)) && !language.Equals("csharp", StringComparison.OrdinalIgnoreCase))
{
throw new CompilerException(string.Format("When running the {0} in an AppDomain without a system.codedom config section only the csharp language is supported. This happens if you are precompiling your views.", typeof(BatchCompiler).FullName));
}
string compilerVersion = GetCompilerVersion();
Dictionary <string, string> dictionary2 = new Dictionary <string, string>();
dictionary2.Add("CompilerVersion", compilerVersion);
Dictionary <string, string> providerOptions = dictionary2;
provider = new CSharpCodeProvider(providerOptions);
parameters = new CompilerParameters();
}
parameters.TreatWarningsAsErrors = false;
string fileExtension = provider.FileExtension;
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
if (!assembly.IsDynamic())
{
parameters.ReferencedAssemblies.Add(assembly.Location);
}
}
string tempDir = AppDomain.CurrentDomain.SetupInformation.DynamicBase ?? Path.GetTempPath();
parameters.TempFiles = new TempFileCollection(tempDir);
if (debug)
{
parameters.IncludeDebugInformation = true;
string str5 = Path.Combine(tempDir, Guid.NewGuid().ToString("n"));
List <string> list = new List <string>();
int num = 0;
foreach (string str6 in sourceCode)
{
num++;
string path = string.Concat(new object[] { str5, "-", num, ".", fileExtension });
using (FileStream stream = new FileStream(path, FileMode.Create, FileAccess.Write))
{
using (StreamWriter writer = new StreamWriter(stream))
{
writer.Write(str6);
}
}
list.Add(path);
}
if (!string.IsNullOrEmpty(this.OutputAssembly))
{
parameters.OutputAssembly = Path.Combine(tempDir, this.OutputAssembly);
}
else
{
parameters.OutputAssembly = str5 + ".dll";
}
results = provider.CompileAssemblyFromFile(parameters, list.ToArray());
}
else
{
if (!string.IsNullOrEmpty(this.OutputAssembly))
{
parameters.OutputAssembly = Path.Combine(tempDir, this.OutputAssembly);
}
else
{
parameters.GenerateInMemory = true;
}
results = provider.CompileAssemblyFromSource(parameters, sourceCode);
}
if (!results.Errors.HasErrors)
{
return(results.CompiledAssembly);
}
StringBuilder builder = new StringBuilder();
builder.AppendLine("Dynamic view compilation failed.");
foreach (CompilerError error in results.Errors)
{
builder.AppendFormat("{4}({0},{1}): {2} {3}: ", new object[] { error.Line, error.Column, error.IsWarning ? "warning" : "error", error.ErrorNumber, error.FileName });
builder.AppendLine(error.ErrorText);
}
builder.AppendLine();
foreach (string str8 in sourceCode)
{
using (StringReader reader = new StringReader(str8))
{
int num2 = 1;
while (true)
{
string str9 = reader.ReadLine();
if (str9 != null)
{
builder.Append(num2).Append(' ').AppendLine(str9);
num2++;
}
}
}
}
throw new BatchCompilerException(builder.ToString(), results);
}
public override bool RunTask()
{
// In Xamarin Studio, if the project name isn't a valid C# identifier
// then $(RootNamespace) is not set, and the generated Activity is
// placed into the "Application" namespace. VS just munges the project
// name to be a valid C# identifier.
// Use "Application" as the default namespace name to work with XS.
Namespace = Namespace ?? "Application";
if (!File.Exists(JavaResgenInputFile) && !UseManagedResourceGenerator)
{
return(true);
}
// ResourceDirectory may be a relative path, and
// we need to compare it to absolute paths
ResourceDirectory = Path.GetFullPath(ResourceDirectory);
var javaPlatformDirectory = Path.GetDirectoryName(JavaPlatformJarPath);
// Create our capitalization maps so we can support mixed case resources
foreach (var item in Resources)
{
if (!item.ItemSpec.StartsWith(ResourceDirectory))
{
continue;
}
var name = item.ItemSpec.Substring(ResourceDirectory.Length);
var logical_name = item.GetMetadata("LogicalName").Replace('\\', '/');
AddRename(name.Replace('/', Path.DirectorySeparatorChar), logical_name.Replace('/', Path.DirectorySeparatorChar));
}
if (AdditionalResourceDirectories != null)
{
foreach (var additionalDir in AdditionalResourceDirectories)
{
var file = Path.Combine(ProjectDir, Path.GetDirectoryName(additionalDir.ItemSpec), "__res_name_case_map.txt");
if (File.Exists(file))
{
foreach (var line in File.ReadAllLines(file).Where(l => !string.IsNullOrEmpty(l)))
{
string [] tok = line.Split(';');
AddRename(tok [1].Replace('/', Path.DirectorySeparatorChar), tok [0].Replace('/', Path.DirectorySeparatorChar));
}
}
}
}
// Parse out the resources from the R.java file
CodeTypeDeclaration resources;
if (UseManagedResourceGenerator)
{
var parser = new ManagedResourceParser()
{
Log = Log, JavaPlatformDirectory = javaPlatformDirectory, ResourceFlagFile = ResourceFlagFile
};
resources = parser.Parse(ResourceDirectory, AdditionalResourceDirectories?.Select(x => x.ItemSpec), IsApplication, resource_fixup);
}
else
{
var parser = new JavaResourceParser()
{
Log = Log
};
resources = parser.Parse(JavaResgenInputFile, IsApplication, resource_fixup);
}
var extension = Path.GetExtension(NetResgenOutputFile);
var language = string.Compare(extension, ".fs", StringComparison.OrdinalIgnoreCase) == 0 ? "F#" : CodeDomProvider.GetLanguageFromExtension(extension);
bool isVB = string.Equals(extension, ".vb", StringComparison.OrdinalIgnoreCase);
bool isFSharp = string.Equals(language, "F#", StringComparison.OrdinalIgnoreCase);
bool isCSharp = string.Equals(language, "C#", StringComparison.OrdinalIgnoreCase);
if (isFSharp)
{
language = "C#";
isCSharp = true;
NetResgenOutputFile = Path.ChangeExtension(NetResgenOutputFile, ".cs");
}
// Let VB put this in the default namespace
if (isVB)
{
Namespace = string.Empty;
}
List <string> aliases = new List <string> ();
// Create static resource overwrite methods for each Resource class in libraries.
if (IsApplication && References != null && References.Length > 0)
{
var assemblies = new List <ITaskItem> (References.Length);
foreach (var assembly in References)
{
var assemblyPath = assembly.ItemSpec;
var fileName = Path.GetFileName(assemblyPath);
if (MonoAndroidHelper.IsFrameworkAssembly(fileName) &&
!MonoAndroidHelper.FrameworkEmbeddedJarLookupTargets.Contains(fileName))
{
Log.LogDebugMessage($"Skipping framework assembly '{fileName}'.");
continue;
}
if (!File.Exists(assemblyPath))
{
Log.LogDebugMessage($"Skipping non-existent dependency '{assemblyPath}'.");
continue;
}
ITaskItem item = new TaskItem(assemblyPath);
assembly.CopyMetadataTo(item);
assemblies.Add(item);
string aliasMetaData = assembly.GetMetadata("Aliases");
if (!string.IsNullOrEmpty(aliasMetaData))
{
foreach (var alias in aliasMetaData.Split(new [] { ',' }, StringSplitOptions.RemoveEmptyEntries))
{
string aliasName = alias.Trim();
// don't emit an `extern alias global` as it is implicitly done.
if (string.Compare("global", aliasName, StringComparison.Ordinal) == 0)
{
continue;
}
aliases.Add(aliasName);
// only add the first alias for each reference.
break;
}
}
Log.LogDebugMessage("Scan assembly {0} for resource generator", fileName);
}
new ResourceDesignerImportGenerator(Namespace, resources, Log)
.CreateImportMethods(assemblies);
}
AdjustConstructor(resources);
foreach (var member in resources.Members)
{
if (member is CodeTypeDeclaration)
{
AdjustConstructor((CodeTypeDeclaration)member);
}
}
// Write out our Resources.Designer.cs file
WriteFile(NetResgenOutputFile, resources, language, isCSharp, aliases);
return(!Log.HasLoggedErrors);
}
static CompilerInfo GetCSharpCompilerInfo()
{
return(CodeDomProvider.GetCompilerInfo(CodeDomProvider.GetLanguageFromExtension(".cs")));
}
private static string GetLanguageFromExtension(string file)
{
return(CodeDomProvider.GetLanguageFromExtension(Path.GetExtension(file)));
}