private static bool TryConvertPackageArchitecture(string architectureString, out PackageArchitecture architecture) { architecture = PackageArchitecture.Unknown; switch (architectureString.ToLowerInvariant()) { case "arm": architecture = PackageArchitecture.Arm; break; case "amd64": case "x64": architecture = PackageArchitecture.X64; break; case "i386": case "x86": architecture = PackageArchitecture.X86; break; case "neutral": architecture = PackageArchitecture.Neutral; break; } return(architecture != PackageArchitecture.Unknown); }
/// <summary> /// Compiles the added files into a target output appropriate for the output path extension. /// </summary> /// <param name="type">Package type to generate.</param> /// <param name="architecture">Package architecture to generate.</param> /// <param name="languages">Package languages to generate.</param> /// <param name="outputPath">Path to generate output. Output path file extension determines the output type.</param> public void Compile(PackageType type, PackageArchitecture architecture, CultureInfo[] languages, string outputPath) { FrontendCompiler frontend = new FrontendCompiler(architecture, this.referenceAssemblies); frontend.Messages += this.Messages; foreach (KeyValuePair <string, string> define in this.PreprocessorDefines) { frontend.Substitutions.Add(define.Key, define.Value); } foreach (Swix root in this.roots) { frontend.AddRoot(root); } foreach (string path in this.sourceFiles) { frontend.Parse(path); } if (frontend.EncounteredError) { return; } frontend.Resolve(); if (frontend.EncounteredError) { return; } frontend.Harvest(); if (frontend.EncounteredError) { return; } Intermediate[] intermediates = frontend.GetIntermediates(); CompilerFileManager fileManager = this.FileManager ?? new CompilerFileManager(); fileManager.Architecture = architecture; fileManager.Language = languages.Length == 0 ? null : languages[0]; fileManager.OutputPath = outputPath; foreach (string searchPath in this.SearchPaths) { fileManager.SearchPaths.Add(searchPath); } using (BackendCompiler backend = BackendCompiler.Create(type, outputPath)) { backend.Messages += this.Messages; backend.Architecture = architecture; backend.FileManager = fileManager; backend.Languages = languages; backend.Generate(intermediates, outputPath); } }
public FrontendCompiler(PackageArchitecture architecture, List <System.Reflection.Assembly> referenceAssemblies) { this.namedItems = new Dictionary <string, PackageItem>(); this.Substitutions = new Dictionary <string, string>(); this.Architecture = architecture; this.items = new List <PackageItem>(); this.roots = new List <Swix>(); this.services = new Dictionary <Type, object>(); this.fileSystemManager = new FileSystemResourceManager(FrontendCompiler.DefaultFileSystemManagerRootFolderId); this.services.Add(this.fileSystemManager.GetType(), this.fileSystemManager); this.unresolved = new List <PackageItem>(); this.AddSystemPackage(); // ensure the system resources are always loaded. }
private bool Run(Messaging messaging) { if (this.SourcePaths.Length == 0) { messaging.OnError(null, "No inputs specified. Specify at least one file."); } if (String.IsNullOrEmpty(this.Type)) { if (this.OutputPath == null) { messaging.OnError(this, "Package type cannot be inferred from output path. Explicitly specify PackageType in your MSBuild project or -type from the swc.exe command-line. Valid options are: appx, msi, vsix, or wixlib"); } else { this.Type = Path.GetExtension(this.OutputPath.ItemSpec); } } else if (this.OutputPath == null && this.SourcePaths.Length > 0) { string outputPath = Path.ChangeExtension(this.SourcePaths[0].ItemSpec, this.Type.ToLowerInvariant()); this.OutputPath = new FilePathTaskItem(outputPath); } PackageArchitecture architecture = PackageArchitecture.Unknown; if (String.IsNullOrEmpty(this.Architecture)) { messaging.OnError(this, "A package architecture must specified. Set the PackageArchitecture in your MSBuild project or -arch from the swc.exe command-line. Valid options are: arm, x64, x86 or neutral"); } else if (!SimplifiedWixCompiler.TryConvertPackageArchitecture(this.Architecture, out architecture)) { messaging.OnError(this, "Unknown architecture specified: {0}. Valid options are: arm, x64, x86 or neutral", this.Architecture); } List <CultureInfo> locales = new List <CultureInfo>(); if (this.Languages != null) { foreach (string language in this.Languages) { try { CultureInfo locale; int lcid = 0; if (Int32.TryParse(language, out lcid)) { locale = new CultureInfo(lcid); } else { locale = new CultureInfo(language); } locales.Add(locale); } catch (CultureNotFoundException) { messaging.OnError(this, "Unknown language: {0}", language); } } } PackageType type = PackageType.Unknown; if (String.IsNullOrEmpty(this.Type)) { messaging.OnError(this, "A package type must specified. Use the PackageType in your MSBuild project or -type from the swc.exe command-line. Valid options are: appx, msi, vsix or wixlib"); } else if (!SimplifiedWixCompiler.TryConvertPackageType(this.Type, out type)) { messaging.OnError(this, "Unknown package type specified: {0}. Valid options are: appx, msi, vsix or wixlib", this.Type); } if (type == PackageType.Appx && locales.Count == 0) { messaging.OnError(this, "AppX packages do not support language neutral packages. At least one language to be specified. Use the PackageLanguages property in your MSBuild project or -lang from the swc.exe command-line."); } if (!messaging.Errored) { SimplifiedCompiler compiler = new SimplifiedCompiler(); compiler.Messages += messaging.MessageDelegate; if (this.SearchPaths != null) { foreach (ITaskItem searchPath in this.SearchPaths) { compiler.SearchPaths.Add(searchPath.ItemSpec); } } if (this.PreprocessorDefines != null) { foreach (string define in this.PreprocessorDefines) { string[] defineSplit = define.Split(new char[] { '=' }, 2, StringSplitOptions.RemoveEmptyEntries); compiler.PreprocessorDefines.Add(defineSplit[0], defineSplit.Length > 1 ? defineSplit[1] : null); } } // Load the extensions. if (this.Extensions != null) { SimplifiedWixCompiler.LoadExtensions(compiler, messaging, this.Extensions); } // Finally, load the sources and compile! if (!messaging.Errored) { SimplifiedWixCompiler.LoadPackageSources(compiler, this.SourcePaths); compiler.Compile(type, architecture, locales.ToArray(), this.OutputPath.ItemSpec); } } return(!messaging.Errored); }
/// <summary> /// Compiles the added files using the given CompilerExtension to generate the output /// </summary> /// <param name="outputExtension">Extension used to generated the output.</param> /// <param name="architecture">Package architecture to generate.</param> /// <param name="languages">Package languages to generate.</param> /// <param name="outputPath">Path to generate output.</param> public void Compile(CompilerExtension outputExtension, PackageArchitecture architecture, CultureInfo[] languages, string outputPath) { CoreCompile(architecture, languages, outputPath, () => outputExtension.CreateBackendCompiler()); }
/// <summary> /// Compiles the added files into a target output appropriate for the output path extension. /// </summary> /// <param name="type">Package type to generate.</param> /// <param name="architecture">Package architecture to generate.</param> /// <param name="languages">Package languages to generate.</param> /// <param name="outputPath">Path to generate output. Output path file extension determines the output type.</param> public void Compile(PackageType type, PackageArchitecture architecture, CultureInfo[] languages, string outputPath) { CoreCompile(architecture, languages, outputPath, () => BackendCompiler.Create(type, outputPath)); }