public string GetScriptAssembly() { if (CompilerType == null) { return(null); } var papyrusGen = new PapyrusGen(new CommonTreeNodeStream(CompilerType.GetAst()) { TokenStream = CompilerType.GetTokenStream() }); using (var manifestResourceStream = papyrusGen.GetType().Assembly.GetManifestResourceStream("PCompiler.PapyrusAssembly.stg")) { var templateGroup = new StringTemplateGroup(new StreamReader(manifestResourceStream)); #if SKYRIM papyrusGen.TemplateLib = templateGroup; #else papyrusGen.TemplateGroup = templateGroup; #endif papyrusGen.AsDynamic().KnownUserFlags = _program.FlagsFile.NativeFlagsDict; var template = papyrusGen.script(_filePath, CompilerType).Template; return(template.ToString()); } }
protected virtual CompileResult Compile( CompilerType compilerType, string compilerPath, string compilerArguments, string submissionFilePath, bool useWorkingDirectoryForProcess = false) { if (compilerType == CompilerType.None) { return(new CompileResult(true, null) { OutputFile = submissionFilePath }); } if (!File.Exists(compilerPath)) { throw new ArgumentException($"Compiler not found in: {compilerPath}", nameof(compilerPath)); } var compiler = Compiler.CreateCompiler(compilerType, this.Type); var compilerResult = compiler.Compile(compilerPath, submissionFilePath, compilerArguments, useWorkingDirectoryForProcess); return(compilerResult); }
public SolutionManager(string program, string userId, int taskId, CompilerType compilerType) { this.program = program; this.userId = userId; this.taskId = taskId; this.compilerType = compilerType; }
public SolutionManager(byte[] file, string userId, int taskId, CompilerType compilerType) { program = Encoding.UTF8.GetString(file); //zmiana bitów na string this.userId = userId; this.taskId = taskId; this.compilerType = compilerType; }
public void NamedScope_WithNull(CompilerType compilerType) { var container = new StashboxContainer(c => c.WithCompiler(compilerType)) .Register <Test2>(config => config.InNamedScope("A")); Assert.Null(container.BeginScope("A").Resolve <Test2>(nullResultAllowed: true)); }
public void DecoratorTests_Simple_Enumerable(CompilerType compilerType) { using var container = new StashboxContainer(c => c.WithCompiler(compilerType)); container.Register <ITest1, Test1>(); container.Register <ITest1, Test11>(); container.RegisterDecorator <ITest1, TestDecorator1>(); var test = container.Resolve <IEnumerable <ITest1> >(); Assert.NotNull(test); Assert.IsAssignableFrom <IEnumerable <ITest1> >(test); var arr = test.ToArray(); Assert.NotNull(arr[0]); Assert.IsType <TestDecorator1>(arr[0]); Assert.NotNull(arr[1]); Assert.IsType <TestDecorator1>(arr[1]); Assert.NotNull(arr[0].Test); Assert.IsType <Test1>(arr[0].Test); Assert.NotNull(arr[1].Test); Assert.IsType <Test11>(arr[1].Test); }
private CompileResult CompileSourceFiles( CompilerType compilerType, string compilerPath, string compilerArguments, IEnumerable <string> sourceFilesToCompile) { var compilerResult = new CompileResult(false, null); var compilerCommentBuilder = new StringBuilder(); foreach (var sourceFile in sourceFilesToCompile) { compilerResult = this.Compile(compilerType, compilerPath, compilerArguments, sourceFile); compilerCommentBuilder.AppendLine(compilerResult.CompilerComment); if (!compilerResult.IsCompiledSuccessfully) { break; // The compilation of other files is not necessary } } var compilerComment = compilerCommentBuilder.ToString().Trim(); compilerResult.CompilerComment = compilerComment.Length > 0 ? compilerComment : null; return(compilerResult); }
public void Ensure_expression_built_correctly_singleton_dispose_simple(CompilerType compilerType) { C.Counter = 0; F inst = null; { using var container = new StashboxContainer(c => { c.WithDisposableTransientTracking().WithCompiler(compilerType); }) .Register <F>(c => c.WithScopedLifetime()) .Register <C>(c => c.WithSingletonLifetime()); { using var scope = container.BeginScope(); inst = scope.Resolve <F>(); } Assert.True(inst.Disposed); Assert.False(inst.C.Disposed); } Assert.True(inst.C.Disposed); Assert.Equal(1, C.Counter); }
public GradleProjectGenerator(String SolutionName, Project Project, List <ProjectReference> ProjectReferences, PathString InputDirectory, PathString OutputDirectory, PathString SolutionOutputDirectory, String BuildGradleTemplateText, OperatingSystemType HostOperatingSystem, ArchitectureType HostArchitecture, OperatingSystemType TargetOperatingSystem, ArchitectureType?TargetArchitecture, ToolchainType Toolchain, CompilerType Compiler, CLibraryType CLibrary, CLibraryForm CLibraryForm, CppLibraryType CppLibrary, CppLibraryForm CppLibraryForm, ConfigurationType?ConfigurationType, PathString AndroidNdk) { this.SolutionName = SolutionName; this.ProjectName = Project.Name.Split(':').First(); this.Project = Project; this.ProjectReferences = ProjectReferences; this.InputDirectory = InputDirectory.FullPath; this.OutputDirectory = OutputDirectory.FullPath; this.SolutionOutputDirectory = SolutionOutputDirectory.FullPath; this.BuildGradleTemplateText = BuildGradleTemplateText; this.HostOperatingSystem = HostOperatingSystem; this.HostArchitecture = HostArchitecture; this.TargetOperatingSystem = TargetOperatingSystem; this.TargetArchitecture = TargetArchitecture; if (!TargetArchitecture.HasValue) { throw new NotSupportedException("ArchitectureTypeIsNull"); } this.Toolchain = Toolchain; this.Compiler = Compiler; this.CLibrary = CLibrary; this.CLibraryForm = CLibraryForm; this.CppLibrary = CppLibrary; this.CppLibraryForm = CppLibraryForm; this.ConfigurationType = ConfigurationType; this.AndroidNdk = AndroidNdk; }
public static ICompiler CreateCompiler(CompilerType compilerType) { switch (compilerType) { case CompilerType.None: return(null); case CompilerType.CSharp: return(new CSharpCompiler()); case CompilerType.CPlusPlusGcc: return(new CPlusPlusCompiler()); case CompilerType.MsBuild: return(new MsBuildCompiler()); case CompilerType.Java: return(new JavaCompiler()); case CompilerType.JavaZip: return(new JavaZipCompiler()); default: throw new ArgumentException("Unsupported compiler."); } }
public void NamedScope_Throws_ResolutionFailedException_Without_Scope(CompilerType compilerType) { var container = new StashboxContainer(c => c.WithCompiler(compilerType)) .Register <ITest, Test>(config => config.InNamedScope("A")); Assert.Throws <ResolutionFailedException>(() => container.Resolve <ITest>()); }
public void Ensure_expression_built_correctly_scoped(CompilerType compilerType) { A.Counter = 0; B.Counter = 0; C.Counter = 0; D.Counter = 0; E.Counter = 0; F.Counter = 0; A inst = null; { using var container = new StashboxContainer(c => c.WithRuntimeCircularDependencyTracking() .WithDisposableTransientTracking() .WithCompiler(compilerType)) .Register <A>(c => c.WithScopedLifetime()) .Register <B>(c => c.WithScopedLifetime()) .Register <D>(c => c.WithScopedLifetime()) .Register <E>(c => c.WithScopedLifetime()) .Register <F>(c => c.WithScopedLifetime()) .Register <C>(c => c.WithFactory(r => new C()).WithScopedLifetime().WithoutDisposalTracking()); using var scope = container.BeginScope(); inst = scope.Resolve <A>(); Assert.NotNull(inst); Assert.NotNull(inst.B); Assert.NotNull(inst.C); Assert.NotNull(inst.B.D); Assert.NotNull(inst.B.C); Assert.NotNull(inst.B.D.C); Assert.NotNull(inst.B.D.E); Assert.NotNull(inst.B.D.F); Assert.NotNull(inst.B.D.E.C); Assert.NotNull(inst.B.D.F.C); Assert.Same(inst.C, inst.B.C); Assert.Same(inst.B.C, inst.B.D.C); Assert.Same(inst.B.D.C, inst.B.D.E.C); Assert.Same(inst.B.D.E.C, inst.B.D.F.C); } Assert.True(inst.Disposed); Assert.True(inst.B.Disposed); Assert.False(inst.C.Disposed); Assert.True(inst.B.D.Disposed); Assert.False(inst.B.C.Disposed); Assert.False(inst.B.D.C.Disposed); Assert.True(inst.B.D.E.Disposed); Assert.True(inst.B.D.F.Disposed); Assert.False(inst.B.D.E.C.Disposed); Assert.False(inst.B.D.F.C.Disposed); Assert.Equal(1, A.Counter); Assert.Equal(1, B.Counter); Assert.Equal(1, C.Counter); Assert.Equal(1, D.Counter); Assert.Equal(1, E.Counter); Assert.Equal(1, F.Counter); }
protected CompileResult Compile(CompilerType compilerType, string compilerPath, string compilerArguments, string submissionFilePath) { if (compilerType == CompilerType.None) { return(new CompileResult(true, null) { OutputFile = submissionFilePath }); } if (!File.Exists(compilerPath)) { throw new ArgumentException(string.Format("Compiler not found in: {0}", compilerPath), "compilerPath"); } ICompiler compiler = Compiler.CreateCompiler(compilerType); var compilerResult = compiler.Compile(compilerPath, submissionFilePath, compilerArguments); if (File.Exists(submissionFilePath)) { File.Delete(submissionFilePath); } return(compilerResult); }
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); }
internal CompilerType GetCompilerInfoFromLanguage(string language) { CompilerType compilerTypeInternal; this.EnsureCompilerCacheInit(); object obj2 = this._compilerLanguages[language]; Compiler compiler = obj2 as Compiler; if (compiler != null) { compilerTypeInternal = compiler.CompilerTypeInternal; this._compilerLanguages[language] = compilerTypeInternal; } else { compilerTypeInternal = obj2 as CompilerType; } if ((compilerTypeInternal == null) && CodeDomProvider.IsDefinedLanguage(language)) { CompilerInfo compilerInfo = CodeDomProvider.GetCompilerInfo(language); compilerTypeInternal = new CompilerType(compilerInfo.CodeDomProviderType, compilerInfo.CreateDefaultCompilerParameters()); this._compilerLanguages[language] = compilerTypeInternal; } if (compilerTypeInternal == null) { throw new HttpException(System.Web.SR.GetString("Invalid_lang", new object[] { language })); } CompilationUtil.CheckCompilerOptionsAllowed(compilerTypeInternal.CompilerParameters.CompilerOptions, true, null, 0); compilerTypeInternal = compilerTypeInternal.Clone(); compilerTypeInternal.CompilerParameters.IncludeDebugInformation = this.Debug; return(compilerTypeInternal); }
private static string GetCompilerPath(CompilerType type) { switch (type) { case CompilerType.None: return(null); case CompilerType.CSharp: return(Settings.CSharpCompilerPath); case CompilerType.MsBuild: case CompilerType.MsBuildLibrary: return(Settings.MsBuildExecutablePath); case CompilerType.CPlusPlusGcc: case CompilerType.CPlusPlusZip: return(Settings.CPlusPlusGccCompilerPath); case CompilerType.Java: case CompilerType.JavaZip: case CompilerType.JavaInPlaceCompiler: return(Settings.JavaCompilerPath); case CompilerType.DotNetCompiler: case CompilerType.CSharpDotNetCore: return(Settings.DotNetCompilerPath); case CompilerType.SolidityCompiler: return(Settings.SolidityCompilerPath); default: throw new ArgumentOutOfRangeException(nameof(type)); } }
public SimpleRazorBuildProvider() { this._codeLanguage = new CSharpRazorCodeLanguage(); this._compilerType = GetDefaultCompilerTypeForLanguage(this._codeLanguage.LanguageName); this._host = new SimpleRazorEngineHost(this._codeLanguage); this._virtualPathDependencies = null; this._typeName = string.Format(CultureInfo.InvariantCulture, "{0}.{1}", this._host.DefaultNamespace, "Foot"); }
public void ResolveFactoryTests_ParameterLess(CompilerType compilerType) { using var container = new StashboxContainer(c => c.WithCompiler(compilerType)); container.Register <Test>(); var factory = container.ResolveFactory <Test>(); Assert.NotNull(factory()); }
/// <summary> /// Clone another compile environment /// </summary> /// <param name="Other">The compile environment to copy</param> public CompileEnvironment(CompileEnvironment Other) { Compiler = Other.Compiler; CompilerType = Other.CompilerType; Options = new List <CompileOption>(Other.Options); Definitions = new List <string>(Other.Definitions); IncludePaths = new List <DirectoryReference>(Other.IncludePaths); }
public void NamedScope_Lifetime_Check(CompilerType compilerType) { var inst = new StashboxContainer(c => c.WithCompiler(compilerType)) .Register <ITest, Test>(config => config.InNamedScope("A")) .ContainerContext.RegistrationRepository.GetRegistrationMappings().First(reg => reg.Key == typeof(ITest)); Assert.IsType <NamedScopeLifetime>(inst.Value.RegistrationContext.Lifetime); }
public void Different_Compilers(CompilerType type, string table) { var input = new Query("Foo"); var expected = new Sql($"SELECT * FROM {table}"); var output = input.ToSql(type); output.Should().BeEquivalentTo(expected); }
public abstract void DoWork( CompilerType compilerType, string compilerAdditionalArguments, byte[] compilerContent, string checkerAssemblyName, string checkerTypeName, string checkerParameter, int timeLimit, int memoryLimit);
public void ResolveFactoryTests_ParameterLess_Named(CompilerType compilerType) { using var container = new StashboxContainer(c => c.WithCompiler(compilerType)); container.Register <IService, Service>(c => c.WithName("service")); container.Register <IService, Service1>(c => c.WithName("service1")); var factory = container.ResolveFactory <IService>("service"); Assert.IsType <Service>(factory()); }
/* * 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); }
public void FactoryTests_Resolve_ContainerFactory(CompilerType compilerType) { using var container = new StashboxContainer(c => c.WithCompiler(compilerType)); container.Register <Test3>(); container.Register <ITest>(context => context.WithFactory(c => c.Resolve <Test3>())); var inst = container.Resolve <ITest>(); Assert.IsType <Test3>(inst); }
public Make(ToolchainType Toolchain, CompilerType Compiler, OperatingSystemType TargetOperationSystem, String SourceDirectory, String BuildDirectory, bool EnableRebuild) { this.Toolchain = Toolchain; this.Compiler = Compiler; this.TargetOperationSystem = TargetOperationSystem; this.SourceDirectory = SourceDirectory; this.BuildDirectory = BuildDirectory; this.EnableRebuild = EnableRebuild; this.BuildingOperatingSystem = OperatingSystemType.Windows; }
public void FactoryTests_Resolve_ContainerFactory_Initializer(CompilerType compilerType) { using var container = new StashboxContainer(c => c.WithCompiler(compilerType)); container.Register <ITest4>(context => context.WithFactory(() => new Test4()).WithInitializer((t, r) => t.Init("Test"))); var test1 = container.Resolve <ITest4>(); Assert.Equal("Test", test1.Name); }
public void NamedScope_Simple_Resolve_Get_Last_If_Scoped_Doesnt_Exist(CompilerType compilerType) { var inst = new StashboxContainer(c => c.WithCompiler(compilerType)) .Register <ITest, Test>() .Register <ITest, Test1>() .BeginScope("A") .Resolve <ITest>(); Assert.IsType <Test1>(inst); }
/// <summary> /// Convert a <seealso cref="Query"/> object to a <seealso cref="Sql" /> object. /// </summary> /// <param name="query"></param> /// <param name="compilerType"></param> /// <returns></returns> public static Sql ToSql(this Query query, CompilerType compilerType) { query = query ?? throw new ArgumentNullException(nameof(query)); var compiler = _compilers[compilerType].Value; var compiled = compiler.Compile(query); var ppSql = Helper.ReplaceAll(compiled.RawSql, "?", x => "@" + x); return(new Sql(ppSql, compiled.Bindings.ToArray())); }
protected internal override void ProcessExternalResource( IResourceBuildHelper helper, string url, out string preProcessed, out string compacted, List <ParseException> errors) { compacted = preProcessed = String.Empty; Uri uri; if (!Uri.TryCreate(url, UriKind.Absolute, out uri)) { throw new ArgumentException("Invalid external URL"); } string ext = Path.GetExtension(uri.AbsolutePath).Trim('.'); CompilerType compiler = helper.GetDefaultCompilerTypeForLanguage(ext); if (!typeof(ResourceCodeProvider).IsAssignableFrom(compiler.CodeDomProviderType)) { // don't know how to process any further return; } ResourceCodeProvider provider = (ResourceCodeProvider)Activator.CreateInstance(compiler.CodeDomProviderType); try { // concatenate the preprocessed source for current merge phase provider.ProcessExternalResource( helper, url, out preProcessed, out compacted, errors); } catch (ParseException ex) { errors.Add(ex); } catch (Exception ex) { errors.Add(new ParseError(ex.Message, url, 0, 0, ex)); } if (!this.isMimeSet && !String.IsNullOrEmpty(provider.ContentType) && !String.IsNullOrEmpty(provider.FileExtension)) { this.contentType = provider.ContentType; this.fileExtension = provider.FileExtension; this.isMimeSet = true; } }
public static ICompiler CreateCompiler(CompilerType compilerType) { switch (compilerType) { case CompilerType.None: return null; case CompilerType.CSharp: return new CSharpCompiler(); case CompilerType.CPlusPlusGcc: return new CPlusPlusCompiler(); default: throw new ArgumentException("Unsupported compiler."); } }
protected CompileResult Compile(CompilerType compilerType, string compilerPath, string compilerArguments, string code) { var sourceCodeFilePath = this.SaveStringToTempFile(code); if (compilerType == CompilerType.None) { return new CompileResult(true, null) { OutputFile = sourceCodeFilePath }; } if (!File.Exists(compilerPath)) { throw new ArgumentException(string.Format("Compiler not found in: {0}", compilerPath), "compilerPath"); } ICompiler compiler = Compiler.CreateCompiler(compilerType); var compilerResult = compiler.Compile(compilerPath, sourceCodeFilePath, compilerArguments); File.Delete(sourceCodeFilePath); return compilerResult; }
protected CompileResult Compile(CompilerType compilerType, string compilerPath, string compilerArguments, string submissionFilePath) { if (compilerType == CompilerType.None) { return new CompileResult(true, null) { OutputFile = submissionFilePath }; } if (!File.Exists(compilerPath)) { throw new ArgumentException(string.Format("Compiler not found in: {0}", compilerPath), "compilerPath"); } ICompiler compiler = Compiler.CreateCompiler(compilerType); var compilerResult = compiler.Compile(compilerPath, submissionFilePath, compilerArguments); if (File.Exists(submissionFilePath)) { File.Delete(submissionFilePath); } return compilerResult; }
/// <summary> /// Initializeaza o clasa pentru un compilator nou /// </summary> /// <param name="fullPath">Adresa catre executabil</param> /// <param name="argumentsPattern">Sablonul argumentelor</param> /// <param name="compilerType">Tipul compilatorului</param> public CompilerData(string fullPath, string argumentsPattern, CompilerType compilerType) { FullPath = fullPath; ArgumentsPattern = argumentsPattern; CompilerType = compilerType; }
/// <summary> /// Compileaza un text /// </summary> /// <param name="sourceText">Textul care trebuie compilat</param> /// <param name="compilerType">Tipul compilatorului</param> /// <returns></returns> public bool CompileText(string sourceText, CompilerType compilerType) { return CompileText(sourceText, GetCompilerByType(compilerType)); }
/// <summary> /// Returneaza un compilator dupa tipul specificat /// </summary> /// <param name="compilerType">Tipul compilatorului</param> /// <returns></returns> public CompilerData GetCompilerByType(CompilerType compilerType) { switch (compilerType) { case CompilerType.CPP: return CPPCompiler; default: return null; } }
private CompileResult CompileSourceFiles(CompilerType compilerType, string compilerPath, string compilerArguments, IEnumerable<string> sourceFilesToCompile) { var compilerResult = new CompileResult(false, null); var compilerCommentBuilder = new StringBuilder(); foreach (var sourceFile in sourceFilesToCompile) { compilerResult = this.Compile(compilerType, compilerPath, compilerArguments, sourceFile); compilerCommentBuilder.AppendLine(compilerResult.CompilerComment); if (!compilerResult.IsCompiledSuccessfully) { break; // The compilation of other files is not necessary } } var compilerComment = compilerCommentBuilder.ToString().Trim(); compilerResult.CompilerComment = compilerComment.Length > 0 ? compilerComment : null; return compilerResult; }
private static Compiler CreateCompiler(CompilerType compilerType, Logger logger, Platform platform, string monoProfile, string projectDir, string[] compilationOptions, string unityEditorDataDir) { var compilerDirectory = Path.Combine(projectDir, LANGUAGE_SUPPORT_DIR); switch (compilerType) { case CompilerType.Auto: return FindSuitableCompiler(logger, platform, monoProfile, projectDir, compilationOptions, unityEditorDataDir); case CompilerType.Mono3: var stockCompilerPath = monoProfile == "2.0" ? Path.Combine(unityEditorDataDir, @"Mono/lib/mono/2.0/gmcs.exe") : Path.Combine(unityEditorDataDir, @"Mono/lib/mono/" + monoProfile + "/smcs.exe"); return new Mono30Compiler(logger, stockCompilerPath); case CompilerType.Mono5: var bleedingEdgeCompilerPath = Path.Combine(unityEditorDataDir, @"MonoBleedingEdge/lib/mono/4.5/mcs.exe"); return new Mono50Compiler(logger, bleedingEdgeCompilerPath); case CompilerType.Mono6: if (Mono60Compiler.IsAvailable(compilerDirectory)) return new Mono60Compiler(logger, compilerDirectory); break; case CompilerType.Microsoft6: var roslynDirectory = Path.Combine(compilerDirectory, "Roslyn"); if (Microsoft60Compiler.IsAvailable(roslynDirectory)) return new Microsoft60Compiler(logger, roslynDirectory); break; case CompilerType.Incremental6: if (Incremental60Compiler.IsAvailable(compilerDirectory)) return new Incremental60Compiler(logger, compilerDirectory); break; } return null; }
private static string GetCompilerPath(CompilerType type) { switch (type) { case CompilerType.None: return null; case CompilerType.CSharp: return Settings.CSharpCompilerPath; case CompilerType.MsBuild: return Settings.MsBuildExecutablePath; case CompilerType.CPlusPlusGcc: return Settings.CPlusPlusGccCompilerPath; case CompilerType.Java: return Settings.JavaCompilerPath; default: throw new ArgumentOutOfRangeException("type"); } }
private CompileResult CompileSourceFiles(CompilerType compilerType, string compilerPath, string compilerArguments, IEnumerable<string> sourceFilesToCompile) { CompileResult compilerResult = null; foreach (var sourceFile in sourceFilesToCompile) { compilerResult = this.Compile(compilerType, compilerPath, compilerArguments, sourceFile); if (!compilerResult.IsCompiledSuccessfully) { break; // The compilation of other files is not necessary } } return compilerResult; }
private static string GetCompilerPath(CompilerType type) { switch (type) { case CompilerType.None: return null; case CompilerType.CSharp: return Settings.CSharpCompilerPath; case CompilerType.MsBuild: throw new NotImplementedException("Compiler not supported."); case CompilerType.CPlusPlusGcc: return Settings.CPlusPlusGccCompilerPath; case CompilerType.Java: throw new NotImplementedException("Compiler not supported."); default: throw new ArgumentOutOfRangeException("type"); } }