public object VisitCompilationUnit(CompilationUnit compilationUnit, object data)
		{
			module = new B.Module();
			module.LexicalInfo = new B.LexicalInfo(fileName, 1, 1);
			compilationUnit.AcceptChildren(this, data);
			if (entryPointMethod != null) {
				bool allMembersAreStatic = true;
				foreach (B.TypeMember member in entryPointMethod.DeclaringType.Members) {
					allMembersAreStatic &= member.IsStatic;
				}
				if (allMembersAreStatic) {
					entryPointMethod.DeclaringType.Attributes.Add(MakeAttribute(("module")));
				} else {
					lastLexicalInfo = entryPointMethod.LexicalInfo;
					B.Expression expr = MakeReferenceExpression(entryPointMethod.DeclaringType.Name + ".Main");
					B.MethodInvocationExpression mie = new B.MethodInvocationExpression(lastLexicalInfo, expr);
					if (entryPointMethod.Parameters.Count > 0) {
						mie.Arguments.Add(MakeReferenceExpression("argv"));
					}
					B.SimpleTypeReference ret = entryPointMethod.ReturnType as B.SimpleTypeReference;
					if (ret.Name == "void" || ret.Name == "System.Void")
						module.Globals.Add(new B.ExpressionStatement(mie));
					else
						module.Globals.Add(new B.ReturnStatement(lastLexicalInfo, mie, null));
				}
			}
			B.Module tmp = module;
			module = null;
			return tmp;
		}

        public static string CreateBooCode(CompilerErrorCollection errors,
                CompilerWarningCollection warnings,
                Module module,
                IList<ICSharpCode.NRefactory.ISpecial> specials)
        {
            using (StringWriter w = new StringWriter())
            {
                foreach (CompilerError error in errors)
                {
                    w.WriteLine("ERROR: " + error.ToString());
                }
                if (errors.Count > 0)
                    w.WriteLine();
                foreach (CompilerWarning warning in warnings)
                {
                    w.WriteLine("# WARNING: " + warning.ToString());
                }

                if (warnings.Count > 0)
                    w.WriteLine();

                BooPrinterVisitorWithComments printer = new BooPrinterVisitorWithComments(specials, w);
                printer.OnModule(module);
                printer.Finish();
                return w.ToString();
            }
        }

        /// <summary>
        /// Inspect a module to check if we need to add a namespace
        /// </summary>
        /// <param name="node">The node.</param>
        public override void OnModule(Module node)
        {
            if (node.Namespace != null)
                return;

            node.Namespace = new NamespaceDeclaration(node.FullName);
        }

        public override void OnModule(Module module) {
            replacecount = 0;
            dowork = module["isduck"]==null|| module["isduck"].toBool();

                //NameResolutionService.Reset();
                Console.WriteLine("");
                Console.Write("[" + module.Members[0].Name.Replace("_0_","/") + "](" + (cnt++) + ")");
                base.OnModule(module);
                if(replacecount==0) {
                    
                    if (dowork) {
                        Console.ForegroundColor = ConsoleColor.Yellow;
                        Console.WriteLine();
                        Console.WriteLine(module.Members[0].Name.Replace("_0_", "/") + " can be NODUCK");
                    }else {
                        Console.ForegroundColor = ConsoleColor.Green;
                        Console.WriteLine();
                        Console.WriteLine(module.Members[0].Name.Replace("_0_", "/") + " is NODUCK");
                    }
                   
                }else {
                    Console.ForegroundColor = ConsoleColor.Red;
                    Console.WriteLine();
                    Console.WriteLine(module.Members[0].Name.Replace("_0_", "/") + " contains DUCKS");
                }

                Console.ResetColor();
            
        }

		override public void OnModule(Module module)
		{
			EnterNamespace(InternalModule.ScopeFor(module));
			VisitTypeDefinitionBody(module);
			Visit(module.AssemblyAttributes);
			LeaveNamespace();
		}

 public InternalModule(InternalTypeSystemProvider provider, Module module)
 {
     _provider = provider;
     _module = module;
     _namespace = SafeNamespace(module);
     _module.Imports.Changed += (sender, e) => _namespaceList = null;
     _module.Members.Changed += (sender, e) => _memberCache = null;
 }

 public override void OnModule(Module node){
     bmlelements = new List<MacroStatement>();
     exceptions = null;
     allowall = false;
     Visit(node.Members);
     Visit(node.Globals.Statements);
     collectTemplates();
 }

 /// <summary>
 /// Add the namespaces to the module
 /// </summary>
 public override void OnModule(Module node)
 {
     foreach (string ns in namespaces)
     {
         Import import = new Import(node.LexicalInfo, ns);
         node.Imports.Add(import);
     }
 }

 public ModuleEntity(NameResolutionService nameResolutionService,
     TypeSystemServices typeSystemServices,
     Module module)
 {
     _nameResolutionService = nameResolutionService;
     _typeSystemServices = typeSystemServices;
     _module = module;
     _namespace = SafeNamespace(module);
 }

 public string Generate(XElement xml) {
     var m = new Module {
                            Namespace = new NamespaceDeclaration(xml.Name.LocalName)
                        };
     foreach (var element in xml.Elements()) {
         generateElement(element, m.Globals);
     }
     return m.ToCodeString();
 }

		public void ReifyIntoShouldFailWithAlreadyConnectedMember()
		{
			var module = new Module();
			RunCompilerStepAfterExpressionResolutionOn(new CompileUnit(module), new ActionStep(() =>
			{
				var klass = new ClassDefinition { Name = "Foo" };
				module.Members.Add(klass);
				Exceptions.Expecting<ArgumentException>(() => CodeReifier().ReifyInto(module, klass));
			}));
		}

 public override void OnModule(Module node)
 {
     var imports = new[] { "UnityEngine", "System.Collections" };
     foreach (var importName in imports)
     {
         var targetImport = new Import(LexicalInfo.Empty, importName);
         if (node.Imports.Contains(targetImport))
             node.Imports.Add(targetImport);
     }
 }

		override public void OnModule(Module node)
		{	
			var existingModuleClass = FindModuleClass(node);
			var moduleClass = existingModuleClass ?? NewModuleClassFor(node);

			Method entryPoint = moduleClass.Members["Main"] as Method;
			
			int removed = 0;
			TypeMember[] members = node.Members.ToArray();
			for (int i=0; i<members.Length; ++i)
			{
				TypeMember member = members[i];
				if (member is TypeDefinition) continue;
				if (member.NodeType == NodeType.Method)
				{
					if (EntryPointMethodName == member.Name)
					{
						entryPoint = (Method)member;
					}
					member.Modifiers |= TypeMemberModifiers.Static;
				}
				node.Members.RemoveAt(i-removed);
				moduleClass.Members.Add(member);
				++removed;
			}
			
			if (!node.Globals.IsEmpty)
			{
				Method method = new Method();
				method.IsSynthetic = true;
				method.Parameters.Add(new ParameterDeclaration("argv", new ArrayTypeReference(new SimpleTypeReference("string"))));
				method.ReturnType = CodeBuilder.CreateTypeReference(TypeSystemServices.VoidType);
				method.Body = node.Globals;
				method.LexicalInfo = node.Globals.Statements[0].LexicalInfo;
				method.EndSourceLocation = node.EndSourceLocation;
				method.Name = EntryPointMethodName;
				method.Modifiers = TypeMemberModifiers.Static | TypeMemberModifiers.Private;
				moduleClass.Members.Add(method);
				
				node.Globals = null;
				entryPoint = method;
			}
			
			SetEntryPointIfNecessary(entryPoint);

			if (existingModuleClass != null || ForceModuleClass || (moduleClass.Members.Count > 0))
			{
				if (moduleClass != existingModuleClass)
				{
					moduleClass.Members.Add(AstUtil.CreateConstructor(node, TypeMemberModifiers.Private));
					node.Members.Add(moduleClass);
				}
				InitializeModuleClassEntity(node, moduleClass);
			}
		}

		// get the directory name where this script reside and create a property
		// that return this value.
		// this is used to calculate relative paths when loading subviews.
		private void ScriptDirectoryProperty(ClassDefinition macro, Module module)
		{
			Property p = new Property("ScriptDirectory");
			p.Modifiers = TypeMemberModifiers.Override;
			p.Getter = new Method("getScriptDirectory");
			p.Getter.Body.Add(
				new ReturnStatement(
					new StringLiteralExpression(
						Path.GetDirectoryName(module.LexicalInfo.FileName))));

			macro.Members.Add(p);
		}

		private Module Parse()
		{
			var module = new Module();
			var globals = module.Globals;
			while (_position < _code.Length)
			{
				var expression = ParseNextExpression();
				if (expression == null)
					break;
				globals.Add(expression);
			}
			return module;
		}

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

			_currentModule = null;
			_currentMethod = null;
			_methodStack = new Stack<InternalMethod>();
			_memberStack = new Stack();
			_callableResolutionService = new EnvironmentProvision<CallableResolutionService>();
			_invocationTypeReferenceRules = new EnvironmentProvision<InvocationTypeInferenceRules>();
			_typeChecker = new EnvironmentProvision<TypeChecker>();
			_methodCache = new EnvironmentProvision<RuntimeMethodCache>();
		}

        private void processModule(Module module) {
            var key = module.LexicalInfo.FileName;
            var source = sources.FirstOrDefault(x => x.Key == key);
            if (null == source) return;
            var type = module.Members[0] as ClassDefinition;
            type.Name = source.Key.Replace("/","_0_");
            module.Namespace = null;
            var attr = new Attribute();
            attr.Name = typeof (TimeStampAttribute).Name;
            attr.Arguments.Add(new StringLiteralExpression(source.LastModified.ToString("dd.MM.yyyy HH:mm:ss")));
            type.Attributes.Add(attr);

        }

		public static Module ParseModule(int tabSize, CompileUnit cu, string readerName, TextReader reader, ParserErrorHandler errorHandler)
		{
			if (Readers.IsEmpty(reader))
			{
				Module emptyModule = new Module(new LexicalInfo(readerName), ModuleNameFrom(readerName));
				cu.Modules.Add(emptyModule);
				return emptyModule;
			}

			Module module = CreateParser(tabSize, readerName, reader, errorHandler).start(cu);
			module.Name = ModuleNameFrom(readerName);
			return module;
		}

        public override void OnModule(Module node)
        {
            var root = "root";
            var name = node.Namespace;
            if(name!=null && (!string.IsNullOrWhiteSpace(name.Name))){
                root = name.Name;
            }
            Target = new XElement(root);
            Current = Target;
            Visit(node.Members);
            Visit(node.Globals);

        }

		protected override CodeCompileUnit Parse()
		{
			LoggingService.Debug("BooDesignerLoader.Parse()");
			try {
				CodeCompileUnit ccu = ParseForm();
				LoggingService.Debug("BooDesignerLoader.Parse() finished");
				// Clear the cached module after loading has finished
				this.parsedModule = null;
				return ccu;
			} catch (Boo.Lang.Compiler.CompilerError ex) {
				throw new FormsDesignerLoadException(ex.ToString(true));
			}
		}