protected override void CustomizeCompiler(BooCompiler compiler, CompilerPipeline pipeline, string[] urls) { pipeline.Insert(1, new ImplicitBaseClassCompilerStep(typeof(BooConfigReader), "Prepare", "Horn.Core.Dsl")); pipeline.InsertBefore(typeof(ProcessMethodBodiesWithDuckTyping), new RightShiftToMethodCompilerStep()); pipeline.Insert(2, new UnderscorNamingConventionsToPascalCaseCompilerStep()); pipeline.Insert(3, new UseSymbolsStep()); }
protected override void AddCompilerSteps(BooCompiler compiler, string filename, CompilerPipeline pipeline) { compiler.Parameters.AddAssembly(typeof(Boo.Lang.Compiler.Ast.DepthFirstTransformer).Assembly); compiler.Parameters.Pipeline.Insert(1, new MethodSubstitutionBaseClassCompilerStep(typeof(MyMethodSubstitutionBaseClass), "System", "Boo.Lang.Compiler.Ast.DepthFirstTransformer")); }
protected override void CustomizeCompiler(BooCompiler compiler, CompilerPipeline pipeline, string[] urls) { pipeline.Insert(1, new ImplicitBaseClassCompilerStep(typeof (BaseDaemonConfigurationDSL), "Prepare", "Puppy.Monitoring.Daemon.DSL")); pipeline.InsertBefore(typeof (ProcessMethodBodiesWithDuckTyping), new UnderscoreNamingConventionsToPascalCaseCompilerStep()); }
protected override void CustomizeCompiler(BooCompiler compiler, CompilerPipeline pipeline, string[] urls) { int step = 1; pipeline.Insert(step++, new ImplicitBaseClassCompilerStep(typeof (MigrationBase), "Execute", "evo.Core.DSL")); pipeline.Insert(step++, new AutoImportCompilerStep("System", "evo.Core", "evo.Core.DSL")); pipeline.Insert(step++, new UseSymbolsStep()); pipeline.Insert(step++, new AutoReferenceFilesCompilerStep()); }
public static void ReplaceOptional(CompilerPipeline pipeline, Type optionalPipelineStepType, ICompilerStep step) { int num = pipeline.Find(optionalPipelineStepType); if (num >= 0) { pipeline.RemoveAt(num); pipeline.Insert(num - 1, step); } }
protected override void CustomizeCompiler(BooCompiler compiler, CompilerPipeline pipeline, string[] urls) { pipeline.Insert(1, new ImplicitBaseClassCompilerStep(typeof (BaseOrderActionsDSL), "Prepare", //default namespaces "Rhino.DSL.Tests.SchedulingDSL")); pipeline.InsertBefore(typeof (ProcessMethodBodiesWithDuckTyping), new UnderscoreNamingConventionsToPascalCaseCompilerStep()); }
protected override void CustomizeCompiler(BooCompiler compiler, CompilerPipeline pipeline, string[] urls) { pipeline.Insert(1, new ImplicitBaseClassCompilerStep(typeof (PhantomBase), "Execute", typeof(UtilityFunctions).Namespace)); pipeline.Insert(2, new ExpressionToTargetNameStep()); pipeline.Insert(3, new ExpressionToDependencyNamesStep()); pipeline.Insert(4, new ExpressionToCallTargetNameStep()); pipeline.Insert(5, new UseSymbolsStep()); pipeline.Insert(6, new AutoReferenceFilesCompilerStep()); }
public static CompilerPipeline AdjustPipeline(EvaluationContext context, CompilerPipeline pipeline) { pipeline.InsertAfter(typeof(IntroduceUnityGlobalNamespaces), new IntroduceScriptingNamespace(context)); pipeline.InsertAfter(typeof(IntroduceScriptingNamespace), new IntroduceImports(context)); pipeline.InsertAfter(typeof(ApplySemantics), new IntroduceEvaluationContext(context)); pipeline.Replace(typeof(ProcessUnityScriptMethods), new ProcessScriptingMethods(context)); pipeline.InsertAfter(typeof(ProcessScriptingMethods), new IntroduceReturnValue()); return pipeline; }
public CompilerContext Compile(string name, string code, CompilerPipeline pipeline = null, Action<CompilerParameters> prepare = null) { if(null==pipeline) pipeline = new Parse(); var compiler = new BooCompiler(); compiler.Parameters.Pipeline = pipeline; compiler.Parameters.Input.Add(new ReaderInput(name, new StringReader(code))); if(prepare!=null) { prepare(compiler.Parameters); } return compiler.Run(); }
protected override void CustomizeCompiler( BooCompiler compiler, CompilerPipeline pipeline, string[] urls) { pipeline.Insert(1, new ImplicitBaseClassCompilerStep( typeof(ResponseStrategy), "ExecuteRule", "System.Net.Mail")); }
protected override void CustomizeCompiler( BooCompiler compiler, CompilerPipeline pipeline, string[] urls) { pipeline.Insert(1, new ImplicitBaseClassCompilerStep( typeof(QuoteGeneratorRule), "Evaluate", "BooDslExampleApp.QuoteGeneration")); pipeline.Insert(2, new UseSymbolsStep()); }
/// <summary> /// Customise the compiler to fit the etl engine /// </summary> protected override void CustomizeCompiler(BooCompiler compiler, CompilerPipeline pipeline, string[] urls) { compiler.Parameters.References.Add(typeof(EtlDslEngine).Assembly); compiler.Parameters.References.Add(typeof(EtlProcess).Assembly); pipeline.Insert(1, new AutoReferenceFilesCompilerStep()); pipeline.Insert(2, new UseModuleNameAsNamespaceIfMissing()); pipeline.Insert(3, new AutoImportCompilerStep( "Rhino.Etl.Core", "Rhino.Etl.Dsl", "Rhino.Etl.Dsl.Macros")); pipeline.InsertAfter(typeof(MacroAndAttributeExpansion), new CorrelateTypesToModuleName(moduleNameToContainedTypes)); }
protected override void CustomizeCompiler(BooCompiler compiler, CompilerPipeline pipeline, string[] urls) { // save to disk pipeline = new CompileToFile(); compiler.Parameters.Pipeline = pipeline; //compiler.Parameters.Ducky = true; pipeline.Insert(1, new AnonymousBaseClassCompilerStep(typeof (DeclerativeDslBase), "Prepare", // method to override "DSL.Demo.Model", "DSL.Demo.Declerative")); // namespace to add pipeline.Insert(2, new CaptureCompilerContextStep()); }
public void EventSequence() { var calls = new List<string>(); var pipeline = new CompilerPipeline(); pipeline.Before += delegate { calls.Add("before"); }; pipeline.BeforeStep += delegate { calls.Add("before step"); }; pipeline.Add(new ActionStep(() => calls.Add("step"))); pipeline.AfterStep += delegate { calls.Add("after step"); }; pipeline.After += delegate { calls.Add("after"); }; pipeline.Run(new CompilerContext()); Assert.AreEqual( new string[] {"before", "before step", "step", "after step", "after"}, calls.ToArray()); }
public static CompilerPipeline Extend(CompilerPipeline pipeline) { if(pipeline.Find(typeof(ExtensionsPreprocessorCompilerStep))==-1) { #if !LIB2 if (pipeline.Find(typeof (BooParsingStep)) != -1) { pipeline.InsertAfter(typeof (BooParsingStep), new ExtensionsPreprocessorCompilerStep()); } #else if (pipeline.Find(typeof(Parsing)) != -1) { pipeline.InsertAfter(typeof(Parsing), new ExtensionsPreprocessorCompilerStep()); } #endif } return pipeline; }
public static CompilerPipeline AdjustBooPipeline(CompilerPipeline pipeline) { pipeline.Insert(0, new PreProcess()); pipeline.Replace(typeof(Parsing), new UnityScript.Steps.Parse()); pipeline.Replace(typeof(IntroduceGlobalNamespaces), new IntroduceUnityGlobalNamespaces()); pipeline.InsertAfter(typeof(PreErrorChecking), new ApplySemantics()); pipeline.InsertAfter(typeof(ApplySemantics), new ApplyDefaultVisibility()); pipeline.InsertBefore(typeof(ExpandDuckTypedExpressions), new ProcessAssignmentToDuckMembers()); pipeline.Replace(typeof(ProcessMethodBodiesWithDuckTyping), new ProcessUnityScriptMethods()); pipeline.InsertAfter(typeof(ProcessUnityScriptMethods), new AutoExplodeVarArgsInvocations()); pipeline.InsertAfter(typeof(ProcessUnityScriptMethods), new ProcessEvalInvocations()); UnityScriptCompilerModule.ReplaceOptional(pipeline, typeof(ExpandDuckTypedExpressions), new ExpandUnityDuckTypedExpressions()); pipeline.InsertBefore(typeof(EmitAssembly), new Lint()); pipeline.InsertBefore(typeof(EmitAssembly), new EnableRawArrayIndexing()); pipeline.InsertAfter(typeof(BindBaseTypes), new CheckBaseTypes()); return pipeline; }
public Assembly Compile(ExtensionsFileSystemProvider provider) { var compiler = new BooCompiler(); var pipeline = Pipeline ??( Pipeline = new CompileToFile()); ExtensionsPreprocessorCompilerStep.Extend(pipeline); compiler.Parameters.Pipeline = pipeline; var files = provider.GetFileNames(); if(files.Length==0) { WriteLog("no input files provided"); } foreach (var fileName in files) { WriteLog("input added: " + fileName); compiler.Parameters.Input.Add(new FileInput(fileName)); } compiler.Parameters.References.Add(typeof (IRegistryLoader).Assembly); //need to use Comdiv.Core compiler.Parameters.References.Add(typeof (IDictionary<string, object>).Assembly); //need to use System WriteLog("compiler created"); //loading other dlls: foreach (var referencedAssembly in provider.GetReferencedAssemblies()) { WriteLog("add assembly " + referencedAssembly.GetName().Name); compiler.Parameters.References.Add(referencedAssembly); } compiler.Parameters.OutputAssembly = provider.GetLibraryPath(); WriteLog("output is setted : " + provider.GetLibraryPath()); WriteLog("start compiler"); var result = compiler.Run(); LastCompiledContext = result; if (result.Errors.Count != 0) { WriteLog("error occured!"); WriteLog(result.Errors.ToString()); ConsoleLogHost.Current.logerror(result.Errors.ToString()); throw new CompilerErrorException(result); } //if (result.Warnings.Count != 0) //{ // WriteLog("warrnings!"); // WriteLog(result.Warnings.ToString()); //} WriteLog("compilation successfull"); if(Pipeline is CompileToMemory) { return result.GeneratedAssembly; }else { return provider.LoadAssembly(); } }
public void CurrentStep() { var pipeline = new CompilerPipeline(); var step1 = new ActionStep(delegate {}); pipeline.Add(step1); ActionStep step2 = null; step2 = new ActionStep(() => Assert.AreSame(step2, pipeline.CurrentStep)); pipeline.Add(step2); var currentSteps = new Boo.Lang.List(); pipeline.Before += (sender, args) => currentSteps.Add(pipeline.CurrentStep); pipeline.BeforeStep += (sender, args) => currentSteps.Add(pipeline.CurrentStep); pipeline.AfterStep += (sender, args) => currentSteps.Add(pipeline.CurrentStep); pipeline.After += (sender, args) => currentSteps.Add(pipeline.CurrentStep); pipeline.Run(new CompilerContext()); Assert.AreEqual( new object[] { null, step1, step1, step2, step2, null }, currentSteps.ToArray()); }
public CompilerParameters(IReflectionTypeSystemProvider reflectionProvider, bool loadDefaultReferences) { _libPaths = new List<string>(); _systemDir = Permissions.WithDiscoveryPermission(() => GetSystemDir()); if (_systemDir != null) { _libPaths.Add(_systemDir); _libPaths.Add(Directory.GetCurrentDirectory()); } _pipeline = null; _input = new CompilerInputCollection(); _resources = new CompilerResourceCollection(); _compilerReferences = new CompilerReferenceCollection(reflectionProvider); _maxExpansionIterations = 12; _outputAssembly = String.Empty; _outputType = CompilerOutputType.Auto; _outputWriter = Console.Out; _debug = true; _checked = true; _generateInMemory = true; _stdLib = true; _delaySign = false; Strict = false; TraceLevel = TraceLevel.Off; if (loadDefaultReferences) LoadDefaultReferences(); }
protected override void CustomizeCompiler(BooCompiler compiler, CompilerPipeline pipeline, string[] urls) { pipeline.Insert(1, new ImplicitBaseClassCompilerStep(typeof (BaseScheduler), "Prepare", "Rhino.DSL.Tests.SchedulingDSL")); }
protected override void CustomizeCompiler(BooCompiler compiler, CompilerPipeline pipeline, string[] urls) { var steps = new List<ICompilerStep>(); steps.Add(new IncludeSupportStep(new PhantomDslEngine(importBuilders) {InIncludeMode = true})); if (!InIncludeMode) { steps.Add(new UnescapeNamesStep()); steps.Add(new ExpressionToTargetNameStep()); steps.Add(new ExpressionToDependencyNamesStep()); steps.Add(new ExpressionToCleanupNameStep()); steps.Add(new ExpressionToCallTargetNameStep()); steps.Add(new AutoReferenceFilesCompilerStep()); steps.Add(new TaskImportStep(importBuilders.ToArray())); steps.Add(new ImplicitBaseClassCompilerStep(typeof (PhantomBase), "Execute", typeof (UtilityFunctions).Namespace)); } steps.Reverse(); foreach (var step in steps) { pipeline.Insert(1, step); } if (!InIncludeMode) pipeline.InsertBefore(typeof (ProcessMethodBodiesWithDuckTyping), new AutoRunAllRunnablesStep()); compiler.Parameters.References.Add(typeof(UtilityFunctions).Assembly); }
public void SetUp() { _pipeline = new CompilerPipeline(); }
public static CompilerPipeline RawParsing() { CompilerPipeline pipeline; CompilerPipeline pipeline1 = pipeline = new CompilerPipeline(); pipeline.Add(new PreProcess()); pipeline.Add(new UnityScript.Steps.Parse()); return pipeline; }
void ViewFactory_PreparePipeline(CompilerPipeline obj) { obj.Replace(typeof (TransformToBrailStep),new MONORAILTransformToBrailStep(this.Options)); }
public void ExecutionOrder() { var order = new List<string>(); var p1 = new ActionStep(() => order.Add("p1")); var p2 = new ActionStep(() => order.Add("p2")); var pipeline = new CompilerPipeline { p1, p2 }; pipeline.Run(new CompilerContext()); Assert.AreEqual(new[] { "p1", "p2" }, order.ToArray()); }
protected override void AddCompilerSteps(BooCompiler compiler, string filename, CompilerPipeline pipeline) { compiler.Parameters.Pipeline.Insert(1, new ImplicitBaseClassCompilerStep(typeof (MyAnonymousBaseClass), "Run")); }
protected override void AddCompilerSteps(BooCompiler compiler, string filename, CompilerPipeline pipeline) { pipeline.Insert(1, new AutoReferenceFilesCompilerStep(Path.GetDirectoryName(filename))); }
protected override void AddCompilerSteps(BooCompiler compiler, string filename, CompilerPipeline pipeline) { compiler.Parameters.References.Add(typeof(XmlDocument).Assembly); pipeline.Insert(1, new AutoImportCompilerStep("System.Xml")); }
protected override void CustomizeCompiler(BooCompiler compiler, CompilerPipeline pipeline, string[] urls) { ParameterDeclarationCollection parameters = new ParameterDeclarationCollection(); ParameterDeclaration newParameterDeclaration = new ParameterDeclaration("input", new SimpleTypeReference("System.String")); parameters.Add(newParameterDeclaration); pipeline.Insert(1, new ImplicitBaseClassCompilerStep(typeof(MyClassWithParams), "Hello", parameters, "System")); }
protected override void CustomizeCompiler(BooCompiler compiler, CompilerPipeline pipeline, string[] urls) { compiler.Parameters.Ducky = true; pipeline.Insert(1, new ImplicitBaseClassCompilerStep(typeof(Service), "ConfigureService", "DslConfig", "System")); }