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();
 }
        public static void Prepare(Parse result)
        {
#if LIB2
            if(-1!=result.Find(typeof(Parsing))){
                result.InsertAfter(typeof (Parsing), new IncludeAstMacroExpandStep());
            }else if (-1!=result.Find(typeof(WSABooParsingStep))){
                result.InsertAfter(typeof(WSABooParsingStep), new IncludeAstMacroExpandStep());
            }
#else
            if (-1 != result.Find(typeof(BooParsingStep)))
            {
                result.InsertAfter(typeof(BooParsingStep), new IncludeAstMacroExpandStep());
            }
            else if (-1 != result.Find(typeof(WSABooParsingStep)))
            {
                result.InsertAfter(typeof(WSABooParsingStep), new IncludeAstMacroExpandStep());
            }
#endif
        }
Esempio n. 3
0
		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;
		}
Esempio n. 4
0
        public void strict_mode()
        {
            var pipe = new Parse();
            //pipe.InsertAfter(typeof(Boo.Lang.Parser.BooParsingStep), new ExpandBmlStep());
            //pipe.Add(new Boo.Lang.Compiler.Steps.PrintAst());
            TextWriter target = new StringWriter();
            checkMacro(@"
#pragma boo
bml ex=(div,span):
    div x,1,cust=test:
        style:
            """"""
    .x {weight:12;}
            """"""

        span y:
            'body'
",
 @"bml ex = (div, span):
	bmlelement div, ___start, ___end, x, 1, cust = test:
		style :
			__write('\r\n    .x {weight:12;}\r\n            ')
		bmlelement span, ___start, ___end, y:
			__write('body')", pipe, Console.Out
                );

        }