Files
mono/mcs/class/System.Web/System.Web.Compilation/CompilationException.cs
T
Marek Habersack 86b4448d43 2009-01-22 Marek Habersack <[email protected]>
* Makefile (net_2_0_dirs): added System.Web - it now depends on
        System.Core, so it needs to be recompiled one more time after
        System.Core is done.

2009-01-22  Marek Habersack  <[email protected]>

        * System.Web.dll.sources: added
        System.Web.Compilation/BuildManagerCacheItem.cs,
        System.Web.Compilation/BuildManagerDirectoryBuilder.cs,
        System.Web.Compilation/BuildProviderGroup.cs

        * Makefile (SYSTEMCORE_DEP): added. Defines SYSTEMCORE_DEP on the
        mcs command line when System.Core is present.
        Added the DEVEL define, which defines DEVEL on the mcs command
        line. This is used to conditionally compile development helper code in
        System.Web.Util.FileUtils (and possibly other stuff later on)

2009-01-22  Marek Habersack  <[email protected]>

        * XsdBuildProvider.cs: added missing BuildProviderAppliesTo
        attribute.

        * BuildProvider.cs: added new internal virtual method,
        ExtractDependencies() whose purpose is to extract virtual path
        dependencies without compiling the code, if possible.
        
        * TemplateBuildProvider.cs: implemented the new
        ExtractDependencies () method which uses regular expressions to
        extract file dependencies from the source without having to
        compile the file.

        * CompilationException.cs: added a new public property, Results,
        which returns the compilation results.

        * BuildProviderGroup.cs: added. A simple class descending from
        List <BuildProvider> which is used to hold a compilation batch -
        that is a collection of BuildProvider instances.

        * BuildManagerDirectoryBuilder.cs: new class which takes care of
        generating compilation batches for the requested virtual path. A
        set of batches is generated from files found in the same virtual
        directory as the requested virtual path and all of the
        dependencies of those files. All files are grouped in batches
        within which no file depends upon its siblings. An attempt is made
        to sort the batches from the "least dependent" to the "most
        dependent" batches - i.e. the batches which do not depend on other
        batches go to the top.
        Code generating the batches now correctly detects dependency loops
        and throws an exception when one is encountered.
        Batches are represented as instances of a new class -
        BuildProviderGroup.

        * BuildManagerCacheItem.cs: added. Contains all the compilation
        result information needed by BuildManager. See below.

        * BuildManager.cs: complete batch building rewrite:
         - only one build lock is held instead of a set of compilation
           tickets. Only one thread can compile anything at one given
           time.
         - retrieving types from the build cache now uses a slim rw lock,
           so that readers aren't blocked while compilation is in
           progress. Writer lock is acquired only when adding a newly
           compiled type to the build cache and when removing it after its
           dependencies made it invalid.
         - assembly references for each compilation are now collected
           dynamically as the source is being compiled, this removed a lot
           of complexity in dealing with assembles containing conflicting
           types. As a consequence right now there may exist several
           loaded assemblies containing the same type, but only the latest
           of them will be used in new compiles.
         - the thread compiling code can recurse into the Build method
           which causes the recursively referenced code to be compiled
           into a separate, uniquely named, assembly. This deals with all
           recursion loops and dependency problems.
         - automatic app domain restart after a certain number of compiles
           is enabled now.
         - improved compilation error handling. If a compilation error
           occurs, the code attempts to recompile the assembly up to 3
           times, each time removing from the batch the files/virtual
           paths which failed parsing/compilation. If the attempts failed,
           another one is made to compile only the virtual path requested
           by the calling code. Only should that fail a compilation
           exception is thrown. All the compilation errors are written to
           stdout if the application is in the debug mode.
         - changed assembly naming. It now generates assembly names based
           on whether the compilation is recursive and whether the batch
           being compiled contains more than one code unit or
           not.
         - compilation results are now stored in the cache as instances of
           the new BuildManagerCacheItem class, which contains all the
           information required by BuildManager to return types,
           assemblies, dependencies etc.
         - GetReferencedAssemblies now correctly returns only the
           assemblies defined in the .config files.
         - GetVirtualPathDependencies does not need to compile code
           anymore in order to extract virtual path dependencies. New code
           in BuildProvider.ExtractDependencies () takes care of that.
         - a BuildManagerDirectoryBuilder class instance is used to
           generate compilation batches.

        * AssemblyBuilder.cs: added support for keeping track of which
        code unit was generated by which BuildProvider andr which
        BuildProvider produced a given source file. Both changes serve the
        purpose of dealing with compilation errors in BuildManager.

        * ApplicationFileBuildProvider.cs: added missing
        BuildProviderAppliesTo attribute

2009-01-22  Marek Habersack  <[email protected]>

        * FileUtils.cs: added two conditionally compiled methods (they
        require DEVEL to be defined) which output lines to a log file.

2009-01-22  Marek Habersack  <[email protected]>

        * WebTest.cs: Run () sets the internal field
        BuildManager.suppressDebugModeMessages to true.

2009-01-22  Marek Habersack  <[email protected]>

        * Web.mono.config: added numRecompilesBeforeAppRestart attribute
        to the compilation element, set to 100000, to avoid appdomain
        restarts during tests.



svn path=/trunk/mcs/; revision=124179
2009-01-22 11:40:22 +00:00

173 lines
4.7 KiB
C#

//
// System.Web.Compilation.CompilationException
//
// Authors:
// Gonzalo Paniagua Javier ([email protected])
//
// (C) 2002,2003 Ximian, Inc (http://www.ximian.com)
//
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System;
using System.Collections;
using System.Collections.Specialized;
using System.CodeDom.Compiler;
using System.Runtime.Serialization;
using System.Security.Permissions;
using System.Text;
using System.Web;
namespace System.Web.Compilation
{
[Serializable]
internal class CompilationException : HtmlizedException
{
string filename;
CompilerErrorCollection errors;
CompilerResults results;
string fileText;
string errmsg;
int [] errorLines;
CompilationException (SerializationInfo info, StreamingContext context)
: base (info, context)
{
filename = info.GetString ("filename");
errors = info.GetValue ("errors", typeof (CompilerErrorCollection)) as CompilerErrorCollection;
results = info.GetValue ("results", typeof (CompilerResults)) as CompilerResults;
fileText = info.GetString ("fileText");
errmsg = info.GetString ("errmsg");
errorLines = info.GetValue ("errorLines", typeof (int[])) as int[];
}
public CompilationException (string filename, CompilerErrorCollection errors, string fileText)
{
this.filename = filename;
this.errors = errors;
this.fileText = fileText;
}
public CompilationException (string filename, CompilerResults results, string fileText)
: this (filename, results != null ? results.Errors : null, fileText)
{
this.results = results;
}
[SecurityPermission (SecurityAction.Demand, SerializationFormatter = true)]
public override void GetObjectData (SerializationInfo info, StreamingContext ctx)
{
base.GetObjectData (info, ctx);
info.AddValue ("filename", filename);
info.AddValue ("errors", errors);
info.AddValue ("results", results);
info.AddValue ("fileText", fileText);
info.AddValue ("errmsg", errmsg);
info.AddValue ("errorLines", errorLines);
}
public override string SourceFile {
get {
if (errors == null || errors.Count == 0)
return filename;
return errors [0].FileName;
}
}
public override string FileName {
get { return filename; }
}
public override string Title {
get { return "Compilation Error"; }
}
public override string Description {
get {
return "Error compiling a resource required to service this request. " +
"Review your source file and modify it to fix this error.";
}
}
public override string ErrorMessage {
get {
if (errmsg == null && errors != null) {
#if NET_2_0
errmsg = errors [0].ToString ();
int idx = errmsg.IndexOf (" : error ");
if (idx > -1)
errmsg = errmsg.Substring (idx + 9);
#else
StringBuilder sb = new StringBuilder ();
foreach (CompilerError err in errors) {
sb.Append (err);
sb.Append ("\n");
}
errmsg = sb.ToString ();
#endif
}
return errmsg;
}
}
public override string FileText {
get { return fileText; }
}
public override int [] ErrorLines {
get {
if (errorLines == null && errors != null) {
ArrayList list = new ArrayList ();
foreach (CompilerError err in errors) {
if (err.Line != 0 && !list.Contains (err.Line))
list.Add (err.Line);
}
errorLines = (int []) list.ToArray (typeof (int));
Array.Sort (errorLines);
}
return errorLines;
}
}
public override bool ErrorLinesPaired {
get { return false; }
}
public StringCollection CompilerOutput {
get {
if (results == null)
return null;
return results.Output;
}
}
public CompilerResults Results {
get { return results; }
}
}
}