Files
mono/mcs/class/System.Web/System.Web.Compilation/CachingCompiler.cs
T
Gonzalo Paniagua Javier 43d7f24f1c 2002-12-12 Gonzalo Paniagua Javier <[email protected]>
* list: Modified file.
	* System.Web/HttpRuntime.cs: avoid nulls and exception when getting
	resource format strings.

	* System.Web/StaticFileHandler.cs: added file name to error message.
	* System.Web.Compilation/AspElements.cs: new method Tag.GetElements
	used to parse the inner contents of a tag looking for data binding or
	code render tags.

	New property HtmlControlTag.ParseChildren allows
	differentiation of a couple of HtmlControls that has children as
	properties (namely HtmlTable and HtmlTableRow).

	* System.Web.Compilation/AspGenerator.cs: fixed container semantics to
	match BindingContainer one. Implemented Inherits attribute for page and
	control.

	Support HtmlControls that has ChildrenAsProperties.

	Generate code for data binding functions that matches the semantic of
	Container.

	Handle data bound and code render attribute values.

	Set proper value return for TemplateSourceDirectory. Should be relative
	to appPath.

	* System.Web.Compilation/BaseCompiler.cs: moved CompilerOptions and
	References handling here.

	* System.Web.Compilation/CachingCompiler.cs: copy result of compilation.

	* System.Web.Compilation/CompilationException.cs: simple ToString ()
	implementation.

	* System.Web.Compilation/CompilationResult.cs: implemented CopyFrom and
	ToString.

	* System.Web.Compilation/GlobalAsaxCompiler.cs:
	* System.Web.Compilation/PageCompiler.cs:
	* System.Web.Compilation/UserControlCompiler.cs: removed
	CompilerOptions as it's now handled in the base class. Get all the
	types in the generated assembly and look for one that derives from
	the correct Type.

	* System.Web.UI/Control.cs: implemented TemplateSourceDirectory.
	* System.Web.UI/TemplateControl.cs: implemented LoadControl and
	LoadTemplate.

	* System.Web.Util/PathUtil.cs: some path handling methods that are not
	available in Path.

svn path=/trunk/mcs/; revision=9583
2002-12-12 03:20:19 +00:00

157 lines
3.4 KiB
C#

//
// System.Web.Compilation.CachingCompiler
//
// Authors:
// Gonzalo Paniagua Javier ([email protected])
//
// (C) 2002 Ximian, Inc (http://www.ximian.com)
//
using System;
using System.Collections;
using System.Diagnostics;
using System.IO;
using System.Text;
using System.Web.UI;
using System.Web.Util;
namespace System.Web.Compilation
{
//TODO: caching should be done using System.Web.Caching, but that namespace still need some work.
internal class CompilationCacheItem
{
CompilationResult result;
DateTime time;
public CompilationCacheItem (CompilationResult result, DateTime time)
{
this.result = result;
this.time = time;
}
public bool CheckDependencies (string [] newDependencies, DateTime time)
{
// FIXME
return true;
}
public CompilationResult Result
{
get { return result; }
}
}
internal class CompilationCache
{
static Hashtable cache;
static CompilationCache instance = new CompilationCache ();
private CompilationCache ()
{
}
static CompilationCache ()
{
cache = new Hashtable ();
}
public static CompilationCache GetInstance ()
{
return instance;
}
public CompilationCacheItem this [string key]
{
get {
return cache [key] as CompilationCacheItem;
}
set {
cache [key] = value;
}
}
}
internal class CachingCompiler
{
static CompilationCache cache = CompilationCache.GetInstance ();
string key;
BaseCompiler compiler;
public CachingCompiler (BaseCompiler compiler)
{
this.compiler = compiler;
this.key = compiler.Key;
}
public static CompilationCacheItem GetCached (string key)
{
if (key == null)
throw new ArgumentNullException ("key");
CompilationCacheItem item = cache [key];
return item;
}
static object compilationLock = new object ();
public bool Compile (CompilationResult result)
{
if (compiler.SourceFile == null)
throw new ArgumentException ("No source to compile!");
result.Reset ();
CompilationCacheItem item;
item = GetCached (key);
if (item != null) {
if (item.CheckDependencies (compiler.Dependencies, DateTime.Now) == true) {
result.CopyFrom (item.Result);
return true;
}
}
lock (compilationLock) {
item = GetCached (key);
if (item != null) {
if (item.CheckDependencies (compiler.Dependencies, DateTime.Now) == true) {
result.CopyFrom (item.Result);
return true;
}
}
RealCompile (result);
cache [key] = new CompilationCacheItem (result, DateTime.Now);
}
return (result.ExitCode == 0);
}
void RealCompile (CompilationResult result)
{
StringBuilder options = new StringBuilder ("/target:library ");
if (compiler.CompilerOptions != null)
options.Append (compiler.CompilerOptions + ' ');
options.AppendFormat ("/out:{0} ", compiler.TargetFile);
options.Append (compiler.SourceFile);
Process proc = new Process ();
proc.StartInfo.FileName = "mcs";
proc.StartInfo.Arguments = options.ToString ();
proc.StartInfo.UseShellExecute = false;
proc.StartInfo.RedirectStandardOutput = true;
WebTrace.WriteLine ("{0} {1}", proc.StartInfo.FileName, options.ToString ());
proc.Start ();
string poutput = proc.StandardOutput.ReadToEnd();
proc.WaitForExit ();
result.ExitCode = proc.ExitCode;
proc.Close ();
proc = null;
result.CompilerOutput = poutput;
result.OutputFile = compiler.TargetFile;
}
}
}