public void Run(string text)
{
BooCompiler compiler = new BooCompiler();
compiler.Parameters.Ducky = true;
compiler.Parameters.Pipeline = new CompileToMemory();
compiler.Parameters.Input.Add(new StringInput("Script", text));
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
compiler.Parameters.References.Add(assembly);
}
CompilerContext context = compiler.Run();
if (context.GeneratedAssembly == null)
{
if (context.Errors.Count > 0)
{
errors = context.Errors.ToString(true);
}
return;
}
try
{
Type[] types = context.GeneratedAssembly.GetTypes();
Type scriptModule = types[types.Length - 1];
MethodInfo mainEntry = scriptModule.Assembly.EntryPoint;
mainEntry.Invoke(null, new object[mainEntry.GetParameters().Length]);
}
catch (Exception ex)
{
errors = ex.Message;
}
}
protected override Type CompileMigration(MigrationReference migrationReference)
{
BooCompiler compiler = new BooCompiler();
compiler.Parameters.Input.Add(new FileInput(migrationReference.Path));
compiler.Parameters.References.Add(typeof(IDatabaseMigration).Assembly);
foreach (string reference in _configuration.References)
{
_log.Debug("Referencing: " + reference);
compiler.Parameters.References.Add(Assembly.LoadFrom(reference));
}
compiler.Parameters.OutputType = CompilerOutputType.Library;
compiler.Parameters.GenerateInMemory = true;
compiler.Parameters.OutputAssembly = Path.Combine(_workingDirectoryManager.WorkingDirectory, Path.GetFileNameWithoutExtension(migrationReference.Path) + ".dll");
compiler.Parameters.Ducky = true;
compiler.Parameters.Pipeline = new CompileToFile();
CompilerContext cc = compiler.Run();
if (cc.Errors.Count > 0)
{
foreach (CompilerError error in cc.Errors)
{
_log.ErrorFormat("{0}", error);
}
throw new InvalidOperationException();
}
if (cc.GeneratedAssembly == null)
{
throw new InvalidOperationException();
}
return MigrationHelpers.LookupMigration(cc.GeneratedAssembly, migrationReference);
}
public override Assembly Compile(string path, string outPath, bool cache)
{
Assembly asm = null;
try
{
if (this.ExistsAndUpToDate(path, outPath) && cache)
return Assembly.LoadFrom(outPath);
// Precompile script to a temp file
var precompiled = this.PreCompile(File.ReadAllText(path));
var tmp = Path.GetTempFileName();
File.WriteAllText(tmp, precompiled);
// Compile
var compiler = new Boo.Lang.Compiler.BooCompiler();
compiler.Parameters.AddAssembly(typeof(Log).Assembly);
compiler.Parameters.AddAssembly(Assembly.GetEntryAssembly());
compiler.Parameters.Input.Add(new FileInput(tmp));
compiler.Parameters.OutputAssembly = outPath;
compiler.Parameters.Pipeline = new CompileToFile();
#if DEBUG
compiler.Parameters.Debug = true;
#else
compiler.Parameters.Debug = false;
#endif
var context = compiler.Run();
if (context.GeneratedAssembly == null)
{
var errors = context.Errors;
var newExs = new CompilerErrorsException();
foreach (var err in errors)
{
var newEx = new CompilerError(path, err.LexicalInfo.Line, err.LexicalInfo.Column, err.Message, false);
newExs.Errors.Add(newEx);
}
throw newExs;
}
asm = context.GeneratedAssembly;
}
catch (CompilerErrorsException)
{
throw;
}
catch (UnauthorizedAccessException)
{
// Thrown if file can't be copied. Happens if script was
// initially loaded from cache.
}
catch (Exception ex)
{
Log.Exception(ex);
}
return asm;
}
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();
}
private void RunCompilerStepAfterExpressionResolutionOn(CompileUnit compileUnit, ICompilerStep step)
{
var pipeline = new Boo.Lang.Compiler.Pipelines.ResolveExpressions { step };
var compiler = new Boo.Lang.Compiler.BooCompiler(new CompilerParameters { Pipeline = pipeline });
var result = compiler.Run(compileUnit);
if (result.Errors.Count > 0)
Assert.Fail(result.Errors.ToString(true));
}
public override Assembly Compile(string path, string outPath)
{
Assembly asm = null;
try
{
if (this.ExistsAndUpToDate(path, outPath))
{
return(Assembly.LoadFrom(outPath));
}
var compiler = new Boo.Lang.Compiler.BooCompiler();
compiler.Parameters.AddAssembly(typeof(Log).Assembly);
compiler.Parameters.AddAssembly(typeof(ScriptManager).Assembly);
compiler.Parameters.Input.Add(new FileInput(path));
compiler.Parameters.OutputAssembly = outPath;
compiler.Parameters.Pipeline = new CompileToFile();
var context = compiler.Run();
if (context.GeneratedAssembly == null)
{
var errors = context.Errors;
var newExs = new CompilerErrorsException();
foreach (var err in errors)
{
var newEx = new CompilerError(path, err.LexicalInfo.Line, err.LexicalInfo.Column, err.Message, false);
newExs.Errors.Add(newEx);
}
throw newExs;
}
asm = context.GeneratedAssembly;
//this.SaveAssembly(asm, outPath);
}
catch (CompilerErrorsException)
{
throw;
}
catch (UnauthorizedAccessException)
{
// Thrown if file can't be copied. Happens if script was
// initially loaded from cache.
}
catch (Exception ex)
{
Log.Exception(ex);
}
return(asm);
}
public override Assembly Compile(string path, string outPath)
{
Assembly asm = null;
try
{
if (this.ExistsAndUpToDate(path, outPath))
return Assembly.LoadFrom(outPath);
var compiler = new Boo.Lang.Compiler.BooCompiler();
compiler.Parameters.AddAssembly(typeof(Log).Assembly);
compiler.Parameters.AddAssembly(typeof(ScriptManager).Assembly);
compiler.Parameters.Input.Add(new FileInput(path));
compiler.Parameters.OutputAssembly = outPath;
compiler.Parameters.Pipeline = new CompileToFile();
var context = compiler.Run();
if (context.GeneratedAssembly == null)
{
var errors = context.Errors;
var newExs = new CompilerErrorsException();
foreach (var err in errors)
{
var newEx = new CompilerError(path, err.LexicalInfo.Line, err.LexicalInfo.Column, err.Message, false);
newExs.Errors.Add(newEx);
}
throw newExs;
}
asm = context.GeneratedAssembly;
//this.SaveAssembly(asm, outPath);
}
catch (CompilerErrorsException)
{
throw;
}
catch (UnauthorizedAccessException)
{
// Thrown if file can't be copied. Happens if script was
// initially loaded from cache.
}
catch (Exception ex)
{
Log.Exception(ex);
}
return asm;
}
protected Assembly Compile(string filename, CompilerOutputType compilerOutputType)
{
BooCompiler compiler = new BooCompiler();
compiler.Parameters.OutputType = compilerOutputType;
compiler.Parameters.GenerateInMemory = true;
compiler.Parameters.Pipeline = new CompileToMemory();
AddCompilerSteps(compiler, filename, compiler.Parameters.Pipeline);
compiler.Parameters.Input.Add(new FileInput(filename));
CompilerContext run = compiler.Run();
if (run.Errors.Count > 0)
throw new CompilerError(run.Errors.ToString(true));
return run.GeneratedAssembly;
}
public void MacroMacroCompilation()
{
CompilerParameters parameters = new CompilerParameters(false);
parameters.References.Add(typeof(IEnumerable<>).Assembly);
parameters.Input.Add(BooLangExtensionsSource("Macros/MacroMacro.boo"));
parameters.Input.Add(BooLangExtensionsSource("Macros/AssertMacro.boo"));
parameters.Pipeline = new Boo.Lang.Compiler.Pipelines.ResolveExpressions();
Boo.Lang.Compiler.BooCompiler compiler = new Boo.Lang.Compiler.BooCompiler(parameters);
CompilerContext results = compiler.Run();
Assert.AreEqual(0, results.Errors.Count, results.Errors.ToString());
}
public int Run(string[] args)
{
int resultCode = 127;
AppDomain.CurrentDomain.AssemblyResolve += AssemblyResolve;
CheckBooCompiler();
var parameters = new CompilerParameters(false);
try
{
var setupTime = Stopwatch.StartNew();
CommandLineParser.ParseInto(parameters, args);
if (0 == parameters.Input.Count)
throw new ApplicationException(ResourceManager.GetString("BooC.NoInputSpecified"));
var compiler = new BooCompiler(parameters);
setupTime.Stop();
var processingTime = Stopwatch.StartNew();
var context = compiler.Run();
processingTime.Stop();
if (context.Warnings.Count > 0)
{
Console.Error.WriteLine(context.Warnings);
Console.Error.WriteLine(Boo.Lang.ResourceManager.Format("BooC.Warnings", context.Warnings.Count));
}
if (context.Errors.Count == 0)
resultCode = 0;
else
{
foreach (CompilerError error in context.Errors)
Console.Error.WriteLine(error.ToString(parameters.TraceInfo));
Console.Error.WriteLine(ResourceManager.Format("BooC.Errors", context.Errors.Count));
}
if (parameters.TraceWarning)
Console.Error.WriteLine(ResourceManager.Format("BooC.ProcessingTime", parameters.Input.Count, processingTime.ElapsedMilliseconds, setupTime.ElapsedMilliseconds));
}
catch (Exception x)
{
var message = (parameters.TraceWarning) ? (object)x : (object)x.Message;
Console.Error.WriteLine(ResourceManager.Format("BooC.FatalError", message));
}
return resultCode;
}
public static Assembly CompileString(string code)
{
var compiler = new BooCompiler(new CompilerParameters(false));
compiler.Parameters.GenerateInMemory = true;
compiler.Parameters.Pipeline = new NihPipeline();
compiler.Parameters.Input.Add(new StringInput("string.nih", code));
var result = compiler.Run();
if (result.Errors.Count > 0)
throw new CompilationErrorsException(result.Errors);
return result.GeneratedAssembly;
}
public void EnvironmentBindingsCanBeCustomizedThroughCompilerParametersEnvironment()
{
EntityFormatter actualFormatter = null;
var expectedFormatter = new EntityFormatter();
var compiler = new Boo.Lang.Compiler.BooCompiler();
compiler.Parameters.Pipeline = new CompilerPipeline {
new ActionStep(() => actualFormatter = My <EntityFormatter> .Instance)
};
compiler.Parameters.Environment = new ClosedEnvironment(expectedFormatter);
compiler.Run();
Assert.AreSame(expectedFormatter, actualFormatter);
}
public void TransformerIsAppliedToCompileUnit()
{
StubTransformer transformer = new StubTransformer();
TransformerCompilerStep transformerStep = new TransformerCompilerStep(transformer);
CompileUnit unit = new CompileUnit();
BooCompiler compiler = new BooCompiler();
compiler.Parameters.Pipeline = new CompilerPipeline();
compiler.Parameters.Pipeline.Insert(0, transformerStep);
compiler.Run(unit);
Assert.IsTrue(transformer.CompileUnitVisited);
}
public void MacroMacroCompilation()
{
CompilerParameters parameters = new CompilerParameters(false);
parameters.References.Add(typeof(IEnumerable <>).Assembly);
parameters.Input.Add(BooLangExtensionsSource("Macros/MacroMacro.boo"));
parameters.Input.Add(BooLangExtensionsSource("Macros/AssertMacro.boo"));
parameters.Pipeline = new Boo.Lang.Compiler.Pipelines.ResolveExpressions();
Boo.Lang.Compiler.BooCompiler compiler = new Boo.Lang.Compiler.BooCompiler(parameters);
CompilerContext results = compiler.Run();
Assert.AreEqual(0, results.Errors.Count, results.Errors.ToString());
}
public BooExpression(string expression)
{
var script = string.Format(Scripts.Boo, expression);
var booC = new BooCompiler();
booC.Parameters.Input.Add(new StringInput("test", script));
booC.Parameters.Pipeline = new CompileToMemory();
var compiler = booC.Run();
if (compiler.Errors.Count > 0)
throw compiler.Errors[0];
var invoker = MethodCache.Do.GetInvoker(
compiler.GeneratedAssembly.GetType("TestModule").GetMethod("evaluate"));
evaluator = x => (bool)(invoker(null, new ValueBagFu(x)) ?? false);
}
private void RunCompilerStepAfterExpressionResolutionOn(CompileUnit compileUnit, ICompilerStep step)
{
var pipeline = new Boo.Lang.Compiler.Pipelines.ResolveExpressions {
step
};
var compiler = new Boo.Lang.Compiler.BooCompiler(new CompilerParameters {
Pipeline = pipeline
});
var result = compiler.Run(compileUnit);
if (result.Errors.Count > 0)
{
Assert.Fail(result.Errors.ToString(true));
}
}
// practically the same as ForceCompile, but without saving to disk
CompilerContext IIncludeCompiler.CompileInclude(string url)
{
if (!InIncludeMode)
throw new InvalidOperationException("Cannot CompileInclude when not in include mode.");
var compiler = new BooCompiler {
Parameters = {OutputType = CompilerOutputType, GenerateInMemory = true, Pipeline = new Parse()}
};
CustomizeCompiler(compiler, compiler.Parameters.Pipeline, new[] {url});
AddInput(compiler, url);
var compilerContext = compiler.Run();
if (compilerContext.Errors.Count != 0) {
throw CreateCompilerException(compilerContext);
}
HandleWarnings(compilerContext.Warnings);
return compilerContext;
}
/// <summary>
/// Loads this instance.
/// </summary>
public override void LoadOrExecute()
{
var compiler = new BooCompiler();
foreach (Assembly assembly in References) {
compiler.Parameters.AddAssembly(assembly);
}
string outputDir = CompilerOutput;
if (!string.IsNullOrEmpty(outputDir))
outputDir = System.IO.Path.GetFullPath(outputDir);
else
outputDir = System.IO.Path.GetDirectoryName(Filename);
string outputAssembly = System.IO.Path.Combine(
outputDir,
AssemblyPrefix + System.IO.Path.GetFileNameWithoutExtension(Filename) + ".dll");
if (File.Exists(outputAssembly) &&
File.GetLastWriteTime(outputAssembly) > File.GetLastWriteTime(Filename)) {
GeneratedAssembly = Assembly.LoadFrom(outputAssembly);
InvokeEntryPoint();
return;
}
compiler.Parameters.Input.Add(new FileInput(Filename));
//compiler.Parameters.Pipeline = new CompileToMemory();
compiler.Parameters.Pipeline = new CompileToFile();
#if DEBUG
compiler.Parameters.Debug = true;
#else
compiler.Parameters.Debug = false;
#endif
compiler.Parameters.OutputAssembly = outputAssembly;
compiler.Parameters.OutputType = CompilerOutputType.ConsoleApplication;
compiler.Parameters.Ducky = false;
_context = compiler.Run();
GeneratedAssembly = _context.GeneratedAssembly;
if (GeneratedAssembly == null)
ThrowError(Filename, _context);
InvokeEntryPoint();
}
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 CompilerErrorCollection Run(params string[] args){
var referencedAssemblies = ExtractAssemblies();
var pipeline = ExtractPipeline() ?? new CompileToFile();
var parameters = new CompilerParameters(true);
//parameters.Ducky = true;
parameters.LibPaths.Add(Environment.CurrentDirectory);
parameters.LibPaths.Add(Path.Combine(Environment.CurrentDirectory, "bin"));
parameters.OutputAssembly = "script.dll";
foreach (var assembly in referencedAssemblies){
parameters.AddAssembly(assembly);
parameters.References.Add(assembly);
}
parameters.Pipeline = pipeline;
var compiler = new BooCompiler(parameters);
parameters.Input.Add(new ReaderInput("script", new StringReader(BooScript)));
var result = compiler.Run();
if (result.Errors.yes()) return result.Errors;
var resultAssembly = result.GeneratedAssembly;
var global__ = resultAssembly.getTypesWithAttribute<GlobalsHandlingClassAttribute>();
var global = global__.no() ? null : global__.FirstOrDefault();
if (global.yes() && Globals.Count != 0){
foreach (var pair in Globals){
var pi = global.GetProperty(pair.Key, BindingFlags.Static | BindingFlags.Public | BindingFlags.SetProperty);
if (null == pi) throw new Exception("Нет статического свойства с именем " + pair.Key);
pi.SetValue(null, pair.Key, null);
}
}
resultAssembly.EntryPoint.Invoke(null, new[]{args});
return null;
}
public void TestWithDocPath()
{
var parameters = new CompilerParameters();
CommandLineParser.ParseInto(parameters,
new string[] { "/doc:TestDoc.xml", "/target:library", "/o:TestDoc.dll", "TestDoc.boo" });
var compiler = new BooCompiler(parameters);
var context=compiler.Run();
if (context.Errors.Count > 0)
{
Console.WriteLine(context.Errors);
throw new AssertionException(context.Errors[0].ToString());
}
var reference = new XmlDocument();
reference.Load("TestDocReference.xml");
var result = new XmlDocument();
result.Load("TestDoc.xml");
Assert.AreEqual(reference.ToString(), result.ToString());
}
public static void Compile(int tabSize, IEnumerable<Assembly> assemblies, IEnumerable<CompileResults> codeFiles)
{
var pipeline = CompilerPipeline.GetPipeline("compile");
pipeline.BreakOnErrors = false;
var compiler = new BooCompiler(new CompilerParameters(false) { Pipeline = pipeline });
compiler.Parameters.Environment =
new ClosedEnvironment(
new ParserSettings
{
TabSize= tabSize
});
compiler.Parameters.Input.Clear();
compiler.Parameters.References.Clear();
foreach (var assembly in assemblies)
compiler.Parameters.References.Add(assembly);
var results = new Dictionary<string, CompileResults>();
foreach (var codeFile in codeFiles)
{
results.Add(codeFile.Url, codeFile);
codeFile.SetupForCompilation(compiler.Parameters);
}
compiler.Parameters.Pipeline.AfterStep +=
(sender, args) =>
{
if (args.Step == pipeline[0])
MapParsedNodes(results, args.Context);
if (args.Step == pipeline[pipeline.Count - 1])
MapCompleted(results, args.Context);
};
// as a part of compilation process compiler might request assembly load which triggers an assembly
// resolve event to be processed by type resolver. Such processing has to happen on the same thread the
// resolver has been created on
compiler.Run();
}
void AssertCultureDependentMessage(string message, CultureInfo culture)
{
CultureInfo savedCulture = Thread.CurrentThread.CurrentUICulture;
Thread.CurrentThread.CurrentUICulture = culture;
try
{
Boo.Lang.Compiler.BooCompiler compiler = new Boo.Lang.Compiler.BooCompiler();
CompilerParameters options = compiler.Parameters;
options.Input.Add(new Boo.Lang.Compiler.IO.StringInput("testcase", TestCase));
options.Pipeline = new Boo.Lang.Compiler.Pipelines.Parse();
CompilerErrorCollection errors = compiler.Run().Errors;
Assert.AreEqual(1, errors.Count);
Assert.AreEqual(message, errors[0].Message);
}
finally
{
Thread.CurrentThread.CurrentUICulture = savedCulture;
}
}
void AssertCultureDependentMessage(string message, CultureInfo culture)
{
CultureInfo savedCulture = Thread.CurrentThread.CurrentUICulture;
Thread.CurrentThread.CurrentUICulture = culture;
try
{
Boo.Lang.Compiler.BooCompiler compiler = new Boo.Lang.Compiler.BooCompiler();
CompilerParameters options = compiler.Parameters;
options.Input.Add(new Boo.Lang.Compiler.IO.StringInput("testcase", TestCase));
options.Pipeline = new Boo.Lang.Compiler.Pipelines.Parse();
CompilerErrorCollection errors = compiler.Run().Errors;
Assert.AreEqual(1, errors.Count);
Assert.AreEqual(message, errors[0].Message);
}
finally
{
Thread.CurrentThread.CurrentUICulture = savedCulture;
}
}
public IEnumerable<Node> Substitute(MacroStatement callPointMacro){
var compiler = new BooCompiler();
compiler.Parameters.Pipeline = new CompilerPipeline();
compiler.Parameters.Pipeline.Add(new BooParsingStep());
compiler.Parameters.Input.Add(new StringInput("_code_", Code));
var compileresult = compiler.Run();
Node target = callPointMacro.ParentNode;
while(!(target==null||(target is TypeDefinition))){
target = target.ParentNode;
}
if (null != target){
foreach (var member in compileresult.CompileUnit.Modules[0].Members){
((TypeDefinition)target).Members.Add(member);
}
}
var result = new Block(callPointMacro.LexicalInfo);
foreach (var statement in compileresult.CompileUnit.Modules[0].Globals.Statements)
{
yield return statement;
}
}
private CompilerContext Compile(string url)
{
TextReader input = urlResolver(url, baseDirectory ?? Path.GetDirectoryName(url));
CompilerParameters parameters = SafeCloneParameters(Parameters);
parameters.Input.Add(new ReaderInput(url, input));
BooCompiler compiler = new BooCompiler(parameters);
return compiler.Run();
}
private ICompilationUnit Parse(IProjectContent projectContent, string fileName, int[] lineLength, BooCompiler compiler)
{
compiler.Parameters.OutputWriter = new StringWriter();
compiler.Parameters.TraceLevel = System.Diagnostics.TraceLevel.Off;
// Compile pipeline as of Boo 0.9.2:
// Boo.Lang.Compiler.Pipelines.Parse:
// Boo.Lang.Parser.BooParsingStep
// Boo.Lang.Compiler.Pipelines.ExpandMacros:
// Boo.Lang.Compiler.Steps.InitializeTypeSystemServices
// Boo.Lang.Compiler.Steps.PreErrorChecking
// Boo.Lang.Compiler.Steps.MergePartialClasses
// Boo.Lang.Compiler.Steps.InitializeNameResolutionService
// Boo.Lang.Compiler.Steps.IntroduceGlobalNamespaces
// Boo.Lang.Compiler.Steps.TransformCallableDefinitions
// Boo.Lang.Compiler.Steps.BindTypeDefinitions
// Boo.Lang.Compiler.Steps.BindGenericParameters
// Boo.Lang.Compiler.Steps.BindNamespaces
// Boo.Lang.Compiler.Steps.BindBaseTypes
// Boo.Lang.Compiler.Steps.MacroAndAttributeExpansion
// Boo.Lang.Compiler.Pipelines.ResolveExpressions:
// Boo.Lang.Compiler.Steps.ExpandAstLiterals
// Boo.Lang.Compiler.Steps.IntroduceModuleClasses
// Boo.Lang.Compiler.Steps.NormalizeStatementModifiers
// Boo.Lang.Compiler.Steps.NormalizeTypeAndMemberDefinitions
// Boo.Lang.Compiler.Steps.NormalizeOmittedExpressions
// Boo.Lang.Compiler.Steps.BindTypeDefinitions
// Boo.Lang.Compiler.Steps.BindGenericParameters
// Boo.Lang.Compiler.Steps.BindEnumMembers
// Boo.Lang.Compiler.Steps.BindBaseTypes
// Boo.Lang.Compiler.Steps.CheckMemberTypes
// Boo.Lang.Compiler.Steps.BindMethods
// Boo.Lang.Compiler.Steps.ResolveTypeReferences
// Boo.Lang.Compiler.Steps.BindTypeMembers
// Boo.Lang.Compiler.Steps.CheckGenericConstraints
// Boo.Lang.Compiler.Steps.ProcessInheritedAbstractMembers
// Boo.Lang.Compiler.Steps.CheckMemberNames
// Boo.Lang.Compiler.Steps.ProcessMethodBodiesWithDuckTyping
// Boo.Lang.Compiler.Steps.PreProcessExtensionMethods
// Boo.Lang.Compiler.Pipelines.Compile:
// Boo.Lang.Compiler.Steps.ConstantFolding
// Boo.Lang.Compiler.Steps.NormalizeLiterals
// Boo.Lang.Compiler.Steps.OptimizeIterationStatements
// Boo.Lang.Compiler.Steps.BranchChecking
// Boo.Lang.Compiler.Steps.CheckIdentifiers
// Boo.Lang.Compiler.Steps.StricterErrorChecking
// Boo.Lang.Compiler.Steps.CheckAttributesUsage
// Boo.Lang.Compiler.Steps.ExpandDuckTypedExpressions
// Boo.Lang.Compiler.Steps.ProcessAssignmentsToValueTypeMembers
// Boo.Lang.Compiler.Steps.ExpandProperties
// Boo.Lang.Compiler.Steps.RemoveDeadCode
// Boo.Lang.Compiler.Steps.CheckMembersProtectionLevel
// Boo.Lang.Compiler.Steps.NormalizeIterationStatements
// Boo.Lang.Compiler.Steps.ProcessSharedLocals
// Boo.Lang.Compiler.Steps.ProcessClosures
// Boo.Lang.Compiler.Steps.ProcessGenerators
// Boo.Lang.Compiler.Steps.ExpandVarArgsMethodInvocations
// Boo.Lang.Compiler.Steps.InjectCallableConversions
// Boo.Lang.Compiler.Steps.ImplementICallableOnCallableDefinitions
// Boo.Lang.Compiler.Steps.CheckNeverUsedMembers
// Boo.Lang.Compiler.Pipelines.CompileToMemory:
// Boo.Lang.Compiler.Steps.EmitAssembly
// Boo.Lang.Compiler.Pipelines.CompileToFile:
// Boo.Lang.Compiler.Steps.SaveAssembly
CompilerPipeline compilePipe = new Parse();
compilePipe.Add(new InitializeTypeSystemServices());
compilePipe.Add(new PreErrorChecking());
compilePipe.Add(new MergePartialClasses());
compilePipe.Add(new InitializeNameResolutionService());
compilePipe.Add(new IntroduceGlobalNamespaces());
// TransformCallableDefinitions: not used for CC
compilePipe.Add(new BindTypeDefinitions());
compilePipe.Add(new BindGenericParameters());
compilePipe.Add(new BindNamespacesWithoutRemovingErrors());
compilePipe.Add(new BindBaseTypes());
compilePipe.Add(new MacroAndAttributeExpansion());
compilePipe.Add(new IntroduceModuleClasses());
BooParsingStep parsingStep = (BooParsingStep)compilePipe[0];
parsingStep.TabSize = 1;
ConvertVisitor visitor = new ConvertVisitor(lineLength, projectContent);
visitor.Cu.FileName = fileName;
compilePipe.Add(visitor);
compilePipe.BreakOnErrors = false;
compiler.Parameters.Pipeline = compilePipe;
compiler.Parameters.References.Add(typeof(Boo.Lang.Useful.Attributes.SingletonAttribute).Assembly);
int errorCount = 0;
compilePipe.AfterStep += delegate(object sender, CompilerStepEventArgs args) {
if (args.Step == parsingStep)
errorCount = args.Context.Errors.Count;
};
try {
compiler.Run();
visitor.Cu.ErrorsDuringCompile = errorCount > 0;
} catch (Exception ex) {
MessageService.ShowError(ex);
}
return visitor.Cu;
}
public int Run(string[] args)
{
int resultCode = -1;
AppDomain.CurrentDomain.AssemblyResolve += new ResolveEventHandler(AssemblyResolve);
CheckBooCompiler();
try
{
DateTime start = DateTime.Now;
_options = new CompilerParameters(false); //false means no stdlib loading yet
_options.GenerateInMemory = false;
ArrayList tempLibPaths = _options.LibPaths.Clone() as ArrayList;
_options.LibPaths.Clear();
BooCompiler compiler = new BooCompiler(_options);
ParseOptions(args);
if (0 == _options.Input.Count)
{
throw new ApplicationException(Boo.Lang.ResourceManager.GetString("BooC.NoInputSpecified"));
}
//move standard libpaths below any new ones:
foreach(object o in tempLibPaths)
_options.LibPaths.Add(o);
if (_options.StdLib)
{
_options.LoadDefaultReferences();
}
else if (!_noConfig)
{
_references.Insert(0, "mscorlib");
}
LoadReferences();
ConfigurePipeline();
if (_options.TraceSwitch.TraceInfo)
{
compiler.Parameters.Pipeline.BeforeStep += new CompilerStepEventHandler(OnBeforeStep);
compiler.Parameters.Pipeline.AfterStep += new CompilerStepEventHandler(OnAfterStep);
}
TimeSpan setupTime = DateTime.Now - start;
start = DateTime.Now;
CompilerContext context = compiler.Run();
TimeSpan processingTime = DateTime.Now - start;
if (context.Warnings.Count > 0)
{
Console.Error.WriteLine(context.Warnings);
Console.Error.WriteLine(Boo.Lang.ResourceManager.Format("BooC.Warnings", context.Warnings.Count));
}
if (context.Errors.Count > 0)
{
foreach (CompilerError error in context.Errors)
{
Console.Error.WriteLine(error.ToString(_options.TraceSwitch.TraceInfo));
}
Console.Error.WriteLine(Boo.Lang.ResourceManager.Format("BooC.Errors", context.Errors.Count));
}
else
{
resultCode = 0;
}
if (_options.TraceSwitch.TraceWarning)
{
Console.Error.WriteLine(Boo.Lang.ResourceManager.Format("BooC.ProcessingTime", _options.Input.Count, processingTime.TotalMilliseconds, setupTime.TotalMilliseconds));
}
}
catch (Exception x)
{
object message = _options.TraceSwitch.TraceWarning ? (object)x : (object)x.Message;
Console.Error.WriteLine(Boo.Lang.ResourceManager.Format("BooC.FatalError", message));
}
return resultCode;
}
/// <summary>
/// Force a compile with no caching
/// </summary>
/// <param name="urls">The urls.</param>
/// <param name="cacheFileName">Name of the cache file.</param>
/// <returns></returns>
public virtual CompilerContext ForceCompile(string[] urls, string cacheFileName)
{
BooCompiler compiler = new BooCompiler();
compiler.Parameters.OutputType = CompilerOutputType;
compiler.Parameters.GenerateInMemory = true;
compiler.Parameters.Pipeline = new CompileToFile();
compiler.Parameters.OutputAssembly = cacheFileName;
CustomizeCompiler(compiler, compiler.Parameters.Pipeline, urls);
AddInputs(compiler, urls);
CompilerContext compilerContext = compiler.Run();
if (compilerContext.Errors.Count != 0)
throw CreateCompilerException(compilerContext);
HandleWarnings(compilerContext.Warnings);
return compilerContext;
}
public override bool Execute()
{
BooCompiler compiler = new BooCompiler();
if (OutputAssembly == null)
{
compiler.Parameters.Pipeline = new CompileToMemory();
}
else
{
compiler.Parameters.Pipeline = new CompileToFile();
compiler.Parameters.OutputAssembly = OutputAssembly.ItemSpec;
}
compiler.Parameters.OutputType = CompilerOutputType.ConsoleApplication;
if (files == null || files.Length == 0)
{
Log.LogError("Must specify at least one file for the book task");
return false;
}
foreach (ITaskItem taskItem in files)
{
FileInput input = new FileInput(taskItem.ItemSpec);
compiler.Parameters.Input.Add(input);
}
foreach (ITaskItem reference in references)
{
Assembly assembly = Assembly.LoadFrom(reference.ItemSpec);
compiler.Parameters.References.Add(assembly);
}
CompilerContext run = compiler.Run();
if (run.Errors.Count > 0)
{
string s = run.Errors.ToString(true);
Log.LogError("Failed to compile code: " + s);
return false;
}
MethodInfo methodInfo = run.GeneratedAssembly.EntryPoint;
if (methodInfo == null)
{
Log.LogError("Could not find entry point for the files");
return false;
}
try
{
methodInfo.Invoke(null, new object[] { new string[0] });
}
catch (TargetInvocationException e)
{
Log.LogError("Scripts failed to run!");
Log.LogError(e.InnerException.ToString());
}
return true;
}
private static BoostOutputter Compile(string booSource)
{
var booc = new BooCompiler();
booc.Parameters.Input.Add(new StringInput("Input", booSource));
booc.Parameters.Ducky = true;
booc.Parameters.References.Add(Assembly.GetAssembly(typeof(BoostOutputter)));
booc.Parameters.Pipeline = new CompileToMemory();
booc.Parameters.Pipeline[0] = new WSABooParsingStep();
var output = new StringBuilder();
var compilerContext = booc.Run();
if (null == compilerContext.GeneratedAssembly)
{
foreach (CompilerError error in compilerContext.Errors)
{
output.AppendLine(error.Message);
}
output.Append(booSource);
throw new Exception(output.ToString());
}
var booClassType = compilerContext.GeneratedAssembly.GetType("GeneratedOutputter", true, true);
return Activator.CreateInstance(booClassType) as BoostOutputter;
}
void BuildAdapter(Assembly assembly, string adapterNamespace, string adapterPath, string importsPath)
{
// There are several solutions to this:
// 1. Directly generate IL, optionally using some intermediate library
// 2. Generate Boo AST and compile it
// 3. Generate Boo code and compile it
// I am going with option 3, just because it is the easiest to debug and understand later
var referencedTypes = new HashSet<Type>();
var code = GenerateAdapterCode(assembly, adapterNamespace, referencedTypes);
var compiler = new BooCompiler {
Parameters = {
OutputType = CompilerOutputType.Library,
Pipeline = new CompileToFile(),
OutputAssembly = adapterPath,
Input = {new StringInput("integration.boo", code)}
}
};
compiler.Parameters.Pipeline.InsertBefore(typeof (ExpandAstLiterals), new UnescapeNamesStep());
compiler.Parameters.Pipeline.InsertBefore(typeof (ProcessMethodBodiesWithDuckTyping), new AutoRunAllRunnablesStep());
compiler.Parameters.References.Add(assembly);
compiler.Parameters.References.Add(GetType().Assembly);
foreach (var referencedAssembly in referencedTypes.Select(t => t.Assembly).Distinct()) {
compiler.Parameters.References.Add(referencedAssembly);
}
var result = compiler.Run();
if (result.Errors.Count > 0) {
File.WriteAllText(Path.ChangeExtension(adapterPath, ".boo"), code);
throw new CompilerError(result.Errors.ToString(true));
}
using (var writer = new StreamWriter(importsPath, false)) {
var imports = referencedTypes.Select(type => new {type.Namespace, type.Assembly}).Distinct();
foreach (var import in imports) {
writer.WriteLine(import.Namespace + "," + import.Assembly.Location);
}
}
}
private void RunBooScript(string file)
{
uint timer_id = Log.DebugTimerStart ();
BooCompiler compiler = new BooCompiler ();
compiler.Parameters.Ducky = true;
compiler.Parameters.Pipeline = new CompileToMemory ();
compiler.Parameters.Input.Add (new FileInput (file));
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies ()) {
compiler.Parameters.References.Add (assembly);
}
CompilerContext context = compiler.Run ();
if (context.GeneratedAssembly == null) {
foreach (CompilerError error in context.Errors) {
Log.Warning (String.Format ("BooScript: compiler error: {0} ({1})",
error.ToString (), file), false);
}
return;
}
try {
Type script_module = context.GeneratedAssembly.GetTypes ()[0];
if (script_module == null) {
Log.Warning (String.Format ("BooScript: could not find module in script ({0})", file), false);
return;
}
MethodInfo main_entry = script_module.Assembly.EntryPoint;
main_entry.Invoke (null, new object[main_entry.GetParameters ().Length]);
Log.DebugTimerPrint (timer_id, "BooScript: compiled and invoked: {0}");
} catch (Exception e) {
Log.Exception ("BooScript: scripted failed", e);
}
}
public CompilerResults CompileAssemblyFromSourceBatch(
CompilerParameters options, string [] sources)
{
if (null == options)
{
throw new ArgumentNullException("options");
}
if (null == sources)
{
throw new ArgumentNullException("fileNames");
}
CompilerResults results = new CompilerResults(options.TempFiles);
BooC.BooCompiler compiler = new BooC.BooCompiler();
BooC.CompilerParameters parameters = compiler.Parameters;
if (options.OutputAssembly == null)
{
options.OutputAssembly = GetTempFileNameWithExtension(options.TempFiles, "dll");
}
parameters.OutputAssembly = options.OutputAssembly;
// set compile options
if (options.GenerateInMemory)
{
parameters.Pipeline = new CompileToMemory();
}
else
{
parameters.Pipeline = new CompileToFile();
}
if (options.GenerateExecutable)
{
parameters.OutputType = BooC.CompilerOutputType.ConsoleApplication; // winexe ??
}
else
{
parameters.OutputType = BooC.CompilerOutputType.Library;
}
parameters.Debug = options.IncludeDebugInformation;
if (null != options.ReferencedAssemblies)
{
foreach (string import in options.ReferencedAssemblies)
{
parameters.References.Add(Assembly.LoadFrom(import));
}
}
foreach (string source in sources)
{
parameters.Input.Add(new StringInput("source", source));
}
// run the compiler
BooC.CompilerContext context = compiler.Run();
bool loadIt = processCompileResult(context, results);
if (loadIt)
{
results.CompiledAssembly = context.GeneratedAssembly;
//results.CompiledAssembly = Assembly.LoadFrom(options.OutputAssembly);
}
else
{
results.CompiledAssembly = null;
}
return(results);
}
public override Assembly Compile(string path, string outPath, bool cache)
{
Assembly asm = null;
try
{
if (this.ExistsAndUpToDate(path, outPath) && cache)
{
return(Assembly.LoadFrom(outPath));
}
// Precompile script to a temp file
var precompiled = this.PreCompile(File.ReadAllText(path));
var tmp = Path.GetTempFileName();
File.WriteAllText(tmp, precompiled);
// Compile
var compiler = new Boo.Lang.Compiler.BooCompiler();
compiler.Parameters.AddAssembly(typeof(Log).Assembly);
compiler.Parameters.AddAssembly(Assembly.GetEntryAssembly());
compiler.Parameters.Input.Add(new FileInput(tmp));
compiler.Parameters.OutputAssembly = outPath;
compiler.Parameters.Pipeline = new CompileToFile();
#if DEBUG
compiler.Parameters.Debug = true;
#else
compiler.Parameters.Debug = false;
#endif
var context = compiler.Run();
if (context.GeneratedAssembly == null)
{
var errors = context.Errors;
var newExs = new CompilerErrorsException();
foreach (var err in errors)
{
var newEx = new CompilerError(path, err.LexicalInfo.Line, err.LexicalInfo.Column, err.Message, false);
newExs.Errors.Add(newEx);
}
throw newExs;
}
asm = context.GeneratedAssembly;
}
catch (CompilerErrorsException)
{
throw;
}
catch (UnauthorizedAccessException)
{
// Thrown if file can't be copied. Happens if script was
// initially loaded from cache.
}
catch (Exception ex)
{
Log.Exception(ex);
}
return(asm);
}
private static AbstractConfigurationRunner GetConfigurationInstance(
string name, string environment, ICompilerInput input,
GenerationOptions generationOptions, ICompilerStep autoReferenceStep,
params string[] namespaces)
{
BooCompiler compiler = new BooCompiler();
compiler.Parameters.Ducky = true;
if (generationOptions == GenerationOptions.Memory)
compiler.Parameters.Pipeline = new CompileToMemory();
else
compiler.Parameters.Pipeline = new CompileToFile();
compiler.Parameters.Pipeline.Insert(1, autoReferenceStep);
compiler.Parameters.Pipeline.Insert(2, new BinsorCompilerStep(environment, namespaces));
compiler.Parameters.Pipeline.Replace(
typeof (ProcessMethodBodiesWithDuckTyping),
new TransformUnknownReferences());
compiler.Parameters.Pipeline.InsertAfter(typeof (TransformUnknownReferences),
new RegisterComponentAndFacilitiesAfterCreation());
compiler.Parameters.OutputType = CompilerOutputType.Library;
compiler.Parameters.Input.Add(input);
compiler.Parameters.References.Add(typeof (BooReader).Assembly);
compiler.Parameters.References.Add(typeof (MacroMacro).Assembly);
TryAddAssembliesReferences(compiler.Parameters, "Rhino.Commons.NHibernate", "Rhino.Commons.ActiveRecord");
CompilerContext run = compiler.Run();
if (run.Errors.Count != 0)
{
throw new CompilerError(string.Format("Could not compile configuration! {0}", run.Errors.ToString(true)));
}
Type type = run.GeneratedAssembly.GetType(name.Replace('.', '_'));
return Activator.CreateInstance(type) as AbstractConfigurationRunner;
}
public void EnvironmentBindingsCanBeCustomizedThroughCompilerParametersEnvironment()
{
EntityFormatter actualFormatter = null;
var expectedFormatter = new EntityFormatter();
var compiler = new Boo.Lang.Compiler.BooCompiler();
compiler.Parameters.Pipeline = new CompilerPipeline { new ActionStep(() => actualFormatter = My<EntityFormatter>.Instance) };
compiler.Parameters.Environment = new ClosedEnvironment(expectedFormatter);
compiler.Run();
Assert.AreSame(expectedFormatter, actualFormatter);
}
