public IEvaluator ReferenceDomainAssemblies(DomainAssemblies assemblies = DomainAssemblies.AllStaticNonGAC) #endif { //NOTE: It is important to avoid loading the runtime itself (mscorelib) as it //will break the code evaluation (compilation). // //On .NET mscorelib is filtered out by GlobalAssemblyCache check but //on Mono it passes through so there is a need to do a specific check for mscorelib assembly. var relevantAssemblies = AppDomain.CurrentDomain.GetAssemblies(); if (assemblies == DomainAssemblies.AllStatic) { relevantAssemblies = relevantAssemblies.Where(x => !CSSUtils.IsDynamic(x) && x != mscorelib).ToArray(); } else if (assemblies == DomainAssemblies.AllStaticNonGAC) { relevantAssemblies = relevantAssemblies.Where(x => !x.GlobalAssemblyCache && !CSSUtils.IsDynamic(x) && x != mscorelib).ToArray(); } else if (assemblies == DomainAssemblies.None) { relevantAssemblies = new Assembly[0]; } foreach (var asm in relevantAssemblies) { ReferenceAssembly(asm); } return(this); }
/// <summary> /// Creates the CompilerException instance from the specified compiler errors. /// </summary> /// <param name="Errors">The compiler errors.</param> /// <param name="hideCompilerWarnings">if set to <c>true</c> hide compiler warnings.</param> /// <param name="resolveAutogenFilesRefs">if set to <c>true</c> all references to the path of the derived auto-generated files /// (e.g. errors in the decorated classless scripts) will be replaced with the path of the original files (e.g. classless script itself).</param> /// <returns></returns> public static CompilerException Create(CompilerErrorCollection Errors, bool hideCompilerWarnings, bool resolveAutogenFilesRefs) { StringBuilder compileErr = new StringBuilder(); int errorCount = 0; foreach (CompilerError err in Errors) { if (!err.IsWarning) { errorCount++; } if (err.IsWarning && hideCompilerWarnings) { continue; } if (err.FileName.HasText()) { string file = err.FileName; int line = err.Line; if (resolveAutogenFilesRefs) { CSSUtils.NormaliseFileReference(ref file, ref line); } compileErr.Append(file); compileErr.Append("("); compileErr.Append(line); compileErr.Append(","); compileErr.Append(err.Column); compileErr.Append("): "); } else { compileErr.Append("BUILD: "); } if (err.IsWarning) { compileErr.Append("warning "); } else { compileErr.Append("error "); } compileErr.Append(err.ErrorNumber); compileErr.Append(": "); compileErr.Append(err.ErrorText); compileErr.Append(Environment.NewLine); } CompilerException retval = new CompilerException(compileErr.ToString()); retval.Data.Add("Errors", Errors); retval.ErrorCount = errorCount; return(retval); }
public SystemWideLock(string file, string context) { bool isLinux = (Environment.OSVersion.Platform == PlatformID.Unix); if (isLinux) { mutex = new LinuxSystemWideLock(file, context); } else { file = file.ToLower(CultureInfo.InvariantCulture); mutex = new WinSystemWideLock("" + context + "." + CSSUtils.GetHashCodeEx(file)); } }
public void ProcessFile() { packages.Clear(); referencedAssemblies.Clear(); referencedScripts.Clear(); referencedNamespaces.Clear(); referencedResources.Clear(); this.parser = new CSharpParser(fileName, true, null, this.searchDirs); foreach (CSharpParser.ImportInfo info in parser.Imports) { referencedScripts.Add(new ScriptInfo(info)); } referencedAssemblies.AddRange(parser.RefAssemblies); referencedNamespaces.AddRange(Utils.Except(parser.RefNamespaces, parser.IgnoreNamespaces)); referencedResources.AddRange(parser.ResFiles); if (imported) { if (prams != null) { parser.DoRenaming(prams.RenameNamespaceMap, prams.preserveMain); } if (parser.ModifiedCode == "") { fileNameImported = fileName; //importing does not require any modification of the original code } else { fileNameImported = Path.Combine(CSExecutor.ScriptCacheDir, string.Format("i_{0}_{1}{2}", Path.GetFileNameWithoutExtension(fileName), CSSUtils.GetHashCodeEx(Path.GetDirectoryName(fileName)), Path.GetExtension(fileName))); if (!Directory.Exists(Path.GetDirectoryName(fileNameImported))) { Directory.CreateDirectory(Path.GetDirectoryName(fileNameImported)); } if (File.Exists(fileNameImported)) { File.SetAttributes(fileNameImported, FileAttributes.Normal); Utils.FileDelete(fileNameImported, true); } using (StreamWriter scriptWriter = new StreamWriter(fileNameImported, false, Encoding.UTF8)) { //scriptWriter.Write(ComposeHeader(fileNameImported)); //using a big header at start is overkill (it also shifts line numbers so they do not match with the original script file) //but might be required in future scriptWriter.WriteLine(parser.ModifiedCode); scriptWriter.WriteLine("///////////////////////////////////////////"); scriptWriter.WriteLine("// Compiler-generated file - DO NOT EDIT!"); scriptWriter.WriteLine("///////////////////////////////////////////"); } File.SetAttributes(fileNameImported, FileAttributes.ReadOnly); } } }
static public Project GenerateProjectFor(string script) { // System.Diagnostics.Debug.Assert(false); // ******************************************************************************************** // * Extremely important to keep the project building algorithm in sync with CSExecutor.Compile // ******************************************************************************************** var project = new Project { Script = script }; var searchDirs = new List <string>(); searchDirs.Add(Path.GetDirectoryName(script)); var globalConfig = GetGlobalConfigItems(); var defaultSearchDirs = globalConfig.dirs; var defaultRefAsms = globalConfig.asms; var defaultNamespaces = globalConfig.namespaces; searchDirs.AddRange(defaultSearchDirs); ScriptParser parser; using (new CurrentDirGuard()) { Environment.CurrentDirectory = Path.GetDirectoryName(script); parser = new ScriptParser(script, searchDirs.ToArray(), false); } #if !class_lib CSExecutor.options.preCompilers = parser.Precompilers .Select(x => FileParser.ResolveFile(x, CSExecutor.options.searchDirs)) .AddItem(CSExecutor.options.preCompilers) .JoinBy(","); PrecompilationContext precompiling = CSSUtils.Precompile(script, parser.FilesToCompile.Distinct(), CSExecutor.options); #endif // search dirs could be also defined in the script var probingDirs = searchDirs.Concat(parser.SearchDirs) .Where(x => !string.IsNullOrEmpty(x)) .Distinct() .ToArray(); var sources = parser.SaveImportedScripts().ToList(); //this will also generate auto-scripts and save them sources.Insert(0, script); //if (parser.Packages.Any() && NotifyClient != null) //{ // NotifyClient("Processing NuGet packages..."); //} project.Files = sources.Distinct().Select <string, string>(PathExtensions.PathNormaliseSeparators).ToArray(); project.Refs = parser.AgregateReferences(probingDirs, defaultRefAsms, defaultNamespaces) .Select(PathExtensions.PathNormaliseSeparators) .ToArray(); #if !class_lib project.Refs = project.Refs.ConcatWith(precompiling.NewReferences); project.Files = project.Files.ConcatWith(precompiling.NewIncludes); #endif project.SearchDirs = probingDirs.Select <string, string>(PathExtensions.PathNormaliseSeparators).ToArray(); return(project); }
static int BuildHashSetValue(string assemblyName, string directory) { return(CSSUtils.GetHashCodeEx((assemblyName ?? "") + (directory ?? ""))); }
// UnitTest // Make Surrogate scenario to compile conditionally // + check and delete the exe before building // + set Appartment state // + update all ExecutionClients incliding csslib // + when starting remove css and //x args //+ try to solve limitations with console Input redurectionlimi //+ ensure launcher is not build when building dll/exe without execution public string BuildSurrogateLauncher(string scriptAssembly, string tragetFramework, CompilerParameters compilerParams, ApartmentState appartmentState, string consoleEncoding) { //Debug.Assert(false); #if !net4 throw new ApplicationException("Cannot build surrogate host application because this script engine is build against early version of CLR."); #else var provider = CodeDomProvider.CreateProvider("C#", new Dictionary <string, string> { { "CompilerVersion", tragetFramework } }); compilerParams.OutputAssembly = GetLauncherName(scriptAssembly); compilerParams.GenerateExecutable = true; compilerParams.GenerateInMemory = false; compilerParams.IncludeDebugInformation = false; try { Utils.FileDelete(compilerParams.OutputAssembly, true); } catch (Exception e) { throw new ApplicationException("Cannot build surrogate host application", e); } if (compilerParams.CompilerOptions != null) { compilerParams.CompilerOptions = compilerParams.CompilerOptions.Replace("/d:TRACE", "") .Replace("/d:DEBUG", ""); } if (!AppInfo.appConsole) { compilerParams.CompilerOptions += " /target:winexe"; } string refAssemblies = ""; string appartment = "[STAThread]"; if (appartmentState == ApartmentState.MTA) { appartment = "[" + appartmentState + "Thread]"; } else if (appartmentState == ApartmentState.Unknown) { appartment = ""; } foreach (string asm in compilerParams.ReferencedAssemblies) { if (File.Exists(asm)) //ignore GAC (not full path) assemblies { refAssemblies += Assembly.ReflectionOnlyLoadFrom(asm).FullName + ":" + asm + ";"; } } compilerParams.ReferencedAssemblies.Clear(); //it is important to remove all asms as they can have absolute path to the wrong CLR asms branch compilerParams.ReferencedAssemblies.Add("System.dll"); foreach (var item in compilerParams.ReferencedAssemblies) { Debug.WriteLine(item); } string setEncodingSatement = ""; if (string.Compare(consoleEncoding, Settings.DefaultEncodingName, true) != 0) { setEncodingSatement = "try { Console.OutputEncoding = System.Text.Encoding.GetEncoding(\"" + consoleEncoding + "\"); } catch {}"; } string code = launcherCode .Replace("${REF_ASSEMBLIES}", refAssemblies) .Replace("${APPARTMENT}", appartment) .Replace("${CONSOLE_ENCODING}", setEncodingSatement) .Replace("${ASM_MANE}", Path.GetFileName(scriptAssembly)); CompilerResults retval; compilerParams.IncludeDebugInformation = true; bool debugLauncher = false; if (debugLauncher) { compilerParams.CompilerOptions += " /d:DEBUG"; string launcherFile = Environment.ExpandEnvironmentVariables(@"C:\Users\%USERNAME%\Desktop\New folder\script.launcher.cs"); File.WriteAllText(launcherFile, code); retval = provider.CompileAssemblyFromFile(compilerParams, launcherFile); } else { retval = provider.CompileAssemblyFromSource(compilerParams, code); } foreach (CompilerError err in retval.Errors) { if (!err.IsWarning) { throw CompilerException.Create(retval.Errors, true, false); } } CSSUtils.SetTimestamp(compilerParams.OutputAssembly, scriptAssembly); return(compilerParams.OutputAssembly); #endif }
public SystemWideLock(string file, string context) { file = file.ToLower(CultureInfo.InvariantCulture); mutex = new WinSystemWideLock("" + context + "." + CSSUtils.GetHashCodeEx(file)); }
// UnitTest // Make Surrogate scenario to compile conditionally // + check and delete the exe before building // + set Appartment state // + update all ExecutionClients incliding csslib // + when starting remove css and //x args //+ try to solve limitations with console Input redurectionlimi //+ ensure launcher is not build when building dll/exe without execution public string BuildSurrogateLauncher(string scriptAssembly, string tragetFramework, CompilerParameters compilerParams, ApartmentState appartmentState) { //string #if !net4 throw new ApplicationException("Cannot build surrogate host application because this script engine is build against early version of CLR."); #else var provider = CodeDomProvider.CreateProvider("C#", new Dictionary <string, string> { { "CompilerVersion", tragetFramework } }); compilerParams.OutputAssembly = GetLauncherName(scriptAssembly); compilerParams.GenerateExecutable = true; compilerParams.GenerateInMemory = false; compilerParams.IncludeDebugInformation = false; try { if (File.Exists(compilerParams.OutputAssembly)) { File.Delete(compilerParams.OutputAssembly); } } catch (Exception e) { throw new ApplicationException("Cannot build surrogate host application", e); } if (compilerParams.CompilerOptions != null) { compilerParams.CompilerOptions = compilerParams.CompilerOptions.Replace("/d:TRACE", "") .Replace("/d:DEBUG", ""); } if (!AppInfo.appConsole) { compilerParams.CompilerOptions += " /target:winexe"; } string refAssemblies = ""; string appartment = "[STAThread]"; if (appartmentState == ApartmentState.MTA) { appartment = "[" + appartmentState + "Thread]"; } else if (appartmentState == ApartmentState.Unknown) { appartment = ""; } foreach (string asm in compilerParams.ReferencedAssemblies) { if (File.Exists(asm)) //ignore GAC (not full path) assemblies { refAssemblies += Assembly.ReflectionOnlyLoadFrom(asm).FullName + ":" + asm + ";"; } } string code = launcherCode .Replace("${REF_ASSEMBLIES}", refAssemblies) .Replace("${APPARTMENT}", appartment) .Replace("${ASM_MANE}", Path.GetFileName(scriptAssembly)); CompilerResults retval; bool debugLauncher = false; if (debugLauncher) { compilerParams.IncludeDebugInformation = true; compilerParams.CompilerOptions += " /d:DEBUG"; //string launcherFile = @"C:\Users\OSH\Desktop\New folder (2)\script.launcher.cs"; string launcherFile = Path.GetTempFileName(); File.WriteAllText(launcherFile, code); retval = provider.CompileAssemblyFromFile(compilerParams, launcherFile); } else { retval = provider.CompileAssemblyFromSource(compilerParams, code); } if (retval.Errors.Count != 0) { throw CompilerException.Create(retval.Errors, true); } CSSUtils.SetTimestamp(compilerParams.OutputAssembly, scriptAssembly); return(compilerParams.OutputAssembly); #endif }