public static ParsedTemplate parse(string sourceFilename, string cshtmlContent, string effectiveTemplateClassName, Type modelType)
        {
            var csCodeLanguage = new CSharpRazorCodeLanguage();
            var templateHost = new RazorEngineHost(csCodeLanguage, () => new HtmlMarkupParser());

            var concreteBaseClassType = getBaseClassTypeFromModel(modelType);
            templateHost.DefaultBaseClass = concreteBaseClassType.FullName;

            var templateEngine = new RazorTemplateEngine(templateHost);

            var trimmedcshtmlContent = HeaderLines.trim(cshtmlContent);

            GeneratorResults res;
            using (var input = new StringReader(trimmedcshtmlContent))
            {
                res = templateEngine.GenerateCode(input, effectiveTemplateClassName, GeneratedTemplateNamespace, sourceFilename);
            }

            if (!res.Success)
                throw new Exception("Failed to generate code");

            var compileUnit = res.GeneratedCode;
            var fullyQualifiedClassName = GeneratedTemplateNamespace + "." + effectiveTemplateClassName;

            return new ParsedTemplate(fullyQualifiedClassName, compileUnit);
        }

 public GeneratorResults ParseToCode(string TemplateCode, string defaultnamespace, string defaultclassname, string baseClassFullName)
 {
     GeneratorResults razorResults;
     var host = new RazorEngineHost(new CSharpRazorCodeLanguage());
     host.DefaultBaseClass = baseClassFullName;//typeof(BulaqTemplateForRazorBase).FullName;
     host.DefaultNamespace = defaultnamespace;
     host.DefaultClassName = defaultclassname;
     host.NamespaceImports.Add("System");
     host.NamespaceImports.Add("BulaqCMS.Models");
     host.GeneratedClassContext = new GeneratedClassContext("Execute", "Write", "WriteLiteral");
     var engine = new RazorTemplateEngine(host);
     using (var reader = new StringReader(TemplateCode))
     {
         razorResults = engine.GenerateCode(reader);
         CSharpCodeProvider codeProvider = new CSharpCodeProvider();
         CodeGeneratorOptions options = new CodeGeneratorOptions();
         options.BracingStyle = "C";
         using (StringWriter writer = new StringWriter())
         {
             IndentedTextWriter indentwriter = new IndentedTextWriter(writer, "    ");
             codeProvider.GenerateCodeFromCompileUnit(razorResults.GeneratedCode, indentwriter, options);
             indentwriter.Flush();
             indentwriter.Close();
             LastGeneratedCode = writer.GetStringBuilder().ToString();
             string codePath = AppDomain.CurrentDomain.BaseDirectory.TrimEnd('\\') + "\\code.cs";
             File.WriteAllText(codePath, LastGeneratedCode, Encoding.UTF8);
         }
     }
     return razorResults;
 }

        private async Task<CompilationResult> CompileCore(IFileInfo file)
        {
            var host = new MvcRazorHost();
            var engine = new RazorTemplateEngine(host);
            GeneratorResults results;
            using (TextReader rdr = new StreamReader(file.CreateReadStream()))
            {
                results = engine.GenerateCode(rdr, '_' + Path.GetFileNameWithoutExtension(file.Name), "Asp", file.PhysicalPath ?? file.Name);
            }

            string generatedCode;

            using (var writer = new StringWriter())
            using (var codeProvider = new CSharpCodeProvider())
            {
                codeProvider.GenerateCodeFromCompileUnit(results.GeneratedCode, writer, new CodeGeneratorOptions());
                generatedCode = writer.ToString();
            }

            if (!results.Success) 
            {
                return CompilationResult.Failed(generatedCode, results.ParserErrors.Select(e => new CompilationMessage(e.Message)));
            }

            Directory.CreateDirectory(_tempPath);
            string tempFile = Path.Combine(_tempPath, Path.GetRandomFileName() + ".cs");

            File.WriteAllText(tempFile, generatedCode);

            _tempFileSystem.TryGetFileInfo(tempFile, out file);
            return await _baseCompilationService.Compile(file);
        }

        private static string GenerateCodeFromRazorString(WebPageRazorHost host, string razorString, string virtualPath)
        {

            // Create Razor engine and use it to generate a CodeCompileUnit
            var engine = new RazorTemplateEngine(host);
            GeneratorResults results = null;

            using (StringReader reader = new StringReader(razorString))
            {
                results = engine.GenerateCode(reader, className: null, rootNamespace: null,
                    sourceFileName: host.PhysicalPath);
            }

            if (!results.Success)
            {
                throw CreateExceptionFromParserError(results.ParserErrors.Last(), virtualPath);
            }

            // Use CodeDom to generate source code from the CodeCompileUnit
            using (var codeDomProvider = new CSharpCodeProvider())
            {
                using (var srcFileWriter = new StringWriter())
                {
                    codeDomProvider.GenerateCodeFromCompileUnit(results.GeneratedCode, srcFileWriter,
                        new CodeGeneratorOptions());

                    return srcFileWriter.ToString();
                }
            }
        }

		private CodeCompileUnit GetGeneratedCode()
		{
		    try
		    {

                if (this.generatedCode == null)
                {
                    var engine = new RazorTemplateEngine(this.host);
                    GeneratorResults results;
                    using (var reader = this.OpenReader())
                    {
                        results = engine.GenerateCode(reader);
                    }

                    if (!results.Success)
                    {
                        throw new InvalidOperationException(results.ToString());
                    }

                    this.generatedCode = results.GeneratedCode;
                }

                return this.generatedCode;
            }
            catch (Exception ex)
            {
                Log.Error("GetGeneratedCode(): ", ex);
                return null;
            }
		}

        public override SyntaxTree GetSyntaxTree(string sourcePath, Stream sourceStream)
        {
            try
            {
                var viewFullPath = sourcePath;
                var viewVirtualPath = GetRelativeUri(sourcePath, Compilation.CurrentDirectory.FullName);
                var viewConfig = WebConfigurationManager.OpenMappedWebConfiguration(_configMap, viewVirtualPath);
                var razorConfig = viewConfig.GetSectionGroup("system.web.webPages.razor") as RazorWebSectionGroup;
                var host = razorConfig == null
                    ? WebRazorHostFactory.CreateDefaultHost(viewVirtualPath, viewFullPath)
                    : WebRazorHostFactory.CreateHostFromConfig(razorConfig, viewVirtualPath, viewFullPath);

                using (var rdr = new StreamReader(sourceStream, Compilation.Encoding, detectEncodingFromByteOrderMarks: true))
                using (var provider = CodeDomProvider.CreateProvider("csharp"))
                using (var generatedStream = new MemoryStream())
                using (var generatedWriter = new StreamWriter(generatedStream, Compilation.Encoding))
                {
                    var engine = new RazorTemplateEngine(host);
                    var razorOut = engine.GenerateCode(rdr, null, null, viewFullPath);
                    var codeGenOptions = new CodeGeneratorOptions { VerbatimOrder = true, ElseOnClosing = false, BlankLinesBetweenMembers = false };
                    provider.GenerateCodeFromCompileUnit(razorOut.GeneratedCode, generatedWriter, codeGenOptions);

                    // rewind
                    generatedWriter.Flush();
                    generatedStream.Position = 0;

                    return base.GetSyntaxTree(sourcePath, generatedStream);
                }
            }
            catch (Exception ex)
            {
                Compilation.Diagnostics.Add(Diagnostic.Create(Compilation.ViewGenerationFailed, Compilation.AsLocation(sourcePath), ex.ToString()));
                return null;
            }
        }

		void ReadHtmlSpans(string html)
		{
			RazorEngineHost razorEngineHost = new RazorEngineHost(codeLanguage);
			RazorTemplateEngine engine = new RazorTemplateEngine(razorEngineHost);
			ParserResults results = engine.ParseTemplate(new StringReader(html));
			spans = new List<Span>(results.Document.Flatten());
			spans.RemoveAll(span => span.Kind != SpanKind.Markup);
		}

        private static RazorTemplateEngine CreateRazorTemplateEngine()
        {
            var language = new CSharpRazorCodeLanguage();
            var host = new SimpleRazorEngineHost(language);
            var engine = new RazorTemplateEngine(host);

            return engine;
        }

 void ReadBlockSpans(string markup)
 {
     var razorEngineHost = new RazorEngineHost(codeLanguage);
     var engine = new RazorTemplateEngine(razorEngineHost);
     var results = engine.ParseTemplate(new StringReader(markup));
     spans = new List<Span>(results.Document.Flatten());
     spans.RemoveAll(span => !span.IsBlock);
 }

 public TemplateFactory(RazorContext razorContext)
 {
     if (razorContext == null) throw new ArgumentNullException("razorContext");
     _razorContext = razorContext;
     _razorEngine = new RazorTemplateEngine(new XiptonEngineHost(razorContext.Config));
     ContentManager = new ContentManager(razorContext.Config);
     ContentManager.ContentProvider.ContentModified += OnContentModified;
     ContentManager.SharedContentModified += OnSharedContentModified;
 }

        public IEnumerable<Span> Parse(string viewFile)
        {
            var codeLanguage = RazorCodeLanguageFactory.Create(viewFile.FileExtension());

            using (var fileStream = new FileStream(viewFile, FileMode.Open, FileAccess.Read))
            using (var reader = new StreamReader(fileStream))
            {
                var templateEngine = new RazorTemplateEngine(new RazorEngineHost(codeLanguage));
                var parseResults = templateEngine.ParseTemplate(reader);
                return parseResults.Document.Flatten();
            }
        }

        public virtual void RenderClientTemplate(TextReader razorTemplate, TextWriter output)
        {
            var host = new RazorEngineHost(new CSharpRazorCodeLanguage());
            var engine = new RazorTemplateEngine(host);

            var parserResults = engine.ParseTemplate(razorTemplate);

            if(parserResults.Success == false)
                // TODO: Less suck
                throw new RazorClientTemplateException("Template parse exception");

            RenderClientTemplate(parserResults.Document, output);
        }

        internal void Parse(TextReader razorTemplate, TextWriter output)
        {
            RazorEngineHost host = new RazorEngineHost(new CSharpRazorCodeLanguage());
            RazorTemplateEngine engine = new RazorTemplateEngine(host);

            ParserResults result = engine.ParseTemplate(razorTemplate);

            if (!result.Success)
            {
                ThrowParserError(result);
            }
            WriteTemplateFunction(result.Document, output);
        }

        public GeneratorResults GenerateCode()
        {
            // Create the engine
            RazorTemplateEngine engine = new RazorTemplateEngine(this);

            // Generate code
            using (Stream stream = File.OpenRead(_fullPath))
            {
                using (StreamReader reader = new StreamReader(stream, Encoding.Default, detectEncodingFromByteOrderMarks: true))
                {
                    return engine.GenerateCode(reader);
                }
            }
        }

        public static RazorTemplateEngine CreateEngine()
        {
            var language = new CSharpRazorCodeLanguage();
            var host = new RazorEngineHost(language);
            host.DefaultBaseClass = typeof(RazorTemplate<Context>).FullName;
            host.DefaultNamespace = "RazorOutput";
            host.DefaultClassName = "Template";
            host.NamespaceImports.Add("System");
            host.NamespaceImports.Add("System.IO");
            //host.NamespaceImports.Add("System.Linq");
           // host.NamespaceImports.Add("System.Text.RegularExpressions");

            var engine = new RazorTemplateEngine(host);
            return engine;
        }

        // Returns an instance of the razor template, compiled from the file stored as an embedded resource.
        // The first time this method is executed, the Razor template is compiled and stored.
        // This method will throw an InvalidDataException if the template contains syntax errors.
        public TemplateBase CreateRazorTemplateInstance()
        {
            if (templateType == null)
            {
                var host = new RazorEngineHost(new CSharpRazorCodeLanguage());
                host.DefaultBaseClass = typeof(TemplateBase).FullName;
                host.DefaultNamespace = "RazorOutput";
                host.DefaultClassName = "Template";
                host.NamespaceImports.Add("System");

                GeneratorResults razorResult = null;

                var templateStream = System.Reflection.Assembly.GetExecutingAssembly().GetManifestResourceStream("Curtsy.Resources.curtsy.cshtml");

                if (templateStream == null)
                    throw new FileNotFoundException("Could not find embedded resource 'Curtsy.Resources.curtsy.cshtml'");

                using (var reader = new StreamReader(templateStream))
                {
                    razorResult = new RazorTemplateEngine(host).GenerateCode(reader);
                }

                var compilerParams = new CompilerParameters
                {
                    GenerateInMemory = true,
                    GenerateExecutable = false,
                    IncludeDebugInformation = false,
                    CompilerOptions = "/target:library /optimize"
                };
                compilerParams.ReferencedAssemblies.Add(typeof(Program).Assembly.CodeBase.Replace("file:///", "").Replace('/', Path.DirectorySeparatorChar));

                var codeProvider = new Microsoft.CSharp.CSharpCodeProvider();
                var results = codeProvider.CompileAssemblyFromDom(compilerParams, razorResult.GeneratedCode);

                if (results.Errors.HasErrors)
                {
                    StringBuilder errors = new StringBuilder();
                    foreach (var err in results.Errors.OfType<CompilerError>().Where(ce => !ce.IsWarning))
                        errors.AppendFormat("Error compiling template: ({0}, {1}) {2}", err.Line, err.Column, err.ErrorText);

                    throw new InvalidDataException(errors.ToString());
                }

                templateType = results.CompiledAssembly.GetType("RazorOutput.Template");
            }

            return (TemplateBase)Activator.CreateInstance(templateType);
        }

		private static GeneratorResults GenerateCode(RazorTemplateEntry entry)
		{
			var host = new NodeRazorHost(new CSharpRazorCodeLanguage());

			host.DefaultBaseClass = string.Format("Http.Renderer.Razor.Integration.RazorTemplateBase<{0}>", TypeToString(entry.ModelType));
			host.DefaultNamespace = "Http.Renderer.Razor.Integration";
			host.DefaultClassName = entry.TemplateName + "Template";
			host.NamespaceImports.Add("System");
			host.NamespaceImports.Add("System.Dynamic");
			GeneratorResults razorResult = null;
			using (TextReader reader = new StringReader(entry.TemplateString))
			{
				razorResult = new RazorTemplateEngine(host).GenerateCode(reader);
			}
			return razorResult;
		}

 private CompilationData GenerateCode(string path)
 {
     var viewDefinition = _viewProvider.GetViewDefinition(path);
     var host = OpenRastaRazorHostFactory.CreateHost(DetermineCodeLanguage(viewDefinition.FileName));
     var engine = new RazorTemplateEngine(host);
     GeneratorResults results;
     using (TextReader reader = viewDefinition.Contents)
     {
         results = engine.GenerateCode(reader, GetClassName(viewDefinition.FileName), host.DefaultNamespace, viewDefinition.FileName);
     }
     if (!results.Success)
     {
         throw CreateExceptionFromParserError(results.ParserErrors.Last(), path);
     }
     return new CompilationData(GetReferencedAssemblies(viewDefinition), results.GeneratedCode);
 }

 private static RazorTemplateEngine CreateRazorTemplateEngine()
 {
     var language = new CSharpRazorCodeLanguage();
     var host = new SimpleRazorEngineHost(language)
                    {
                        DefaultBaseClass = "SimpleTemplateBase",
                        DefaultClassName = "SimpleView",
                        DefaultNamespace = "SimpleRazor",
                    };
     foreach (string nameSpace in DefaultNamespaceImports)
     {
         host.NamespaceImports.Add(nameSpace);
     }
     var engine = new RazorTemplateEngine(host);
     return engine;
 }

        private CodeCompileUnit GenerateCode()
        {
            var engine = new RazorTemplateEngine(this._host);
            GeneratorResults results;
            using (TextReader reader = OpenReader())
            {
                results = engine.GenerateCode(reader); //, className: null, rootNamespace: null, sourceFileName: Host.PhysicalPath);
            }

            if (!results.Success)
            {
                throw CreateExceptionFromParserError(results.ParserErrors.Last(), VirtualPath);
            }

            return results.GeneratedCode;
        }