public static string Fetch(Configuration.Library library) { string targetPath; log.Info("Fetching library " + library.Name + " from " + library.Uri); using (var client = new WebClient()) { var zipPath = Path.Combine(Core.BaseDirectory, $"deps/{library.Name}.zip"); if (!File.Exists(zipPath)) { client.DownloadFile(library.Uri, zipPath); } targetPath = $"Scripts/{library.Name}"; if (Directory.Exists(targetPath)) { Directory.Delete(targetPath, recursive: true); } ZipFile.ExtractToDirectory(zipPath, targetPath); } return(targetPath); }
public Library(Configuration.Library libConfig, Assembly assembly) { Name = libConfig.Name; Assembly = assembly; Assembly.GetTypes(); Types = Assembly.GetTypes().Where(type => !libConfig.GetIgnoreType(type)).ToArray(); TypesByName = new TypeTable(Types.Length); TypesByFullName = new TypeTable(Types.Length); foreach (var type in Types) { TypesByName.Add(type.Name, type); TypesByFullName.Add(type.FullName, type); if (type.IsDefined(typeof(TypeAliasAttribute), false)) { var attrs = type.GetCustomAttributes(typeof(TypeAliasAttribute), false); if (attrs.Length > 0 && attrs[0] != null) { var attr = attrs[0] as TypeAliasAttribute; foreach (var alias in attr.Aliases) { TypesByFullName.Add(alias, type); } } } } TypeCache = new TypeCache(Types, TypesByName, TypesByFullName); }
private static void GetScripts(Configuration.Library libConfig, Hashtable list, string path, string type) { foreach (string dir in Directory.GetDirectories(path)) { string baseName = Path.GetFileName(dir).ToLower(); for (int i = 0; i < m_IgnoreNames.Length; i++) { if (baseName == m_IgnoreNames[i]) { continue; } } GetScripts(libConfig, list, dir, type); } foreach (string filename in Directory.GetFiles(path, type)) { // Pass relative filename only. if (libConfig == null || !libConfig.GetIgnoreSource(filename)) { list[filename] = File.GetLastWriteTime(filename); } } }
private static Hashtable GetScripts(Configuration.Library libConfig, string type) { Hashtable list = new Hashtable(); GetScripts(libConfig, list, libConfig.SourcePath.FullName, type); return(list); }
private static Dictionary <string, DateTime> GetScripts(Configuration.Library libConfig, string type) { var sourceCodeFileProvider = new SourceCodeFileProvider(libConfig, type); var files = sourceCodeFileProvider.ProvideSources(); return(files); }
private static Hashtable GetScripts(Configuration.Library libConfig, IEnumerable overlays, string type) { Hashtable files = GetScripts(libConfig, type); if (overlays != null) { foreach (Configuration.Library overlay in overlays) { Hashtable files2 = GetScripts(overlay, type); Overlay(libConfig.SourcePath.FullName, files, overlay.SourcePath.FullName, files2); } } return(files); }
public Library(Configuration.Library libConfig, Assembly assembly) { m_Name = libConfig.Name; m_Assembly = assembly; m_Assembly.GetTypes(); List <Type> typeList = new List <Type>(); foreach (Type type in m_Assembly.GetTypes()) { if (libConfig == null || !libConfig.GetIgnoreType(type)) { typeList.Add(type); } } m_Types = typeList.ToArray(); m_TypesByName = new TypeTable(m_Types.Length); m_TypesByFullName = new TypeTable(m_Types.Length); foreach (Type type in m_Types) { m_TypesByName.Add(type.Name, type); m_TypesByFullName.Add(type.FullName, type); if (type.IsDefined(typeof(TypeAliasAttribute), false)) { object[] attrs = type.GetCustomAttributes(typeof(TypeAliasAttribute), false); if (attrs != null && attrs.Length > 0 && attrs[0] != null) { TypeAliasAttribute attr = attrs[0] as TypeAliasAttribute; foreach (string alias in attr.Aliases) { m_TypesByFullName.Add(alias, type); } } } } m_TypeCache = new TypeCache(m_Types, m_TypesByName, m_TypesByFullName); }
private static ArrayList SortLibrariesByDepends() { ArrayList libs = new ArrayList(Environment.Config.Libraries); Hashtable queue = new Hashtable(); ArrayList dst = new ArrayList(); // Handle distro first, for most compatibility. Configuration.Library libConfig = Environment.Config.GetLibrary("distro"); if (libConfig != null) { EnqueueLibrary(dst, libs, queue, libConfig); } while (libs.Count > 0) { EnqueueLibrary(dst, libs, queue, (Configuration.Library)libs[0]); } return(dst); }
public SourceCodeFileProvider(Configuration.Library libConfig, string type) { m_LibraryConfig = libConfig; m_Type = type; }
public static bool Compile(bool debug) { if (m_AdditionalReferences != null) { throw new ApplicationException("already compiled"); } m_AdditionalReferences = new List <string>(); m_Libraries = new List <Library>(); m_Libraries.Add(new Library(Environment.Config.GetLibrary("core"), Environment.Assembly)); // Prepare overlays. foreach (Configuration.Library libConfig in Environment.Config.Libraries) { if (libConfig.Overlays == null || !libConfig.Exists || libConfig.Name == "core") { continue; } if (libConfig.SourcePath == null) { Console.WriteLine("Error: Can't overlay the binary library {0}", libConfig.Name); throw new ApplicationException(); } foreach (string name in libConfig.Overlays) { Configuration.Library overlay = Environment.Config.GetLibrary(name); if (overlay == null || !overlay.Exists) { Console.WriteLine("Error: Can't overlay {0} with {1}, because it does not exist", libConfig.Name, name); throw new ApplicationException(); } if (overlay.SourcePath == null) { Console.WriteLine("Error: Can't overlay {0} with {1}, because it is binary only", libConfig.Name, overlay.Name); throw new ApplicationException(); } overlay.Disabled = true; } } foreach (Configuration.Library libConfig in Environment.Config.Libraries) { if (libConfig.Overlays != null && libConfig.Exists && libConfig.Name != "core" && libConfig.Disabled) { Console.WriteLine("Error: Can't overlay library {0} which is already used as overlay for another library", libConfig.Name); throw new ApplicationException(); } } // Collect Config.Library objects, sort them and compile. ArrayList libConfigs = SortLibrariesByDepends(); foreach (Configuration.Library libConfig in libConfigs) { bool result = Compile(libConfig, debug); if (!result) { return(false); } } // Delete unused cache directories. DirectoryInfo cacheDir = new DirectoryInfo(Environment.Config.CacheDirectory); foreach (DirectoryInfo sub in cacheDir.GetDirectories()) { string libName = sub.Name.ToLower(); if (GetLibrary(libName) == null) { sub.Delete(true); } } return(true); }
/// <summary> /// Enqueue a library for compilation, resolving all dependencies first. /// </summary> /// <param name="dst">This array will receive the libraries in the correct order.</param> /// <param name="libs">Source libraries.</param> /// <param name="queue">Somewhat like a stack of libraries currently waiting.</param> /// <param name="libConfig">The library to be added.</param> private static void EnqueueLibrary(ArrayList dst, ArrayList libs, Hashtable queue, Configuration.Library libConfig) { string[] depends = libConfig.Depends; if (libConfig.Name == "core" || libConfig.Disabled) { libs.Remove(libConfig); return; } if (!libConfig.Exists) { libs.Remove(libConfig); Console.WriteLine("Warning: library {0} does not exist", libConfig.Name); return; } /* first resolve dependencies */ if (depends != null) { queue[libConfig.Name] = 1; foreach (string depend in depends) { /* if the depended library is already in the * queue, there is a circular dependency */ if (queue.ContainsKey(depend)) { Console.WriteLine("Error: Circular library dependency {0} on {1}", libConfig.Name, depend); throw new ApplicationException(); } Configuration.Library next = Environment.Config.GetLibrary(depend); if (next == null || !next.Exists) { Console.WriteLine("Error: Unresolved library dependency: {0} depends on {1}, which does not exist", libConfig.Name, depend); throw new ApplicationException(); } if (next.Disabled) { Console.WriteLine("Error: Unresolved library dependency: {0} depends on {1}, which is disabled", libConfig.Name, depend); throw new ApplicationException(); } if (!dst.Contains(next)) { EnqueueLibrary(dst, libs, queue, next); } } queue.Remove(libConfig.Name); } /* then add it to 'dst' */ dst.Add(libConfig); libs.Remove(libConfig); }
private static bool Compile(Configuration.Library libConfig, bool debug) { // Check if there is source code for this library. if (libConfig.SourcePath == null) { if (libConfig.BinaryPath == null) { Console.WriteLine("Warning: library {0} does not exist", libConfig.Name); return(true); } else if (!libConfig.BinaryPath.Exists) { Console.WriteLine("Warning: library {0} does not exist: {1}", libConfig.Name, libConfig.BinaryPath); return(false); } Console.WriteLine("Libraries: Loading library {0}", libConfig.Name); m_Libraries.Add(new Library(libConfig, Assembly.LoadFrom(libConfig.BinaryPath.FullName))); m_AdditionalReferences.Add(libConfig.BinaryPath.FullName); return(true); } else if (!libConfig.SourcePath.Exists) { Console.WriteLine("Warning: library {0} does not exist", libConfig.Name); return(true); } DirectoryInfo cache = new DirectoryInfo(Environment.Config.CacheDirectory).CreateSubdirectory(libConfig.Name); if (!cache.Exists) { Console.WriteLine("Scripts: Failed to create directory {0}", cache.FullName); return(false); } List <Configuration.Library> overlays = null; if (libConfig.Overlays != null) { overlays = new List <Configuration.Library>(); foreach (string name in libConfig.Overlays) { overlays.Add(Environment.Config.GetLibrary(name)); } } string csFile = Path.Combine(cache.FullName, libConfig.Name + ".dll"); Hashtable files = GetScripts(libConfig, overlays, "*.cs"); if (files.Count > 0) { string stampFile = Path.Combine(cache.FullName, libConfig.Name + ".stm"); if (File.Exists(csFile) && CheckStamps(files, stampFile)) { m_Libraries.Add(new Library(libConfig, Assembly.LoadFrom(csFile))); m_AdditionalReferences.Add(csFile); Console.WriteLine("Libraries: Loaded binary library {0}", libConfig.Name); } else { ArrayList sorted = new ArrayList(files.Keys); sorted.Sort(); CompilerResults results = CompileCSScripts(sorted, csFile, libConfig, debug); if (results != null) { if (results.Errors.HasErrors) { return(false); } m_Libraries.Add(new Library(libConfig, results.CompiledAssembly)); WriteStampFile(stampFile, files); } } } return(true); }
private static CompilerResults CompileCSScripts(ICollection fileColl, string assemblyFile, Configuration.Library libConfig, bool debug) { CSharpCodeProvider provider = new CSharpCodeProvider(); #pragma warning disable 618 ICodeCompiler compiler = provider.CreateCompiler(); #pragma warning restore 618 string[] files; Console.WriteLine("Scripts: Compiling library {0}, {1} C# sources", libConfig.Name, fileColl.Count); string tempFile = compiler.GetType().FullName == "Mono.CSharp.CSharpCodeCompiler" ? Path.GetTempFileName() : null; if (tempFile == String.Empty) { tempFile = null; } if (tempFile == null) { files = new string[fileColl.Count]; fileColl.CopyTo(files, 0); } else { /* to prevent an "argument list too long" error, we * write a list of file names to a temporary file * and add them with @filename */ StreamWriter w = new StreamWriter(tempFile, false); foreach (string file in fileColl) { w.Write("\"" + file + "\" "); } w.Close(); files = new string[0]; } CompilerParameters parms = new CompilerParameters(GetReferenceAssemblies(), assemblyFile, debug); if (tempFile != null) { parms.CompilerOptions += "@" + tempFile; } if (libConfig.WarningLevel >= 0) { parms.WarningLevel = libConfig.WarningLevel; } CompilerResults results = null; try { results = compiler.CompileAssemblyFromFileBatch(parms, files); } catch (System.ComponentModel.Win32Exception e) { /* from WinError.h: * #define ERROR_FILE_NOT_FOUND 2L * #define ERROR_PATH_NOT_FOUND 3L */ if (e.NativeErrorCode == 2 || e.NativeErrorCode == 3) { Console.WriteLine("Fatal: Could not find the compiler - are you sure MCS is installed?"); Console.WriteLine(" (on Debian, try: apt-get install mono-mcs)"); System.Environment.Exit(2); } else { throw e; } } if (tempFile != null) { File.Delete(tempFile); } m_AdditionalReferences.Add(assemblyFile); Display(results); return(results); }
/// <summary> /// Enqueue a library for compilation, resolving all dependencies first. /// </summary> /// <param name="dst">This array will receive the libraries in the correct order.</param> /// <param name="libs">Source libraries.</param> /// <param name="queue">Somewhat like a stack of libraries currently waiting.</param> /// <param name="libConfig">The library to be added.</param> private static void EnqueueLibrary(List <Configuration.Library> dst, List <Configuration.Library> libs, ISet <string> queue, Configuration.Library libConfig) { var depends = libConfig.Depends; if (libConfig.Name == "Core" || libConfig.Disabled) { libs.Remove(libConfig); return; } if (libConfig.IsRemote && (!libConfig.Exists || Core.ForceUpdateDeps)) { var srcPath = Dependencies.Fetch(libConfig); libConfig.SourcePath = new DirectoryInfo(srcPath); } if (!libConfig.Exists) { libs.Remove(libConfig); log.Warning("Library {0} does not exist", libConfig.Name); return; } // First resolve dependencies. if (depends != null) { queue.Add(libConfig.Name); foreach (var depend in depends) { // If the depended library is already in the queue, there is a circular dependency. if (queue.Contains(depend)) { log.Error("Circular library dependency {0} on {1}", libConfig.Name, depend); throw new ApplicationException(); } var next = Core.LibraryConfig.GetLibrary(depend); if (next == null || !next.Exists) { log.Error("Unresolved library dependency: {0} depends on {1}, which does not exist", libConfig.Name, depend); throw new ApplicationException(); } if (next.Disabled) { log.Error("Unresolved library dependency: {0} depends on {1}, which is disabled", libConfig.Name, depend); throw new ApplicationException(); } if (!dst.Contains(next)) { EnqueueLibrary(dst, libs, queue, next); } } queue.Remove(libConfig.Name); } // Then add it to 'dst'. dst.Add(libConfig); libs.Remove(libConfig); }
private static bool Compile(Configuration.Library libConfig, bool debug) { // Check if there is source code for this library. if (libConfig.SourcePath == null) { if (libConfig.BinaryPath == null) { log.Warning("Library {0} does not exist", libConfig.Name); return(true); } if (!libConfig.BinaryPath.Exists) { log.Warning("Library {0} does not exist: {1}", libConfig.Name, libConfig.BinaryPath); return(false); } log.Info("Loading library {0}", libConfig.Name); m_Libraries.Add(new Library(libConfig, Assembly.LoadFrom(libConfig.BinaryPath.FullName))); m_AdditionalReferences.Add(libConfig.BinaryPath.FullName); return(true); } if (!libConfig.SourcePath.Exists) { log.Warning("Library {0} does not exist", libConfig.Name); return(true); } var cache = new DirectoryInfo(Core.Config.CacheDirectory).CreateSubdirectory(libConfig.Name); if (!cache.Exists) { log.Error("Failed to create directory {0}", cache.FullName); return(false); } var csFile = Path.Combine(cache.FullName, libConfig.Name + ".dll"); var files = GetScripts(libConfig, "*.cs"); if (files.Count > 0) { var stampFile = Path.Combine(cache.FullName, libConfig.Name + ".stm"); if (File.Exists(csFile) && CheckStamps(files, stampFile)) { m_Libraries.Add(new Library(libConfig, Assembly.LoadFrom(csFile))); m_AdditionalReferences.Add(csFile); log.Info("Loaded binary library {0}", libConfig.Name); } else { var sorted = new List <string>(files.Keys); sorted.Sort(); var results = CompileCSScripts(sorted, csFile, libConfig, debug); if (results != null) { if (results.Errors.HasErrors) { return(false); } m_Libraries.Add(new Library(libConfig, results.CompiledAssembly)); WriteStampFile(stampFile, files); } } } return(true); }
/// <summary> /// Enqueue a library for compilation, resolving all dependencies first. /// </summary> /// <param name="dst">This array will receive the libraries in the correct order.</param> /// <param name="libs">Source libraries.</param> /// <param name="queue">Somewhat like a stack of libraries currently waiting.</param> /// <param name="libConfig">The library to be added.</param> private static void EnqueueLibrary(List <Configuration.Library> dst, List <Configuration.Library> libs, ISet <string> queue, Configuration.Library libConfig) { var depends = libConfig.Depends; if (libConfig.Name == "core" || libConfig.Disabled) { libs.Remove(libConfig); return; } if (!libConfig.Exists) { libs.Remove(libConfig); Console.WriteLine("Warning: library {0} does not exist", libConfig.Name); return; } // First resolve dependencies. if (depends != null) { queue.Add(libConfig.Name); foreach (string depend in depends) { // If the depended library is already in the queue, there is a circular dependency. if (queue.Contains(depend)) { Console.WriteLine("Error: Circular library dependency {0} on {1}", libConfig.Name, depend); throw new ApplicationException(); } var next = Environment.Config.GetLibrary(depend); if (next == null || !next.Exists) { Console.WriteLine("Error: Unresolved library dependency: {0} depends on {1}, which does not exist", libConfig.Name, depend); throw new ApplicationException(); } if (next.Disabled) { Console.WriteLine("Error: Unresolved library dependency: {0} depends on {1}, which is disabled", libConfig.Name, depend); throw new ApplicationException(); } if (!dst.Contains(next)) { EnqueueLibrary(dst, libs, queue, next); } } queue.Remove(libConfig.Name); } // Then add it to 'dst'. dst.Add(libConfig); libs.Remove(libConfig); }