public DslFactoryFixture()
        {
            factory = new DslFactory();
            mocks = new MockRepository();
            mockedDslEngine = mocks.DynamicMock<DslEngine>();
            mockCache = mocks.DynamicMock<IDslEngineCache>();
        	
			mockCache.WriteLock(null);
        	LastCall.Repeat.Any()
        		.IgnoreArguments()
        		.Do((Action<CacheAction>) ExecuteCachedAction);
			
			mockCache.ReadLock(null);
			LastCall.Repeat.Any()
				.IgnoreArguments()
				.Do((Action<CacheAction>)ExecuteCachedAction);
            
			IDslEngineStorage mockStorage = mocks.DynamicMock<IDslEngineStorage>();
            Assembly assembly = Assembly.GetCallingAssembly();
            context = new CompilerContext();
            context.GeneratedAssembly = assembly;
            mockedDslEngine.Storage = mockStorage;
            mockedDslEngine.Cache = mockCache;

            SetupResult.For(mockStorage.GetMatchingUrlsIn("", ref testUrl)).Return(new string[] { testUrl });
            SetupResult.For(mockStorage.IsUrlIncludeIn(null, null, null))
                .IgnoreArguments()
                .Return(true);
        }

        public GeneratorExpressionProcessor(CompilerContext context,
								ForeignReferenceCollector collector,
								GeneratorExpression node)
        {
            _collector = collector;
            _generator = node;
            Initialize(context);
        }

 public static ClassDefinition GetScriptClass(CompilerContext context)
 {
     object obj1 = context.get_Item("ScriptClass");
     if (!(obj1 is ClassDefinition))
     {
     }
     return (ClassDefinition) RuntimeServices.Coerce(obj1, typeof(ClassDefinition));
 }

		private static string RunThroughPreProcessor(string code)
		{
			var ppc = new BrailPreProcessor(new BooViewEngine());
			var context = new CompilerContext();
			context.Parameters.Input.Add(new StringInput("test", code));
			ppc.Initialize(context);
			ppc.Run();
			return context.Parameters.Input[0].Open().ReadToEnd();
		}

 public override void Initialize(CompilerContext context)
 {
     base.Initialize(context);
     Type type = typeof(UnityRuntimeServices.MemberValueTypeChange);
     this._valueTypeChangeConstructor = this.get_TypeSystemServices().Map(type.GetConstructors()[0]);
     this._valueTypeChangeType = this.get_TypeSystemServices().Map(typeof(UnityRuntimeServices.ValueTypeChange));
     Type type2 = typeof(UnityRuntimeServices.SliceValueTypeChange);
     this._sliceValueTypeChangeConstructor = this.get_TypeSystemServices().Map(type2.GetConstructors()[0]);
     this._propagateChanges = this.get_TypeSystemServices().Map(new __ProcessAssignmentToDuckMembers_Initialize$callable0$25_95__(UnityRuntimeServices.PropagateValueTypeChanges).Method);
 }

 public GeneratorMethodProcessor(CompilerContext context, InternalMethod method)
 {
     _labels = new List();
     _mapping = new Hashtable();
     _generator = method;
     _generatorItemType = (IType)_generator.Method["GeneratorItemType"];
     _enumerable = (BooClassBuilder)_generator.Method["GeneratorClassBuilder"];
     Debug.Assert(null != _generatorItemType);
     Debug.Assert(null != _enumerable);
     Initialize(context);
 }

		public CompilerContext Run(CompileUnit compileUnit)
		{
			if (null == compileUnit)
				throw new ArgumentNullException("compileUnit");
			if (null == _parameters.Pipeline)
				throw new InvalidOperationException(Boo.Lang.Resources.StringResources.BooC_CantRunWithoutPipeline);
			
			var context = new CompilerContext(_parameters, compileUnit);
			_parameters.Pipeline.Run(context);
			return context;
		}

        public static void MapParsedNodes(Dictionary<string, CompileResults> results, CompilerContext compilerContext)
        {
            foreach (var module in compilerContext.CompileUnit.Modules)
                results[module.LexicalInfo.FileName].MapParsedNodes(module);

            foreach (var error in compilerContext.Errors)
                results[error.LexicalInfo.FileName].MapParsingMessage(error);

            foreach (var warning in compilerContext.Warnings)
                results[warning.LexicalInfo.FileName].MapParsingMessage(warning);
        }

		/// <summary>
		/// Throws the error.
		/// </summary>
		/// <param name="filename">The filename.</param>
		/// <param name="context">The context.</param>
		internal static void ThrowError(string filename, CompilerContext context)
		{
			var errors = new List<string>();

			using (StreamWriter errorFile = File.CreateText(filename + ".errors")) {
				foreach (CompilerError error in context.Errors) {
					errorFile.WriteLine("= ERROR ========================================================================");
					errorFile.WriteLine(error);
					errorFile.WriteLine("================================================================================");
					errorFile.WriteLine();

					errors.Add(error.ToString());
				}

				errorFile.Flush();
			}

			throw new ScriptErrorException(filename, errors.ToArray());
		}

        private IEnumerable<Tuple<Assembly,string >> getmacronamespaces(CompilerContext context) {
            if (context["macronamespaces"] == null)
            {

                var macronamespaces = new List<Tuple<Assembly, string>>();
                context["macronamespaces"] = macronamespaces;
                foreach (ICompileUnit reference in context.References) {
                    try {
                        var a = reference.getPropertySafe<Assembly>("Assembly");
                        // импортирует автоматически макросы только из библиотек Comdiv - иначе жестокие тормоза и смысла главное никакого
                        if (a != null) {
                            var n = a.GetName().Name;
                            //HACK: due to performance issues uses only comdiv based libriries
                            if (!n.StartsWith("Comdiv.")) continue;
                            if (n.EndsWith(".Test")||n.EndsWith(".Tests")) continue;

         
                            var attrs = a.GetCustomAttributes(typeof(AssemblyBooMacroNamespaceAttribute), false);
                            if (attrs.Length != 0)
                            {
                                foreach (
                                    string ns in
                                        attrs.Cast<AssemblyBooMacroNamespaceAttribute>().Select(x => x.Namespace))
                                {
                                    macronamespaces.Add(Tuple.Create(a, ns));

                                }
                            }
                            
                        }
                    }
                    catch (Exception ex) {
                        context.TraceInfo("ошибка импорта пространства имен " + ex.Message);
                    }
                }
            }
            return (IEnumerable<Tuple<Assembly, string>>) context["macronamespaces"];
        }

		override public void Initialize(CompilerContext context)
		{
			base.Initialize(context);
			NameResolutionService.Reset();
		}

			public CompilationResult(CompilerContext context, BrailPreProcessor processor)
			{
				this.context = context;
				this.processor = processor;
			}

		}

		protected string Run(string stdin, out CompilerContext context)
		{
			var oldStdOut = Console.Out;
			var oldStdIn = Console.In;

			try
			{
				Console.SetOut(_output);
				if (stdin != null)
					Console.SetIn(new StringReader(stdin));

				context = _compiler.Run();

				if (HasErrors(context) && !IgnoreErrors)
				{
					Assert.Fail(GetFirstInputName(context)
								+ ": "
								+ context.Errors.ToString(true)
								+ context.Warnings);				
				}
				return _output.ToString().Replace("\r\n", "\n");
			}
			finally
			{
				_output.GetStringBuilder().Length = 0;

				Console.SetOut(oldStdOut);
				Console.SetIn(oldStdIn);

		}

		string GetFirstInputName(CompilerContext context)
		{

 protected override void OnAfter(CompilerContext context)
 {
     RunStep(context, new Boo.Lang.Compiler.Steps.PrintErrors());
 }

		}
		
		private bool HasErrors(CompilerContext context)
		{

		private CompilerContext LoadCompilerContext(string file)
		{
			if (!File.Exists(file)) 
				return null;

			Assembly assembly = null;
			ReadLock(delegate
			{
				if (assemblyCache.TryGetValue(file, out assembly) == false)
				{
					WriteLock(delegate
					{
						byte[] bytes = File.ReadAllBytes(file);
						assembly = Assembly.Load(bytes);
						assemblyCache[file] = assembly;
						AssemblyLoaded(file, assembly, true);
					});
				}
			});
			
			CompilerContext context = new CompilerContext();
			context.GeneratedAssembly = assembly;
			return context;
		}

 public CompilerStepEventArgs(CompilerContext context, ICompilerStep step)
 {
     this.Context = context;
     this.Step = step;
 }

		protected AbstractAstGeneratorMacro(CompilerContext context) : base (context)
		{
		}

 public override void Run(CompilerContext context)
 {
     base.Run(context);
     RunStep(context, new Boo.Lang.Compiler.Steps.PrintErrors());
 }