public virtual void Process(SourceFile file)
		{
			foreach (var step in internalSteps)
			{
				step.Process(file);
			}
		}

		public void Process(SourceFile file)	{
			file.RenderBody = Internal.RegularExpressions.ContentTag.Replace(
				file.RenderBody,
				delegate(Match match) 
				{
					var parsedAttributes = match.Groups["attributes"].Value;
					var attributes = Utilities.GetAttributesDictionaryFrom(parsedAttributes);
					if (attributes.Contains("runat") && String.Equals("server", (attributes["runat"] as string), StringComparison.InvariantCultureIgnoreCase)) 
					{
						if (!attributes.Contains("contentplaceholderid"))
							throw new AspViewException(ExceptionMessages.ContentPlaceHolderIdAttributeNotFound);
						if (String.IsNullOrEmpty((string)attributes["contentplaceholderid"]))
							throw new AspViewException(ExceptionMessages.ContentPlaceHolderIdAttributeEmpty);
						var contentplaceholderid = (string)attributes["contentplaceholderid"];

						// handle ViewContents special case
						if (contentplaceholderid == "ViewContents")
							return match.Groups["content"].Value;
						var capturefortagformat = @"<component:capturefor id=""{0}"">{1}</component:capturefor>";
						return string.Format(capturefortagformat, contentplaceholderid, match.Groups["content"].Value);
					}
					else
						return match.Value;
				                      
				}
				);
		}

		void tokenize_file (SourceFile sourceFile, ModuleContainer module, ParserSession session)
		{
			Stream input;

			try {
				input = File.OpenRead (sourceFile.Name);
			} catch {
				Report.Error (2001, "Source file `" + sourceFile.Name + "' could not be found");
				return;
			}

			using (input){
				SeekableStreamReader reader = new SeekableStreamReader (input, ctx.Settings.Encoding);
				var file = new CompilationSourceFile (module, sourceFile);

				Tokenizer lexer = new Tokenizer (reader, file, session, ctx.Report);
				int token, tokens = 0, errors = 0;

				while ((token = lexer.token ()) != Token.EOF){
					tokens++;
					if (token == Token.ERROR)
						errors++;
				}
				Console.WriteLine ("Tokenized: " + tokens + " found " + errors + " errors");
			}
			
			return;
		}

		public virtual void Process(SourceFile file)
		{
			foreach (IPreCompilationStep step in internalSteps)
			{
				step.Process(file);
			}
		}

        public void ItemTests()
        {
            var sourceFile = new SourceFile(Services.FileSystem, "test.txt", "test.txt");

            var doc = Services.CompositionService.Resolve<JsonTextSnapshot>().With(SnapshotParseContext.Empty, sourceFile, "{ \"Item\": { \"Fields\": [ { \"Name\": \"Text\", \"Value\": \"123\" } ] } }");
            var root = doc.Root;
            Assert.IsNotNull(root);
            Assert.AreEqual("Item", root.Key);
            Assert.AreEqual(1, root.ChildNodes.Count());

            var fields = root.ChildNodes.First();
            Assert.AreEqual(1, fields.ChildNodes.Count());

            var field = fields.ChildNodes.First();
            Assert.AreEqual("Text", field.GetAttributeValue("Name"));
            Assert.AreEqual("123", field.GetAttributeValue("Value"));
            Assert.AreEqual(0, field.ChildNodes.Count());

            var attribute = field.GetAttribute("Name");
            Assert.IsNotNull(attribute);
            Assert.AreEqual("Text", attribute.Value);
            Assert.AreEqual(0, attribute.Attributes.Count());
            Assert.AreEqual(0, attribute.ChildNodes.Count());
            Assert.AreEqual(field.Snapshot, attribute.Snapshot);
            Assert.AreEqual(doc, attribute.Snapshot);
        }

        internal CodeIssueFile(CodeIssue codeIssue, SourceFile file, string message)
        {
            this.codeIssue = codeIssue;
            this.file = file;
            this.message = message;

        }

		public void Process(SourceFile file)
		{
			file.RenderBody = Internal.RegularExpressions.LayoutContentPlaceHolder.Replace(
				file.RenderBody,
				delegate(Match match) 
				{
					string parsedAttributes = match.Groups["attributes"].Value;
					IDictionary attributes = Utilities.GetAttributesDictionaryFrom(parsedAttributes);
					if(attributes.Contains("runat") && String.Equals("server",(attributes["runat"] as string), StringComparison.InvariantCultureIgnoreCase))
					{
						if (!attributes.Contains("id"))
							throw new AspViewException(ExceptionMessages.IdAttributeNotFound);
						if (String.IsNullOrEmpty((string)attributes["id"]))
							throw new AspViewException(ExceptionMessages.IdAttributeEmpty);

						string placeholderid = (string) attributes["id"];
						if(!file.Properties.ContainsKey(placeholderid))
						{
							// handle ViewContents special case
							if (placeholderid != "ViewContents")
								file.Properties.Add(placeholderid, new ViewProperty(placeholderid, "string", @""""""));
						}
						else if(!String.Equals(file.Properties[placeholderid].Type, "string", StringComparison.InvariantCultureIgnoreCase))
						{
							throw new AspViewException(String.Format(ExceptionMessages.ViewPropertyAllreadyRegisteredWithOtherTypeFormat, placeholderid));
						}
						return String.Format("<%={0}%>", placeholderid);
					}
					else
					{
						return match.Value;
					}
				});
		}

		private void RunSteps(SourceFile file)
		{
			foreach (IPreCompilationStep step in provider.GetSteps())
			{
				step.Process(file);
			}
		}

 public void AddNewImport(SourcePoint start, string namespaceName, SourceFile sourceFile, bool isLast)
 {
     string newImportCall = CodeRush.Language.GenerateElement(new NamespaceReference(namespaceName), sourceFile.Project.Language);
     if (isLast && newImportCall.EndsWith(Environment.NewLine))		// Remove cr/lf from last entry.
         newImportCall = newImportCall.Remove(newImportCall.Length - Environment.NewLine.Length);
     _NewImportCalls.Add(new FileChange(sourceFile.Name, start, newImportCall));
 }

 internal CheckFile(IssueServices issueService, 
                     SourceFile file, 
                     IssueProcessor issueProcessor)
 {
     this.issueService = issueService;
     this.file = file;
     this.issueProcessor = issueProcessor;
 }

 public TokenInfo(Token token, string value, SourceFile sourceFile, int ln, int col)
 {
     this.token = token;
     this.value = value;
     this.ln = ln;
     this.col = col;
     this.sourceFile = sourceFile;
 }

		/// <summary>
		/// Performs server side comment stripping
		/// </summary>
		/// <param name="file">The source file object to act upon.</param>
		void IPreCompilationStep.Process(SourceFile file) 
		{
			file.RenderBody = Internal.RegularExpressions.ServerSideComment.Replace(
				file.RenderBody,
				string.Empty
			);
			
		}

		private void RegisterSectionHandler(string handlerName, string sectionContent, SourceFile file)
		{
			var processedSection = sectionContent;
			if (Internal.RegularExpressions.ViewComponentTags.IsMatch(sectionContent))
				processedSection = Process(sectionContent, file);
			processedSection = scriptTransformer.Transform(processedSection);
			file.ViewComponentSectionHandlers[handlerName] = processedSection;
		}

		public void Process(SourceFile file)
		{
			file.RenderBody = Internal.RegularExpressions.ImportDirective.Replace(file.RenderBody, delegate(Match match)
			{
				file.Imports.Add(match.Groups["namespace"].Value);
				return string.Empty;
			});
		}

		public void Process(SourceFile file)
		{
			file.Imports.Add("System");
			file.Imports.Add("System.IO");
			file.Imports.Add("System.Collections");
			file.Imports.Add("System.Collections.Generic");
			file.Imports.Add("Castle.MonoRail.Framework");
			file.Imports.Add("Castle.MonoRail.Views.AspView");
		}

 /// <summary>
 /// Initializes an instance of the ReportItem class.
 /// </summary>
 /// <param name="descriptor">A message descriptor.</param>
 /// <param name="sourceFile">A source file.</param>
 /// <param name="sourceSpan">A source span.</param>
 /// <param name="sourceLine">A source line.</param>
 /// <param name="args">Some arguments required by the message descriptor.</param>
 public ReportItem(MessageDescriptor descriptor, SourceFile sourceFile, SourceSpan sourceSpan,
                   TokenList sourceLine, params string[] args)
 {
     MessageDescriptor = descriptor;
     SourceFile = sourceFile;
     SourceSpan = sourceSpan;
     SourceLine = sourceLine;
     Arguments = args;
 }

		void ConvertSequencePoints (PdbFunction function, SourceFile file, SourceMethodBuilder builder)
		{
			foreach (var line in function.lines.SelectMany (lines => lines.lines))
				builder.MarkSequencePoint (
					(int) line.offset,
					file.CompilationUnit.SourceFile,
					(int) line.lineBegin,
					(int) line.colBegin, line.lineBegin == 0xfeefee);
		}

        public void InvalidXmlTests()
        {
            var sourceFile = new SourceFile(Services.FileSystem, "test.txt", "test.txt");

            var doc = Services.CompositionService.Resolve<XmlTextSnapshot>().With(SnapshotParseContext.Empty, sourceFile, "<Item>", string.Empty, string.Empty);
            Assert.AreEqual(TextNode.Empty, doc.Root);

            doc = Services.CompositionService.Resolve<XmlTextSnapshot>().With(SnapshotParseContext.Empty, sourceFile, string.Empty, string.Empty, string.Empty);
            Assert.AreEqual(TextNode.Empty, doc.Root);
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="provider"></param>
        /// <param name="sourceFile"></param>
        protected SourceReference(SourceProvider provider, SourceFile sourceFile)
        {
            if (provider == null)
                throw new ArgumentNullException("provider");
            else if (sourceFile == null)
                throw new ArgumentNullException("sourceFile");

            _provider = provider;
            _sourceFile = sourceFile;
        }

		public void Process(SourceFile file)
		{
			file.RenderBody = Internal.RegularExpressions.PageDirective.Replace(file.RenderBody, delegate(Match match)
			{
				file.BaseClassName = GetBaseClass(match.Groups["base"]);
				file.TypedViewName = GetTypedViewName(match.Groups["view"]);
				if (file.TypedViewName != null)
					file.BaseClassName += "<" + file.TypedViewName + ">";
				return string.Empty;
			}, 1);
		}