mcs/class/System.Web/System.Web.UI/TemplateParser.cs

   1 //
   2 // System.Web.UI.TemplateParser
   3 //
   4 // Authors:
   5 //      Duncan Mak (duncan@ximian.com)
   6 //      Gonzalo Paniagua Javier (gonzalo@ximian.com)
   7 //
   8 // (C) 2002,2003 Ximian, Inc. (http://www.ximian.com)
   9 // Copyright (C) 2005 Novell, Inc (http://www.novell.com)
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30
  31 using System.CodeDom.Compiler;
  32 using System.Collections;
  33 using System.ComponentModel;
  34 using System.Globalization;
  35 using System.IO;
  36 using System.Reflection;
  37 using System.Security.Permissions;
  38 using System.Web.Compilation;
  39 using System.Web.Configuration;
  40 using System.Web.Util;
  41
  42 #if NET_2_0
  43 using System.Collections.Generic;
  44 #endif
  45
  46 namespace System.Web.UI {
  47
  48         // CAS
  49         [AspNetHostingPermission (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
  50         [AspNetHostingPermission (SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
  51         public abstract class TemplateParser : BaseParser
  52         {
  53                 string inputFile;
  54                 string text;
  55                 string privateBinPath;
  56                 Hashtable mainAttributes;
  57                 ArrayList dependencies;
  58                 ArrayList assemblies;
  59                 Hashtable anames;
  60                 ArrayList imports;
  61                 ArrayList interfaces;
  62                 ArrayList scripts;
  63                 Type baseType;
  64                 bool baseTypeIsGlobal;
  65                 string className;
  66                 RootBuilder rootBuilder;
  67                 bool debug;
  68                 string compilerOptions;
  69                 string language;
  70                 bool implicitLanguage;
  71                 bool strictOn = false;
  72                 bool explicitOn = false;
  73                 bool linePragmasOn = false;
  74                 bool output_cache;
  75                 int oc_duration;
  76                 string oc_header, oc_custom, oc_param, oc_controls;
  77                 bool oc_shared;
  78                 OutputCacheLocation oc_location;
  79                 CultureInfo invariantCulture = CultureInfo.InvariantCulture;
  80 #if NET_2_0
  81                 string src;
  82                 string partialClassName;
  83                 string codeFileBaseClass;
  84                 string metaResourceKey;
  85                 Type codeFileBaseClassType;
  86                 List <UnknownAttributeDescriptor> unknownMainAttributes;
  87 #endif
  88                 Assembly srcAssembly;
  89                 int appAssemblyIndex = -1;
  90
  91                 internal TemplateParser ()
  92                 {
  93                         imports = new ArrayList ();
  94 #if NET_2_0
  95                         AddNamespaces (imports);
  96 #else
  97                         imports.Add ("System");
  98                         imports.Add ("System.Collections");
  99                         imports.Add ("System.Collections.Specialized");
 100                         imports.Add ("System.Configuration");
 101                         imports.Add ("System.Text");
 102                         imports.Add ("System.Text.RegularExpressions");
 103                         imports.Add ("System.Web");
 104                         imports.Add ("System.Web.Caching");
 105                         imports.Add ("System.Web.Security");
 106                         imports.Add ("System.Web.SessionState");
 107                         imports.Add ("System.Web.UI");
 108                         imports.Add ("System.Web.UI.WebControls");
 109                         imports.Add ("System.Web.UI.HtmlControls");
 110 #endif
 111
 112                         assemblies = new ArrayList ();
 113 #if NET_2_0
 114                         bool addAssembliesInBin = false;
 115                         foreach (AssemblyInfo info in CompilationConfig.Assemblies) {
 116                                 if (info.Assembly == "*")
 117                                         addAssembliesInBin = true;
 118                                 else
 119                                         AddAssemblyByName (info.Assembly);
 120                         }
 121                         if (addAssembliesInBin)
 122                                 AddAssembliesInBin ();
 123
 124                         foreach (NamespaceInfo info in PagesConfig.Namespaces) {
 125                                 imports.Add (info.Namespace);
 126                         }
 127 #else
 128                         foreach (string a in CompilationConfig.Assemblies)
 129                                 AddAssemblyByName (a);
 130                         if (CompilationConfig.AssembliesInBin)
 131                                 AddAssembliesInBin ();
 132 #endif
 133
 134                         language = CompilationConfig.DefaultLanguage;
 135                         implicitLanguage = true;
 136                 }
 137
 138                 internal void AddApplicationAssembly ()
 139                 {
 140                         if (Context.ApplicationInstance == null)
 141                                 return; // this may happen if we have Global.asax and have
 142                                         // controls registered from Web.Config
 143                         string location = Context.ApplicationInstance.AssemblyLocation;
 144                         if (location != typeof (TemplateParser).Assembly.Location) {
 145                                 appAssemblyIndex = assemblies.Add (location);
 146                         }
 147                 }
 148
 149                 protected abstract Type CompileIntoType ();
 150
 151 #if NET_2_0
 152                 void AddNamespaces (ArrayList imports)
 153                 {
 154                         if (BuildManager.HaveResources)
 155                                 imports.Add ("System.Resources");
 156
 157                         PagesSection pages = WebConfigurationManager.GetSection ("system.web/pages") as PagesSection;
 158                         if (pages == null)
 159                                 return;
 160
 161                         NamespaceCollection namespaces = pages.Namespaces;
 162                         if (namespaces == null || namespaces.Count == 0)
 163                                 return;
 164
 165                         foreach (NamespaceInfo nsi in namespaces)
 166                                 imports.Add (nsi.Namespace);
 167                 }
 168 #endif
 169
 170                 internal void RegisterCustomControl (string tagPrefix, string tagName, string src)
 171                 {
 172                         string realpath = MapPath (src);
 173                         if (String.Compare (realpath, inputFile, false, invariantCulture) == 0)
 174                                 return;
 175
 176                         if (!File.Exists (realpath))
 177                                 throw new ParseException (Location, "Could not find file \"" + realpath + "\".");
 178                         string vpath = VirtualPathUtility.Combine (BaseVirtualDir, src);
 179                         Type type = null;
 180                         AddDependency (realpath);
 181                         try {
 182                                 ArrayList other_deps = new ArrayList ();
 183                                 type = UserControlParser.GetCompiledType (vpath, realpath, other_deps, Context);
 184                                 foreach (string s in other_deps) {
 185                                         AddDependency (s);
 186                                 }
 187                         } catch (ParseException pe) {
 188                                 if (this is UserControlParser)
 189                                         throw new ParseException (Location, pe.Message, pe);
 190                                 throw;
 191                         }
 192
 193                         AddAssembly (type.Assembly, true);
 194                         RootBuilder.Foundry.RegisterFoundry (tagPrefix, tagName, type);
 195                 }
 196
 197                 internal void RegisterNamespace (string tagPrefix, string ns, string assembly)
 198                 {
 199                         AddImport (ns);
 200                         Assembly ass = null;
 201
 202                         if (assembly != null && assembly.Length > 0) {
 203                                 ass = AddAssemblyByName (assembly);
 204                                 AddDependency (ass.Location);
 205                         }
 206
 207                         RootBuilder.Foundry.RegisterFoundry (tagPrefix, ass, ns);
 208                 }
 209
 210                 internal virtual void HandleOptions (object obj)
 211                 {
 212                 }
 213
 214                 internal static string GetOneKey (Hashtable tbl)
 215                 {
 216                         foreach (object key in tbl.Keys)
 217                                 return key.ToString ();
 218
 219                         return null;
 220                 }
 221
 222                 internal virtual void AddDirective (string directive, Hashtable atts)
 223                 {
 224                         if (String.Compare (directive, DefaultDirectiveName, true) == 0) {
 225                                 if (mainAttributes != null)
 226                                         ThrowParseException ("Only 1 " + DefaultDirectiveName + " is allowed");
 227
 228                                 mainAttributes = atts;
 229                                 ProcessMainAttributes (mainAttributes);
 230                                 return;
 231                         }
 232
 233                         int cmp = String.Compare ("Assembly", directive, true);
 234                         if (cmp == 0) {
 235                                 string name = GetString (atts, "Name", null);
 236                                 string src = GetString (atts, "Src", null);
 237
 238                                 if (atts.Count > 0)
 239                                         ThrowParseException ("Attribute " + GetOneKey (atts) + " unknown.");
 240
 241                                 if (name == null && src == null)
 242                                         ThrowParseException ("You gotta specify Src or Name");
 243
 244                                 if (name != null && src != null)
 245                                         ThrowParseException ("Src and Name cannot be used together");
 246
 247                                 if (name != null) {
 248                                         AddAssemblyByName (name);
 249                                 } else {
 250                                         GetAssemblyFromSource (src);
 251                                 }
 252
 253                                 return;
 254                         }
 255
 256                         cmp = String.Compare ("Import", directive, true);
 257                         if (cmp == 0) {
 258                                 string namesp = GetString (atts, "Namespace", null);
 259                                 if (atts.Count > 0)
 260                                         ThrowParseException ("Attribute " + GetOneKey (atts) + " unknown.");
 261
 262                                 if (namesp != null && namesp != "")
 263                                         AddImport (namesp);
 264                                 return;
 265                         }
 266
 267                         cmp = String.Compare ("Implements", directive, true);
 268                         if (cmp == 0) {
 269                                 string ifacename = GetString (atts, "Interface", "");
 270
 271                                 if (atts.Count > 0)
 272                                         ThrowParseException ("Attribute " + GetOneKey (atts) + " unknown.");
 273
 274                                 Type iface = LoadType (ifacename);
 275                                 if (iface == null)
 276                                         ThrowParseException ("Cannot find type " + ifacename);
 277
 278                                 if (!iface.IsInterface)
 279                                         ThrowParseException (iface + " is not an interface");
 280
 281                                 AddInterface (iface.FullName);
 282                                 return;
 283                         }
 284
 285                         cmp = String.Compare ("OutputCache", directive, true);
 286                         if (cmp == 0) {
 287                                 HttpResponse response = HttpContext.Current.Response;
 288                                 if (response != null)
 289                                         response.Cache.SetValidUntilExpires (true);
 290
 291                                 output_cache = true;
 292
 293                                 if (atts ["Duration"] == null)
 294                                         ThrowParseException ("The directive is missing a 'duration' attribute.");
 295                                 if (atts ["VaryByParam"] == null && atts ["VaryByControl"] == null)
 296                                         ThrowParseException ("This directive is missing 'VaryByParam' " +
 297                                                         "or 'VaryByControl' attribute, which should be set to \"none\", \"*\", " +
 298                                                         "or a list of name/value pairs.");
 299
 300                                 foreach (DictionaryEntry entry in atts) {
 301                                         string key = (string) entry.Key;
 302                                         switch (key.ToLower ()) {
 303                                         case "duration":
 304                                                 oc_duration = Int32.Parse ((string) entry.Value);
 305                                                 if (oc_duration < 1)
 306                                                         ThrowParseException ("The 'duration' attribute must be set " +
 307                                                                         "to a positive integer value");
 308                                                 break;
 309                                         case "varybyparam":
 310                                                 oc_param = (string) entry.Value;
 311                                                 if (String.Compare (oc_param, "none") == 0)
 312                                                         oc_param = null;
 313                                                 break;
 314                                         case "varybyheader":
 315                                                 oc_header = (string) entry.Value;
 316                                                 break;
 317                                         case "varybycustom":
 318                                                 oc_custom = (string) entry.Value;
 319                                                 break;
 320                                         case "location":
 321                                                 if (!(this is PageParser))
 322                                                         goto default;
 323
 324                                                 try {
 325                                                         oc_location = (OutputCacheLocation) Enum.Parse (
 326                                                                 typeof (OutputCacheLocation), (string) entry.Value, true);
 327                                                 } catch {
 328                                                         ThrowParseException ("The 'location' attribute is case sensitive and " +
 329                                                                         "must be one of the following values: Any, Client, " +
 330                                                                         "Downstream, Server, None, ServerAndClient.");
 331                                                 }
 332                                                 break;
 333                                         case "varybycontrol":
 334 #if ONLY_1_1
 335                                                 if (this is PageParser)
 336                                                         goto default;
 337 #endif
 338                                                 oc_controls = (string) entry.Value;
 339                                                 break;
 340                                         case "shared":
 341                                                 if (this is PageParser)
 342                                                         goto default;
 343
 344                                                 try {
 345                                                         oc_shared = Boolean.Parse ((string) entry.Value);
 346                                                 } catch {
 347                                                         ThrowParseException ("The 'shared' attribute is case sensitive" +
 348                                                                         " and must be set to 'true' or 'false'.");
 349                                                 }
 350                                                 break;
 351                                         default:
 352                                                 ThrowParseException ("The '" + key + "' attribute is not " +
 353                                                                 "supported by the 'Outputcache' directive.");
 354                                                 break;
 355                                         }
 356
 357                                 }
 358
 359                                 return;
 360                         }
 361
 362                         ThrowParseException ("Unknown directive: " + directive);
 363                 }
 364
 365                 internal Type LoadType (string typeName)
 366                 {
 367                         Type type = HttpApplication.LoadType (typeName);
 368                         if (type == null)
 369                                 return null;
 370                         Assembly asm = type.Assembly;
 371                         string location = asm.Location;
 372
 373                         AddDependency (location);
 374                         string dirname = Path.GetDirectoryName (location);
 375                         bool doAddAssembly = true;
 376                         foreach (string dir in HttpApplication.BinDirectories) {
 377                                 if (dirname == dir) {
 378                                         doAddAssembly = false;
 379                                         break;
 380                                 }
 381                         }
 382
 383                         if (doAddAssembly)
 384                                 AddAssembly (asm, true);
 385
 386                         return type;
 387                 }
 388
 389                 void AddAssembliesInBin ()
 390                 {
 391                         foreach (string s in HttpApplication.BinDirectoryAssemblies)
 392                                 assemblies.Add (s);
 393                 }
 394
 395                 internal virtual void AddInterface (string iface)
 396                 {
 397                         if (interfaces == null)
 398                                 interfaces = new ArrayList ();
 399
 400                         if (!interfaces.Contains (iface))
 401                                 interfaces.Add (iface);
 402                 }
 403
 404                 internal virtual void AddImport (string namesp)
 405                 {
 406                         if (imports == null)
 407                                 imports = new ArrayList ();
 408
 409                         if (!imports.Contains (namesp))
 410                                 imports.Add (namesp);
 411                 }
 412
 413                 internal virtual void AddSourceDependency (string filename)
 414                 {
 415                         if (dependencies != null && dependencies.Contains (filename)) {
 416                                 ThrowParseException ("Circular file references are not allowed. File: " + filename);
 417                         }
 418
 419                         AddDependency (filename);
 420                 }
 421
 422                 internal virtual void AddDependency (string filename)
 423                 {
 424                         if (filename == "")
 425                                 return;
 426
 427                         if (dependencies == null)
 428                                 dependencies = new ArrayList ();
 429
 430                         if (!dependencies.Contains (filename))
 431                                 dependencies.Add (filename);
 432                 }
 433
 434                 internal virtual void AddAssembly (Assembly assembly, bool fullPath)
 435                 {
 436                         if (assembly.Location == "")
 437                                 return;
 438
 439                         if (anames == null)
 440                                 anames = new Hashtable ();
 441
 442                         string name = assembly.GetName ().Name;
 443                         string loc = assembly.Location;
 444                         if (fullPath) {
 445                                 if (!assemblies.Contains (loc)) {
 446                                         assemblies.Add (loc);
 447                                 }
 448
 449                                 anames [name] = loc;
 450                                 anames [loc] = assembly;
 451                         } else {
 452                                 if (!assemblies.Contains (name)) {
 453                                         assemblies.Add (name);
 454                                 }
 455
 456                                 anames [name] = assembly;
 457                         }
 458                 }
 459
 460                 internal virtual Assembly AddAssemblyByFileName (string filename)
 461                 {
 462                         Assembly assembly = null;
 463                         Exception error = null;
 464
 465                         try {
 466                                 assembly = Assembly.LoadFrom (filename);
 467                         } catch (Exception e) { error = e; }
 468
 469                         if (assembly == null)
 470                                 ThrowParseException ("Assembly " + filename + " not found", error);
 471
 472                         AddAssembly (assembly, true);
 473                         return assembly;
 474                 }
 475
 476                 internal virtual Assembly AddAssemblyByName (string name)
 477                 {
 478                         if (anames == null)
 479                                 anames = new Hashtable ();
 480
 481                         if (anames.Contains (name)) {
 482                                 object o = anames [name];
 483                                 if (o is string)
 484                                         o = anames [o];
 485
 486                                 return (Assembly) o;
 487                         }
 488
 489                         Assembly assembly = null;
 490                         Exception error = null;
 491                         try {
 492                                 assembly = Assembly.Load (name);
 493                         } catch (Exception e) { error = e; }
 494
 495                         if (assembly == null) {
 496                                 try {
 497                                         assembly = Assembly.LoadWithPartialName (name);
 498                                 } catch (Exception e) { error = e; }
 499                         }
 500
 501                         if (assembly == null)
 502                                 ThrowParseException ("Assembly " + name + " not found", error);
 503
 504                         AddAssembly (assembly, true);
 505                         return assembly;
 506                 }
 507
 508                 internal virtual void ProcessMainAttributes (Hashtable atts)
 509                 {
 510                         atts.Remove ("Description"); // ignored
 511 #if NET_1_1
 512                         atts.Remove ("CodeBehind");  // ignored
 513 #endif
 514                         atts.Remove ("AspCompat"); // ignored
 515
 516                         debug = GetBool (atts, "Debug", true);
 517                         compilerOptions = GetString (atts, "CompilerOptions", "");
 518                         language = GetString (atts, "Language", "");
 519                         if (language.Length != 0)
 520                                 implicitLanguage = false;
 521                         else
 522                                 language = CompilationConfig.DefaultLanguage;
 523
 524                         strictOn = GetBool (atts, "Strict", CompilationConfig.Strict);
 525                         explicitOn = GetBool (atts, "Explicit", CompilationConfig.Explicit);
 526                         linePragmasOn = GetBool (atts, "LinePragmas", false);
 527
 528                         string inherits = GetString (atts, "Inherits", null);
 529 #if NET_2_0
 530                         // In ASP 2, the source file is actually integrated with
 531                         // the generated file via the use of partial classes. This
 532                         // means that the code file has to be confirmed, but not
 533                         // used at this point.
 534                         src = GetString (atts, "CodeFile", null);
 535                         codeFileBaseClass = GetString (atts, "CodeFileBaseClass", null);
 536
 537                         if (src == null && codeFileBaseClass != null)
 538                                 ThrowParseException ("The 'CodeFileBaseClass' attribute cannot be used without a 'CodeFile' attribute");
 539
 540                         if (src != null && inherits != null) {
 541                                 // Make sure the source exists
 542                                 src = UrlUtils.Combine (BaseVirtualDir, src);
 543                                 string realPath = MapPath (src, false);
 544                                 if (!File.Exists (realPath))
 545                                         ThrowParseException ("File " + src + " not found");
 546
 547                                 // We are going to create a partial class that shares
 548                                 // the same name as the inherits tag, so reset the
 549                                 // name. The base type is changed because it is the
 550                                 // code file's responsibilty to extend the classes
 551                                 // needed.
 552                                 partialClassName = inherits;
 553
 554                                 // Add the code file as an option to the
 555                                 // compiler. This lets both files be compiled at once.
 556                                 compilerOptions += " \"" + realPath + "\"";
 557
 558                                 if (codeFileBaseClass != null) {
 559                                         try {
 560                                                 codeFileBaseClassType = LoadType (codeFileBaseClass);
 561                                         } catch (Exception) {
 562                                         }
 563
 564                                         if (codeFileBaseClassType == null)
 565                                                 ThrowParseException ("Could not load type '{0}'", codeFileBaseClass);
 566                                 }
 567                         } else if (inherits != null) {
 568                                 // We just set the inherits directly because this is a
 569                                 // Single-Page model.
 570                                 SetBaseType (inherits);
 571                         }
 572 #else
 573                         string src = GetString (atts, "Src", null);
 574
 575                         if (src != null)
 576                                 srcAssembly = GetAssemblyFromSource (src);
 577
 578                         if (inherits != null)
 579                                 SetBaseType (inherits);
 580 #endif
 581                         className = GetString (atts, "ClassName", null);
 582                         if (className != null) {
 583 #if NET_2_0
 584                                 string [] identifiers = className.Split ('.');
 585                                 for (int i = 0; i < identifiers.Length; i++)
 586                                         if (!CodeGenerator.IsValidLanguageIndependentIdentifier (identifiers [i]))
 587                                                 ThrowParseException (String.Format ("'{0}' is not a valid "
 588                                                         + "value for attribute 'classname'.", className));
 589 #else
 590                                 if (!CodeGenerator.IsValidLanguageIndependentIdentifier (className))
 591                                         ThrowParseException (String.Format ("'{0}' is not a valid "
 592                                                 + "value for attribute 'classname'.", className));
 593 #endif
 594                         }
 595
 596 #if NET_2_0
 597                         if (this is TemplateControlParser)
 598                                 metaResourceKey = GetString (atts, "meta:resourcekey", null);
 599
 600                         if (inherits != null && (this is PageParser || this is UserControlParser) && atts.Count > 0) {
 601                                 if (unknownMainAttributes == null)
 602                                         unknownMainAttributes = new List <UnknownAttributeDescriptor> ();
 603                                 string key, val;
 604
 605                                 foreach (DictionaryEntry de in atts) {
 606                                         key = de.Key as string;
 607                                         val = de.Value as string;
 608
 609                                         if (String.IsNullOrEmpty (key) || String.IsNullOrEmpty (val))
 610                                                 continue;
 611                                         CheckUnknownAttribute (key, val, inherits);
 612                                 }
 613                                 return;
 614                         }
 615 #endif
 616                         if (atts.Count > 0)
 617                                 ThrowParseException ("Unknown attribute: " + GetOneKey (atts));
 618                 }
 619
 620 #if NET_2_0
 621                 void CheckUnknownAttribute (string name, string val, string inherits)
 622                 {
 623                         MemberInfo mi = null;
 624                         bool missing = false;
 625                         string memberName = name.Trim ().ToLower (CultureInfo.InvariantCulture);
 626                         Type parent = codeFileBaseClassType;
 627
 628                         if (parent == null)
 629                                 parent = baseType;
 630
 631                         try {
 632                                 MemberInfo[] infos = parent.GetMember (memberName,
 633                                                                        MemberTypes.Field | MemberTypes.Property,
 634                                                                        BindingFlags.Public | BindingFlags.Instance |
 635                                                                        BindingFlags.IgnoreCase | BindingFlags.Static);
 636                                 if (infos.Length != 0) {
 637                                         // prefer public properties to public methods (it's what MS.NET does)
 638                                         foreach (MemberInfo tmp in infos) {
 639                                                 if (tmp is PropertyInfo) {
 640                                                         mi = tmp;
 641                                                         break;
 642                                                 }
 643                                         }
 644                                         if (mi == null)
 645                                                 mi = infos [0];
 646                                 } else
 647                                         missing = true;
 648                         } catch (Exception) {
 649                                 missing = true;
 650                         }
 651                         if (missing)
 652                                 ThrowParseException (
 653                                         "Error parsing attribute '{0}': Type '{1}' does not have a public property named '{0}'",
 654                                         memberName, inherits);
 655
 656                         Type memberType = null;
 657                         if (mi is PropertyInfo) {
 658                                 PropertyInfo pi = mi as PropertyInfo;
 659
 660                                 if (!pi.CanWrite)
 661                                         ThrowParseException (
 662                                                 "Error parsing attribute '{0}': The '{0}' property is read-only and cannot be set.",
 663                                                 memberName);
 664                                 memberType = pi.PropertyType;
 665                         } else if (mi is FieldInfo) {
 666                                 memberType = ((FieldInfo)mi).FieldType;
 667                         } else
 668                                 ThrowParseException ("Could not determine member the kind of '{0}' in base type '{1}",
 669                                                      memberName, inherits);
 670                         TypeConverter converter = TypeDescriptor.GetConverter (memberType);
 671                         bool convertible = true;
 672                         object value = null;
 673
 674                         if (converter == null || !converter.CanConvertFrom (typeof (string)))
 675                                 convertible = false;
 676
 677                         if (convertible) {
 678                                 try {
 679                                         value = converter.ConvertFromInvariantString (val);
 680                                 } catch (Exception) {
 681                                         convertible = false;
 682                                 }
 683                         }
 684
 685                         if (!convertible)
 686                                 ThrowParseException ("Error parsing attribute '{0}': Cannot create an object of type '{1}' from its string representation '{2}' for the '{3}' property.",
 687                                                      memberName, memberType, val, mi.Name);
 688
 689                         UnknownAttributeDescriptor desc = new UnknownAttributeDescriptor (mi, value);
 690                         unknownMainAttributes.Add (desc);
 691                 }
 692 #endif
 693
 694                 internal void SetBaseType (string type)
 695                 {
 696                         if (type == DefaultBaseTypeName)
 697                                 return;
 698
 699                         Type parent = null;
 700                         if (srcAssembly != null)
 701                                 parent = srcAssembly.GetType (type);
 702
 703                         if (parent == null)
 704                                 parent = LoadType (type);
 705
 706                         if (parent == null)
 707                                 ThrowParseException ("Cannot find type " + type);
 708
 709                         if (!DefaultBaseType.IsAssignableFrom (parent))
 710                                 ThrowParseException ("The parent type does not derive from " + DefaultBaseType);
 711
 712                         baseType = parent;
 713                         if (parent.FullName.IndexOf ('.') == -1)
 714                                 baseTypeIsGlobal = true;
 715                 }
 716
 717                 internal void SetLanguage (string language)
 718                 {
 719                         this.language = language;
 720                         implicitLanguage = false;
 721                 }
 722
 723                 Assembly GetAssemblyFromSource (string vpath)
 724                 {
 725                         vpath = UrlUtils.Combine (BaseVirtualDir, vpath);
 726                         string realPath = MapPath (vpath, false);
 727                         if (!File.Exists (realPath))
 728                                 ThrowParseException ("File " + vpath + " not found");
 729
 730                         AddSourceDependency (realPath);
 731
 732                         CompilerResults result = CachingCompiler.Compile (language, realPath, realPath, assemblies);
 733                         if (result.NativeCompilerReturnValue != 0) {
 734                                 StreamReader reader = new StreamReader (realPath);
 735                                 throw new CompilationException (realPath, result.Errors, reader.ReadToEnd ());
 736                         }
 737
 738                         AddAssembly (result.CompiledAssembly, true);
 739                         return result.CompiledAssembly;
 740                 }
 741
 742                 internal abstract Type DefaultBaseType { get; }
 743                 internal abstract string DefaultBaseTypeName { get; }
 744                 internal abstract string DefaultDirectiveName { get; }
 745
 746                 internal string InputFile
 747                 {
 748                         get { return inputFile; }
 749                         set { inputFile = value; }
 750                 }
 751
 752 #if NET_2_0
 753                 internal bool IsPartial {
 754                         get { return src != null; }
 755                 }
 756
 757                 internal string PartialClassName {
 758                         get { return partialClassName; }
 759                 }
 760
 761                 internal string CodeFileBaseClass {
 762                         get { return codeFileBaseClass; }
 763                 }
 764
 765                 internal string MetaResourceKey {
 766                         get { return metaResourceKey; }
 767                 }
 768
 769                 internal Type CodeFileBaseClassType
 770                 {
 771                         get { return codeFileBaseClassType; }
 772                 }
 773
 774                 internal List <UnknownAttributeDescriptor> UnknownMainAttributes
 775                 {
 776                         get { return unknownMainAttributes; }
 777                 }
 778 #endif
 779
 780                 internal string Text
 781                 {
 782                         get { return text; }
 783                         set { text = value; }
 784                 }
 785
 786                 internal Type BaseType
 787                 {
 788                         get {
 789                                 if (baseType == null)
 790                                         baseType = DefaultBaseType;
 791
 792                                 return baseType;
 793                         }
 794                 }
 795
 796                 internal bool BaseTypeIsGlobal {
 797                         get { return baseTypeIsGlobal; }
 798                 }
 799
 800                 internal string ClassName {
 801                         get {
 802                                 if (className != null)
 803                                         return className;
 804
 805 #if NET_2_0
 806                                 string physPath = HttpContext.Current.Request.PhysicalApplicationPath;
 807
 808                                 if (StrUtils.StartsWith (inputFile, physPath)) {
 809                                         className = inputFile.Substring (physPath.Length).ToLower (CultureInfo.InvariantCulture);
 810                                         className = className.Replace ('.', '_');
 811                                         className = className.Replace ('/', '_').Replace ('\\', '_');
 812                                 } else
 813 #endif
 814                                 className = Path.GetFileName (inputFile).Replace ('.', '_');
 815                                 className = className.Replace ('-', '_');
 816                                 className = className.Replace (' ', '_');
 817
 818                                 if (Char.IsDigit(className[0])) {
 819                                         className = "_" + className;
 820                                 }
 821
 822                                 return className;
 823                         }
 824                 }
 825
 826                 internal ArrayList Scripts {
 827                         get {
 828                                 if (scripts == null)
 829                                         scripts = new ArrayList ();
 830
 831                                 return scripts;
 832                         }
 833                 }
 834
 835                 internal ArrayList Imports {
 836                         get { return imports; }
 837                 }
 838
 839                 internal ArrayList Assemblies {
 840                         get {
 841                                 if (appAssemblyIndex != -1) {
 842                                         object o = assemblies [appAssemblyIndex];
 843                                         assemblies.RemoveAt (appAssemblyIndex);
 844                                         assemblies.Add (o);
 845                                         appAssemblyIndex = -1;
 846                                 }
 847
 848                                 return assemblies;
 849                         }
 850                 }
 851
 852                 internal ArrayList Interfaces {
 853                         get { return interfaces; }
 854                 }
 855
 856                 internal RootBuilder RootBuilder {
 857                         get { return rootBuilder; }
 858                         set { rootBuilder = value; }
 859                 }
 860
 861                 internal ArrayList Dependencies {
 862                         get { return dependencies; }
 863                         set { dependencies = value; }
 864                 }
 865
 866                 internal string CompilerOptions {
 867                         get { return compilerOptions; }
 868                 }
 869
 870                 internal string Language {
 871                         get { return language; }
 872                 }
 873
 874                 internal bool ImplicitLanguage {
 875                         get { return implicitLanguage; }
 876                 }
 877
 878                 internal bool StrictOn {
 879                         get { return strictOn; }
 880                 }
 881
 882                 internal bool ExplicitOn {
 883                         get { return explicitOn; }
 884                 }
 885
 886                 internal bool Debug {
 887                         get { return debug; }
 888                 }
 889
 890                 internal bool OutputCache {
 891                         get { return output_cache; }
 892                 }
 893
 894                 internal int OutputCacheDuration {
 895                         get { return oc_duration; }
 896                 }
 897
 898                 internal string OutputCacheVaryByHeader {
 899                         get { return oc_header; }
 900                 }
 901
 902                 internal string OutputCacheVaryByCustom {
 903                         get { return oc_custom; }
 904                 }
 905
 906                 internal string OutputCacheVaryByControls {
 907                         get { return oc_controls; }
 908                 }
 909
 910                 internal bool OutputCacheShared {
 911                         get { return oc_shared; }
 912                 }
 913
 914                 internal OutputCacheLocation OutputCacheLocation {
 915                         get { return oc_location; }
 916                 }
 917
 918                 internal string OutputCacheVaryByParam {
 919                         get { return oc_param; }
 920                 }
 921
 922 #if NET_2_0
 923                 internal PagesSection PagesConfig {
 924                         get {
 925                                 return WebConfigurationManager.GetSection ("system.web/pages") as PagesSection;
 926                         }
 927                 }
 928 #else
 929                 internal PagesConfiguration PagesConfig {
 930                         get { return PagesConfiguration.GetInstance (Context); }
 931                 }
 932 #endif
 933         }
 934 }
 935