mcs/class/System.Web/System.Web.Compilation/TemplateControlCompiler.cs

   1 //
   2 // System.Web.Compilation.TemplateControlCompiler
   3 //
   4 // Authors:
   5 //      Gonzalo Paniagua Javier (gonzalo@ximian.com)
   6 //
   7 // (C) 2003 Ximian, Inc (http://www.ximian.com)
   8 //
   9
  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 using System;
  31 using System.CodeDom;
  32 using System.Collections;
  33 using System.ComponentModel;
  34 using System.Drawing;
  35 using System.Globalization;
  36 using System.Reflection;
  37 using System.Text;
  38 using System.Web;
  39 using System.Web.UI;
  40 using System.ComponentModel.Design.Serialization;
  41 #if NET_2_0
  42 using System.Collections.Specialized;
  43 using System.Text.RegularExpressions;
  44 #endif
  45
  46 namespace System.Web.Compilation
  47 {
  48         class TemplateControlCompiler : BaseCompiler
  49         {
  50                 static BindingFlags noCaseFlags = BindingFlags.Public | BindingFlags.NonPublic |
  51                                                   BindingFlags.Instance | BindingFlags.IgnoreCase;
  52
  53                 TemplateControlParser parser;
  54                 int dataBoundAtts;
  55                 ILocation currentLocation;
  56
  57                 static TypeConverter colorConverter;
  58
  59                 static CodeVariableReferenceExpression ctrlVar = new CodeVariableReferenceExpression ("__ctrl");
  60
  61 #if NET_2_0
  62                 static Regex bindRegex = new Regex (@"Bind\s*\(""(.*?)""\)\s*%>", RegexOptions.Compiled);
  63 #endif
  64
  65                 public TemplateControlCompiler (TemplateControlParser parser)
  66                         : base (parser)
  67                 {
  68                         this.parser = parser;
  69                 }
  70
  71                 void EnsureID (ControlBuilder builder)
  72                 {
  73                         if (builder.ID == null || builder.ID.Trim () == "")
  74                                 builder.ID = builder.GetNextID (null);
  75                 }
  76
  77                 void CreateField (ControlBuilder builder, bool check)
  78                 {
  79                         currentLocation = builder.location;
  80                         if (check && CheckBaseFieldOrProperty (builder.ID, builder.ControlType))
  81                                 return; // The field or property already exists in a base class and is accesible.
  82
  83                         CodeMemberField field;
  84                         field = new CodeMemberField (builder.ControlType.FullName, builder.ID);
  85                         field.Attributes = MemberAttributes.Family;
  86                         mainClass.Members.Add (field);
  87                 }
  88
  89                 bool CheckBaseFieldOrProperty (string id, Type type)
  90                 {
  91                         FieldInfo fld = parser.BaseType.GetField (id, noCaseFlags);
  92
  93                         Type other = null;
  94                         if (fld == null || fld.IsPrivate) {
  95                                 PropertyInfo prop = parser.BaseType.GetProperty (id, noCaseFlags);
  96                                 if (prop != null) {
  97                                         MethodInfo setm = prop.GetSetMethod (true);
  98                                         if (setm != null)
  99                                                 other = prop.PropertyType;
 100                                 }
 101                         } else {
 102                                 other = fld.FieldType;
 103                         }
 104
 105                         if (other == null)
 106                                 return false;
 107
 108                         if (!other.IsAssignableFrom (type)) {
 109                                 string msg = String.Format ("The base class includes the field '{0}', but its " +
 110                                                             "type '{1}' is not compatible with {2}",
 111                                                             id, other, type);
 112                                 throw new ParseException (currentLocation, msg);
 113                         }
 114
 115                         return true;
 116                 }
 117
 118                 void AddParsedSubObjectStmt (ControlBuilder builder, CodeExpression expr)
 119                 {
 120                         if (!builder.haveParserVariable) {
 121                                 CodeVariableDeclarationStatement p = new CodeVariableDeclarationStatement();
 122                                 p.Name = "__parser";
 123                                 p.Type = new CodeTypeReference (typeof (IParserAccessor));
 124                                 p.InitExpression = new CodeCastExpression (typeof (IParserAccessor), ctrlVar);
 125                                 builder.method.Statements.Add (p);
 126                                 builder.haveParserVariable = true;
 127                         }
 128
 129                         CodeVariableReferenceExpression var = new CodeVariableReferenceExpression ("__parser");
 130                         CodeMethodInvokeExpression invoke = new CodeMethodInvokeExpression (var, "AddParsedSubObject");
 131                         invoke.Parameters.Add (expr);
 132                         builder.method.Statements.Add (invoke);
 133                 }
 134
 135                 void InitMethod (ControlBuilder builder, bool isTemplate, bool childrenAsProperties)
 136                 {
 137                         string tailname = ((builder is RootBuilder) ? "Tree" : ("_" + builder.ID));
 138                         CodeMemberMethod method = new CodeMemberMethod ();
 139                         builder.method = method;
 140                         method.Name = "__BuildControl" + tailname;
 141                         method.Attributes = MemberAttributes.Private | MemberAttributes.Final;
 142                         Type type = builder.ControlType;
 143
 144                         if (builder.HasAspCode) {
 145                                 CodeMemberMethod renderMethod = new CodeMemberMethod ();
 146                                 builder.renderMethod = renderMethod;
 147                                 renderMethod.Name = "__Render" + tailname;
 148                                 renderMethod.Attributes = MemberAttributes.Private | MemberAttributes.Final;
 149                                 CodeParameterDeclarationExpression arg1 = new CodeParameterDeclarationExpression ();
 150                                 arg1.Type = new CodeTypeReference (typeof (HtmlTextWriter));
 151                                 arg1.Name = "__output";
 152                                 CodeParameterDeclarationExpression arg2 = new CodeParameterDeclarationExpression ();
 153                                 arg2.Type = new CodeTypeReference (typeof (Control));
 154                                 arg2.Name = "parameterContainer";
 155                                 renderMethod.Parameters.Add (arg1);
 156                                 renderMethod.Parameters.Add (arg2);
 157                                 mainClass.Members.Add (renderMethod);
 158                         }
 159
 160                         if (childrenAsProperties || builder.ControlType == null) {
 161                                 string typeString;
 162                                 if (builder.ControlType != null && builder.isProperty &&
 163                                     !typeof (ITemplate).IsAssignableFrom (builder.ControlType))
 164                                         typeString = builder.ControlType.FullName;
 165                                 else
 166                                         typeString = "System.Web.UI.Control";
 167
 168                                 method.Parameters.Add (new CodeParameterDeclarationExpression (typeString, "__ctrl"));
 169                         } else {
 170
 171                                 if (typeof (Control).IsAssignableFrom (type))
 172                                         method.ReturnType = new CodeTypeReference (typeof (Control));
 173
 174                                 CodeObjectCreateExpression newExpr = new CodeObjectCreateExpression (type);
 175
 176                                 object [] atts = type.GetCustomAttributes (typeof (ConstructorNeedsTagAttribute), true);
 177                                 if (atts != null && atts.Length > 0) {
 178                                         ConstructorNeedsTagAttribute att = (ConstructorNeedsTagAttribute) atts [0];
 179                                         if (att.NeedsTag)
 180                                                 newExpr.Parameters.Add (new CodePrimitiveExpression (builder.TagName));
 181                                 } else if (builder is DataBindingBuilder) {
 182                                         newExpr.Parameters.Add (new CodePrimitiveExpression (0));
 183                                         newExpr.Parameters.Add (new CodePrimitiveExpression (1));
 184                                 }
 185
 186                                 method.Statements.Add (new CodeVariableDeclarationStatement (builder.ControlType, "__ctrl"));
 187                                 CodeAssignStatement assign = new CodeAssignStatement ();
 188                                 assign.Left = ctrlVar;
 189                                 assign.Right = newExpr;
 190                                 method.Statements.Add (assign);
 191
 192                                 CodeFieldReferenceExpression builderID = new CodeFieldReferenceExpression ();
 193                                 builderID.TargetObject = thisRef;
 194                                 builderID.FieldName = builder.ID;
 195                                 assign = new CodeAssignStatement ();
 196                                 assign.Left = builderID;
 197                                 assign.Right = ctrlVar;
 198                                 method.Statements.Add (assign);
 199                                 if (typeof (UserControl).IsAssignableFrom (type)) {
 200                                         CodeMethodReferenceExpression mref = new CodeMethodReferenceExpression ();
 201                                         mref.TargetObject = builderID;
 202                                         mref.MethodName = "InitializeAsUserControl";
 203                                         CodeMethodInvokeExpression initAsControl = new CodeMethodInvokeExpression (mref);
 204                                         initAsControl.Parameters.Add (new CodePropertyReferenceExpression (thisRef, "Page"));
 205                                         method.Statements.Add (initAsControl);
 206                                 }
 207 #if NET_2_0
 208                                 if (typeof (System.Web.UI.WebControls.ContentPlaceHolder).IsAssignableFrom (type)) {
 209                                         CodePropertyReferenceExpression prop = new CodePropertyReferenceExpression (thisRef, "ContentPlaceHolders");
 210                                         CodeMethodInvokeExpression addPlaceholder = new CodeMethodInvokeExpression (prop, "Add");
 211                                         addPlaceholder.Parameters.Add (ctrlVar);
 212                                         method.Statements.Add (addPlaceholder);
 213                                 }
 214 #endif
 215                         }
 216
 217                         mainClass.Members.Add (method);
 218                 }
 219
 220                 void AddLiteralSubObject (ControlBuilder builder, string str)
 221                 {
 222                         if (!builder.HasAspCode) {
 223                                 CodeObjectCreateExpression expr;
 224                                 expr = new CodeObjectCreateExpression (typeof (LiteralControl), new CodePrimitiveExpression (str));
 225                                 AddParsedSubObjectStmt (builder, expr);
 226                         } else {
 227                                 CodeMethodReferenceExpression methodRef = new CodeMethodReferenceExpression ();
 228                                 methodRef.TargetObject = new CodeArgumentReferenceExpression ("__output");
 229                                 methodRef.MethodName = "Write";
 230
 231                                 CodeMethodInvokeExpression expr;
 232                                 expr = new CodeMethodInvokeExpression (methodRef, new CodePrimitiveExpression (str));
 233                                 builder.renderMethod.Statements.Add (expr);
 234                         }
 235                 }
 236
 237                 string TrimDB (string value)
 238                 {
 239                         string str = value.Trim ();
 240                         str = str.Substring (3);
 241                         return str.Substring (0, str.Length - 2);
 242                 }
 243
 244                 string DataBoundProperty (ControlBuilder builder, Type type, string varName, string value)
 245                 {
 246                         value = TrimDB (value);
 247                         CodeMemberMethod method;
 248                         string dbMethodName = builder.method.Name + "_DB_" + dataBoundAtts++;
 249
 250                         method = CreateDBMethod (dbMethodName, GetContainerType (builder), builder.ControlType);
 251
 252                         CodeVariableReferenceExpression targetExpr = new CodeVariableReferenceExpression ("target");
 253
 254                         // This should be a CodePropertyReferenceExpression for properties... but it works anyway
 255                         CodeFieldReferenceExpression field = new CodeFieldReferenceExpression (targetExpr, varName);
 256
 257                         CodeExpression expr;
 258                         if (type == typeof (string)) {
 259                                 CodeMethodInvokeExpression tostring = new CodeMethodInvokeExpression ();
 260                                 CodeTypeReferenceExpression conv = new CodeTypeReferenceExpression (typeof (Convert));
 261                                 tostring.Method = new CodeMethodReferenceExpression (conv, "ToString");
 262                                 tostring.Parameters.Add (new CodeSnippetExpression (value));
 263                                 expr = tostring;
 264                         } else {
 265                                 CodeSnippetExpression snippet = new CodeSnippetExpression (value);
 266                                 expr = new CodeCastExpression (type, snippet);
 267                         }
 268
 269                         method.Statements.Add (new CodeAssignStatement (field, expr));
 270                         mainClass.Members.Add (method);
 271                         return method.Name;
 272                 }
 273
 274                 void AddCodeForPropertyOrField (ControlBuilder builder, Type type, string var_name, string att, MemberInfo member, bool isDataBound)
 275                 {
 276                         CodeMemberMethod method = builder.method;
 277                         if (isDataBound) {
 278                                 string dbMethodName = DataBoundProperty (builder, type, var_name, att);
 279                                 AddEventAssign (method, "DataBinding", typeof (EventHandler), dbMethodName);
 280                                 return;
 281                         }
 282
 283                         CodeAssignStatement assign = new CodeAssignStatement ();
 284                         assign.Left = new CodePropertyReferenceExpression (ctrlVar, var_name);
 285                         currentLocation = builder.location;
 286                         assign.Right = GetExpressionFromString (type, att, member);
 287
 288                         method.Statements.Add (assign);
 289                 }
 290
 291                 bool IsDataBound (string value)
 292                 {
 293                         if (value == null || value == "")
 294                                 return false;
 295
 296                         string str = value.Trim ();
 297                         return (str.StartsWith ("<%#") && str.EndsWith ("%>"));
 298                 }
 299
 300 #if NET_2_0
 301                 void RegisterBindingInfo (ControlBuilder builder, string propName, ref string value)
 302                 {
 303                         string str = value.Trim ();
 304                         str = str.Substring (3).Trim ();        // eats "<%#"
 305                         if (str.StartsWith ("Bind")) {
 306                                 Match match = bindRegex.Match (str);
 307                                 if (match.Success) {
 308                                         string bindingName = match.Groups [1].Value;
 309
 310                                         TemplateBuilder templateBuilder = builder.ParentTemplateBuilder;
 311                                         if (templateBuilder == null || templateBuilder.BindingDirection == BindingDirection.OneWay)
 312                                                 throw new HttpException ("Bind expression not allowed in this context.");
 313
 314                                         string id = builder.attribs ["ID"] as string;
 315                                         if (id == null)
 316                                                 throw new HttpException ("Control of type '" + builder.ControlType + "' using two-way binding on property '" + propName + "' must have an ID.");
 317
 318                                         templateBuilder.RegisterBoundProperty (builder.ControlType, propName, id, bindingName);
 319                                         value = "<%# Eval" + str.Substring (4);
 320                                 }
 321                         }
 322                 }
 323 #endif
 324
 325                 bool ProcessPropertiesAndFields (ControlBuilder builder, MemberInfo member, string id, string attValue)
 326                 {
 327                         int hyphen = id.IndexOf ('-');
 328
 329                         bool isPropertyInfo = (member is PropertyInfo);
 330                         bool is_processed = false;
 331                         bool isDataBound = IsDataBound (attValue);
 332
 333                         Type type;
 334                         if (isPropertyInfo) {
 335                                 type = ((PropertyInfo) member).PropertyType;
 336                                 if (hyphen == -1 && ((PropertyInfo) member).CanWrite == false)
 337                                         return false;
 338                         } else {
 339                                 type = ((FieldInfo) member).FieldType;
 340                         }
 341
 342                         if (0 == String.Compare (member.Name, id, true)){
 343 #if NET_2_0
 344                                 if (isDataBound) RegisterBindingInfo (builder, member.Name, ref attValue);
 345 #endif
 346                                 AddCodeForPropertyOrField (builder, type, member.Name, attValue, member, isDataBound);
 347                                 return true;
 348                         }
 349
 350                         if (hyphen == -1)
 351                                 return false;
 352
 353                         string prop_field = id.Replace ("-", ".");
 354                         string [] parts = prop_field.Split (new char [] {'.'});
 355                         if (parts.Length != 2 || 0 != String.Compare (member.Name, parts [0], true))
 356                                 return false;
 357
 358                         PropertyInfo [] subprops = type.GetProperties ();
 359                         foreach (PropertyInfo subprop in subprops) {
 360                                 if (0 != String.Compare (subprop.Name, parts [1], true))
 361                                         continue;
 362
 363                                 if (subprop.CanWrite == false)
 364                                         return false;
 365
 366                                 bool is_bool = subprop.PropertyType == typeof (bool);
 367                                 if (!is_bool && attValue == null)
 368                                         return false; // Font-Size -> Font-Size="" as html
 369
 370                                 string value;
 371                                 if (attValue == null && is_bool)
 372                                         value = "true"; // Font-Bold <=> Font-Bold="true"
 373                                 else
 374                                         value = attValue;
 375
 376 #if NET_2_0
 377                                 if (isDataBound) RegisterBindingInfo (builder, member.Name + "." + subprop.Name, ref attValue);
 378 #endif
 379                                 AddCodeForPropertyOrField (builder, subprop.PropertyType,
 380                                                  member.Name + "." + subprop.Name,
 381                                                  value, subprop, isDataBound);
 382                                 is_processed = true;
 383                         }
 384
 385                         return is_processed;
 386                 }
 387
 388                 void AddEventAssign (CodeMemberMethod method, string name, Type type, string value)
 389                 {
 390                         //"__ctrl.{0} += new {1} (this.{2});"
 391                         CodeEventReferenceExpression evtID = new CodeEventReferenceExpression (ctrlVar, name);
 392
 393                         CodeDelegateCreateExpression create;
 394                         create = new CodeDelegateCreateExpression (new CodeTypeReference (type), thisRef, value);
 395
 396                         CodeAttachEventStatement attach = new CodeAttachEventStatement (evtID, create);
 397                         method.Statements.Add (attach);
 398                 }
 399
 400                 void CreateAssignStatementsFromAttributes (ControlBuilder builder)
 401                 {
 402                         this.dataBoundAtts = 0;
 403                         IDictionary atts = builder.attribs;
 404                         if (atts == null || atts.Count == 0)
 405                                 return;
 406
 407                         EventInfo [] ev_info = null;
 408                         PropertyInfo [] prop_info = null;
 409                         FieldInfo [] field_info = null;
 410                         bool is_processed = false;
 411                         Type type = builder.ControlType;
 412
 413                         foreach (string id in atts.Keys){
 414                                 if (0 == String.Compare (id, "runat", true))
 415                                         continue;
 416
 417                                 is_processed = false;
 418                                 string attvalue = atts [id] as string;
 419                                 if (id.Length > 2 && id.Substring (0, 2).ToUpper () == "ON"){
 420                                         if (ev_info == null)
 421                                                 ev_info = type.GetEvents ();
 422
 423                                         string id_as_event = id.Substring (2);
 424                                         foreach (EventInfo ev in ev_info){
 425                                                 if (0 == String.Compare (ev.Name, id_as_event, true)){
 426                                                         AddEventAssign (builder.method,
 427                                                                         ev.Name,
 428                                                                         ev.EventHandlerType,
 429                                                                         attvalue);
 430
 431                                                         is_processed = true;
 432                                                         break;
 433                                                 }
 434                                         }
 435
 436                                         if (is_processed)
 437                                                 continue;
 438                                 }
 439
 440                                 if (prop_info == null)
 441                                         prop_info = type.GetProperties ();
 442
 443                                 foreach (PropertyInfo prop in prop_info) {
 444                                         is_processed = ProcessPropertiesAndFields (builder, prop, id, attvalue);
 445                                         if (is_processed)
 446                                                 break;
 447                                 }
 448
 449                                 if (is_processed)
 450                                         continue;
 451
 452                                 if (field_info == null)
 453                                         field_info = type.GetFields ();
 454
 455                                 foreach (FieldInfo field in field_info){
 456                                         is_processed = ProcessPropertiesAndFields (builder, field, id, attvalue);
 457                                         if (is_processed)
 458                                                 break;
 459                                 }
 460
 461                                 if (is_processed)
 462                                         continue;
 463
 464                                 if (!typeof (IAttributeAccessor).IsAssignableFrom (type))
 465                                         throw new ParseException (builder.location, "Unrecognized attribute: " + id);
 466
 467
 468                                 CodeCastExpression cast = new CodeCastExpression (typeof (IAttributeAccessor), ctrlVar);
 469                                 CodeMethodReferenceExpression methodExpr;
 470                                 methodExpr = new CodeMethodReferenceExpression (cast, "SetAttribute");
 471                                 CodeMethodInvokeExpression expr = new CodeMethodInvokeExpression (methodExpr);
 472                                 expr.Parameters.Add (new CodePrimitiveExpression (id));
 473                                 expr.Parameters.Add (new CodePrimitiveExpression ((string) atts [id]));
 474                                 builder.method.Statements.Add (expr);
 475                         }
 476                 }
 477
 478                 void AddRenderControl (ControlBuilder builder)
 479                 {
 480                         CodeIndexerExpression indexer = new CodeIndexerExpression ();
 481                         indexer.TargetObject = new CodePropertyReferenceExpression (
 482                                                         new CodeArgumentReferenceExpression ("parameterContainer"),
 483                                                         "Controls");
 484
 485                         indexer.Indices.Add (new CodePrimitiveExpression (builder.renderIndex));
 486
 487                         CodeMethodInvokeExpression invoke = new CodeMethodInvokeExpression (indexer, "RenderControl");
 488                         invoke.Parameters.Add (new CodeArgumentReferenceExpression ("__output"));
 489                         builder.renderMethod.Statements.Add (invoke);
 490                         builder.renderIndex++;
 491                 }
 492
 493                 void AddChildCall (ControlBuilder parent, ControlBuilder child)
 494                 {
 495                         CodeMethodReferenceExpression m = new CodeMethodReferenceExpression (thisRef, child.method.Name);
 496                         CodeMethodInvokeExpression expr = new CodeMethodInvokeExpression (m);
 497
 498                         object [] atts = child.ControlType.GetCustomAttributes (typeof (PartialCachingAttribute), true);
 499                         if (atts != null && atts.Length > 0) {
 500                                 PartialCachingAttribute pca = (PartialCachingAttribute) atts [0];
 501                                 CodeTypeReferenceExpression cc = new CodeTypeReferenceExpression("System.Web.UI.StaticPartialCachingControl");
 502                                 CodeMethodInvokeExpression build = new CodeMethodInvokeExpression (cc, "BuildCachedControl");
 503                                 build.Parameters.Add (new CodeArgumentReferenceExpression("__ctrl"));
 504                                 build.Parameters.Add (new CodePrimitiveExpression (child.ID));
 505 #if NET_1_1
 506                                 if (pca.Shared)
 507                                         build.Parameters.Add (new CodePrimitiveExpression (child.ControlType.GetHashCode ().ToString ()));
 508                                 else
 509 #endif
 510                                         build.Parameters.Add (new CodePrimitiveExpression (Guid.NewGuid ().ToString ()));
 511
 512                                 build.Parameters.Add (new CodePrimitiveExpression (pca.Duration));
 513                                 build.Parameters.Add (new CodePrimitiveExpression (pca.VaryByParams));
 514                                 build.Parameters.Add (new CodePrimitiveExpression (pca.VaryByControls));
 515                                 build.Parameters.Add (new CodePrimitiveExpression (pca.VaryByCustom));
 516                                 build.Parameters.Add (new CodeDelegateCreateExpression (
 517                                                               new CodeTypeReference (typeof (System.Web.UI.BuildMethod)),
 518                                                               thisRef, child.method.Name));
 519
 520                                 parent.method.Statements.Add (build);
 521                                 if (parent.HasAspCode)
 522                                         AddRenderControl (parent);
 523                                 return;
 524                         }
 525
 526                         if (child.isProperty || parent.ChildrenAsProperties) {
 527                                 expr.Parameters.Add (new CodeFieldReferenceExpression (ctrlVar, child.TagName));
 528                                 parent.method.Statements.Add (expr);
 529                                 return;
 530                         }
 531
 532                         parent.method.Statements.Add (expr);
 533                         CodeFieldReferenceExpression field = new CodeFieldReferenceExpression (thisRef, child.ID);
 534                         if (parent.ControlType == null || typeof (IParserAccessor).IsAssignableFrom (parent.ControlType)) {
 535                                 AddParsedSubObjectStmt (parent, field);
 536                         } else {
 537                                 CodeMethodInvokeExpression invoke = new CodeMethodInvokeExpression (ctrlVar, "Add");
 538                                 invoke.Parameters.Add (field);
 539                                 parent.method.Statements.Add (invoke);
 540                         }
 541
 542                         if (parent.HasAspCode)
 543                                 AddRenderControl (parent);
 544                 }
 545
 546                 void AddTemplateInvocation (CodeMemberMethod method, string name, string methodName)
 547                 {
 548                         CodePropertyReferenceExpression prop = new CodePropertyReferenceExpression (ctrlVar, name);
 549
 550                         CodeObjectCreateExpression newBuild = new CodeObjectCreateExpression (typeof (BuildTemplateMethod));
 551                         newBuild.Parameters.Add (new CodeMethodReferenceExpression (thisRef, methodName));
 552
 553                         CodeObjectCreateExpression newCompiled = new CodeObjectCreateExpression (typeof (CompiledTemplateBuilder));
 554                         newCompiled.Parameters.Add (newBuild);
 555
 556                         CodeAssignStatement assign = new CodeAssignStatement (prop, newCompiled);
 557                         method.Statements.Add (assign);
 558                 }
 559
 560 #if NET_2_0
 561                 void AddBindableTemplateInvocation (CodeMemberMethod method, string name, string methodName, string extractMethodName)
 562                 {
 563                         CodePropertyReferenceExpression prop = new CodePropertyReferenceExpression (ctrlVar, name);
 564
 565                         CodeObjectCreateExpression newBuild = new CodeObjectCreateExpression (typeof (BuildTemplateMethod));
 566                         newBuild.Parameters.Add (new CodeMethodReferenceExpression (thisRef, methodName));
 567
 568                         CodeObjectCreateExpression newExtract = new CodeObjectCreateExpression (typeof (ExtractTemplateValuesMethod));
 569                         newExtract.Parameters.Add (new CodeMethodReferenceExpression (thisRef, extractMethodName));
 570
 571                         CodeObjectCreateExpression newCompiled = new CodeObjectCreateExpression (typeof (CompiledBindableTemplateBuilder));
 572                         newCompiled.Parameters.Add (newBuild);
 573                         newCompiled.Parameters.Add (newExtract);
 574
 575                         CodeAssignStatement assign = new CodeAssignStatement (prop, newCompiled);
 576                         method.Statements.Add (assign);
 577                 }
 578
 579                 string CreateExtractValuesMethod (TemplateBuilder builder)
 580                 {
 581                         CodeMemberMethod method = new CodeMemberMethod ();
 582                         method.Name = "__ExtractValues_" + builder.ID;
 583                         method.Attributes = MemberAttributes.Private | MemberAttributes.Final;
 584                         method.ReturnType = new CodeTypeReference (typeof(IOrderedDictionary));
 585
 586                         CodeParameterDeclarationExpression arg = new CodeParameterDeclarationExpression ();
 587                         arg.Type = new CodeTypeReference (typeof (Control));
 588                         arg.Name = "__container";
 589                         method.Parameters.Add (arg);
 590                         mainClass.Members.Add (method);
 591
 592                         CodeObjectCreateExpression newTable = new CodeObjectCreateExpression ();
 593                         newTable.CreateType = new CodeTypeReference (typeof(OrderedDictionary));
 594                         method.Statements.Add (new CodeVariableDeclarationStatement (typeof(OrderedDictionary), "__table", newTable));
 595                         CodeVariableReferenceExpression tableExp = new CodeVariableReferenceExpression ("__table");
 596
 597                         if (builder.Bindings != null) {
 598                                 foreach (TemplateBinding binding in builder.Bindings) {
 599                                         CodeVariableDeclarationStatement dec = new CodeVariableDeclarationStatement (binding.ControlType, binding.ControlId);
 600                                         method.Statements.Add (dec);
 601                                         CodeVariableReferenceExpression cter = new CodeVariableReferenceExpression ("__container");
 602                                         CodeMethodInvokeExpression invoke = new CodeMethodInvokeExpression (cter, "FindControl");
 603                                         invoke.Parameters.Add (new CodePrimitiveExpression (binding.ControlId));
 604
 605                                         CodeAssignStatement assign = new CodeAssignStatement ();
 606                                         CodeVariableReferenceExpression control = new CodeVariableReferenceExpression (binding.ControlId);
 607                                         assign.Left = control;
 608                                         assign.Right = new CodeCastExpression (binding.ControlType, invoke);
 609                                         method.Statements.Add (assign);
 610
 611                                         CodeConditionStatement sif = new CodeConditionStatement ();
 612                                         sif.Condition = new CodeBinaryOperatorExpression (control, CodeBinaryOperatorType.IdentityInequality, new CodePrimitiveExpression (null));
 613
 614                                         assign = new CodeAssignStatement ();
 615                                         assign.Left = new CodeIndexerExpression (tableExp, new CodePrimitiveExpression (binding.FieldName));
 616                                         assign.Right = new CodePropertyReferenceExpression (control, binding.ControlProperty);
 617                                         sif.TrueStatements.Add (assign);
 618                                         method.Statements.Add (sif);
 619                                 }
 620                         }
 621
 622                         method.Statements.Add (new CodeMethodReturnStatement (tableExp));
 623                         return method.Name;
 624                 }
 625
 626                 void AddContentTemplateInvocation (ContentControlBuilder cbuilder, CodeMemberMethod method, string methodName)
 627                 {
 628                         CodeObjectCreateExpression newBuild = new CodeObjectCreateExpression (typeof (BuildTemplateMethod));
 629                         newBuild.Parameters.Add (new CodeMethodReferenceExpression (thisRef, methodName));
 630
 631                         CodeObjectCreateExpression newCompiled = new CodeObjectCreateExpression (typeof (CompiledTemplateBuilder));
 632                         newCompiled.Parameters.Add (newBuild);
 633
 634                         CodeMethodInvokeExpression invoke = new CodeMethodInvokeExpression (thisRef, "AddContentTemplate");
 635                         invoke.Parameters.Add (new CodePrimitiveExpression (cbuilder.ContentPlaceHolderID));
 636                         invoke.Parameters.Add (newCompiled);
 637
 638                         method.Statements.Add (invoke);
 639                 }
 640 #endif
 641
 642                 void AddCodeRender (ControlBuilder parent, CodeRenderBuilder cr)
 643                 {
 644                         if (cr.Code == null || cr.Code.Trim () == "")
 645                                 return;
 646
 647                         if (!cr.IsAssign) {
 648                                 CodeSnippetStatement code = new CodeSnippetStatement (cr.Code);
 649                                 parent.renderMethod.Statements.Add (code);
 650                                 return;
 651                         }
 652
 653                         CodeMethodInvokeExpression expr = new CodeMethodInvokeExpression ();
 654                         expr.Method = new CodeMethodReferenceExpression (
 655                                                         new CodeArgumentReferenceExpression ("__output"),
 656                                                         "Write");
 657
 658                         expr.Parameters.Add (new CodeSnippetExpression (cr.Code));
 659                         parent.renderMethod.Statements.Add (expr);
 660                 }
 661
 662                 static Type GetContainerType (ControlBuilder builder)
 663                 {
 664                         TemplateBuilder tb = builder as TemplateBuilder;
 665                         if (tb != null && tb.ContainerType != null)
 666                                 return tb.ContainerType;
 667
 668                         Type type = builder.BindingContainerType;
 669
 670                         PropertyInfo prop = type.GetProperty ("Items", noCaseFlags);
 671                         if (prop == null)
 672                                 return type;
 673
 674                         Type ptype = prop.PropertyType;
 675                         if (!typeof (ICollection).IsAssignableFrom (ptype))
 676                                 return type;
 677
 678                         prop = ptype.GetProperty ("Item", noCaseFlags);
 679                         if (prop == null)
 680                                 return type;
 681
 682                         return prop.PropertyType;
 683                 }
 684
 685                 CodeMemberMethod CreateDBMethod (string name, Type container, Type target)
 686                 {
 687                         CodeMemberMethod method = new CodeMemberMethod ();
 688                         method.Attributes = MemberAttributes.Public | MemberAttributes.Final;
 689                         method.Name = name;
 690                         method.Parameters.Add (new CodeParameterDeclarationExpression (typeof (object), "sender"));
 691                         method.Parameters.Add (new CodeParameterDeclarationExpression (typeof (EventArgs), "e"));
 692
 693                         CodeTypeReference containerRef = new CodeTypeReference (container);
 694                         CodeTypeReference targetRef = new CodeTypeReference (target);
 695
 696                         CodeVariableDeclarationStatement decl = new CodeVariableDeclarationStatement();
 697                         decl.Name = "Container";
 698                         decl.Type = containerRef;
 699                         method.Statements.Add (decl);
 700
 701                         decl = new CodeVariableDeclarationStatement();
 702                         decl.Name = "target";
 703                         decl.Type = targetRef;
 704                         method.Statements.Add (decl);
 705
 706                         CodeVariableReferenceExpression targetExpr = new CodeVariableReferenceExpression ("target");
 707                         CodeAssignStatement assign = new CodeAssignStatement ();
 708                         assign.Left = targetExpr;
 709                         assign.Right = new CodeCastExpression (targetRef, new CodeArgumentReferenceExpression ("sender"));
 710                         method.Statements.Add (assign);
 711
 712                         assign = new CodeAssignStatement ();
 713                         assign.Left = new CodeVariableReferenceExpression ("Container");
 714                         assign.Right = new CodeCastExpression (containerRef,
 715                                                 new CodePropertyReferenceExpression (targetExpr, "BindingContainer"));
 716                         method.Statements.Add (assign);
 717
 718                         return method;
 719                 }
 720
 721                 void AddDataBindingLiteral (ControlBuilder builder, DataBindingBuilder db)
 722                 {
 723                         if (db.Code == null || db.Code.Trim () == "")
 724                                 return;
 725
 726                         EnsureID (db);
 727                         CreateField (db, false);
 728
 729                         string dbMethodName = "__DataBind_" + db.ID;
 730                         // Add the method that builds the DataBoundLiteralControl
 731                         InitMethod (db, false, false);
 732                         CodeMemberMethod method = db.method;
 733                         AddEventAssign (method, "DataBinding", typeof (EventHandler), dbMethodName);
 734                         method.Statements.Add (new CodeMethodReturnStatement (ctrlVar));
 735
 736                         // Add the DataBind handler
 737                         method = CreateDBMethod (dbMethodName, GetContainerType (builder), typeof (DataBoundLiteralControl));
 738
 739                         CodeVariableReferenceExpression targetExpr = new CodeVariableReferenceExpression ("target");
 740                         CodeMethodInvokeExpression invoke = new CodeMethodInvokeExpression ();
 741                         invoke.Method = new CodeMethodReferenceExpression (targetExpr, "SetDataBoundString");
 742                         invoke.Parameters.Add (new CodePrimitiveExpression (0));
 743
 744                         CodeMethodInvokeExpression tostring = new CodeMethodInvokeExpression ();
 745                         tostring.Method = new CodeMethodReferenceExpression (
 746                                                         new CodeTypeReferenceExpression (typeof (Convert)),
 747                                                         "ToString");
 748                         tostring.Parameters.Add (new CodeSnippetExpression (db.Code));
 749                         invoke.Parameters.Add (tostring);
 750                         method.Statements.Add (invoke);
 751
 752                         mainClass.Members.Add (method);
 753
 754                         AddChildCall (builder, db);
 755                 }
 756
 757                 void FlushText (ControlBuilder builder, StringBuilder sb)
 758                 {
 759                         if (sb.Length > 0) {
 760                                 AddLiteralSubObject (builder, sb.ToString ());
 761                                 sb.Length = 0;
 762                         }
 763                 }
 764
 765                 void CreateControlTree (ControlBuilder builder, bool inTemplate, bool childrenAsProperties)
 766                 {
 767                         EnsureID (builder);
 768                         bool isTemplate = (typeof (TemplateBuilder).IsAssignableFrom (builder.GetType ()));
 769                         if (!isTemplate && !inTemplate) {
 770                                 CreateField (builder, true);
 771                         } else if (!isTemplate) {
 772                                 builder.ID = builder.GetNextID (null);
 773                                 CreateField (builder, false);
 774                         }
 775
 776                         InitMethod (builder, isTemplate, childrenAsProperties);
 777                         if (!isTemplate || builder.GetType () == typeof (RootBuilder))
 778                                 CreateAssignStatementsFromAttributes (builder);
 779
 780                         if (builder.Children != null && builder.Children.Count > 0) {
 781                                 ArrayList templates = null;
 782
 783                                 StringBuilder sb = new StringBuilder ();
 784                                 foreach (object b in builder.Children) {
 785
 786                                         if (b is string) {
 787                                                 sb.Append ((string) b);
 788                                                 continue;
 789                                         }
 790
 791                                         FlushText (builder, sb);
 792                                         if (b is ObjectTagBuilder) {
 793                                                 ProcessObjectTag ((ObjectTagBuilder) b);
 794                                                 continue;
 795                                         }
 796
 797 #if NET_2_0
 798                                         if (b is ContentControlBuilder) {
 799                                                 ContentControlBuilder cb = (ContentControlBuilder) b;
 800                                                 CreateControlTree (cb, false, true);
 801                                                 AddContentTemplateInvocation (cb, builder.method, cb.method.Name);
 802                                                 continue;
 803                                         }
 804 #endif
 805
 806                                         if (b is TemplateBuilder) {
 807                                                 if (templates == null)
 808                                                         templates = new ArrayList ();
 809
 810                                                 templates.Add (b);
 811                                                 continue;
 812                                         }
 813
 814                                         if (b is CodeRenderBuilder) {
 815                                                 AddCodeRender (builder, (CodeRenderBuilder) b);
 816                                                 continue;
 817                                         }
 818
 819                                         if (b is DataBindingBuilder) {
 820                                                 AddDataBindingLiteral (builder, (DataBindingBuilder) b);
 821                                                 continue;
 822                                         }
 823
 824                                         if (b is ControlBuilder) {
 825                                                 ControlBuilder child = (ControlBuilder) b;
 826                                                 CreateControlTree (child, inTemplate, builder.ChildrenAsProperties);
 827                                                 AddChildCall (builder, child);
 828                                                 continue;
 829                                         }
 830
 831                                         throw new Exception ("???");
 832                                 }
 833
 834                                 FlushText (builder, sb);
 835
 836                                 if (templates != null) {
 837                                         foreach (TemplateBuilder b in templates) {
 838                                                 CreateControlTree (b, true, false);
 839 #if NET_2_0
 840                                                 if (b.BindingDirection == BindingDirection.TwoWay) {
 841                                                         string extractMethod = CreateExtractValuesMethod (b);
 842                                                         AddBindableTemplateInvocation (builder.method, b.TagName, b.method.Name, extractMethod);
 843                                                 }
 844                                                 else
 845 #endif
 846                                                 AddTemplateInvocation (builder.method, b.TagName, b.method.Name);
 847                                         }
 848                                 }
 849
 850                         }
 851
 852                         if (builder.defaultPropertyBuilder != null) {
 853                                 ControlBuilder b = builder.defaultPropertyBuilder;
 854                                 CreateControlTree (b, false, true);
 855                                 AddChildCall (builder, b);
 856                         }
 857
 858                         if (builder.HasAspCode) {
 859                                 CodeMethodReferenceExpression m = new CodeMethodReferenceExpression ();
 860                                 m.TargetObject = thisRef;
 861                                 m.MethodName = builder.renderMethod.Name;
 862
 863                                 CodeDelegateCreateExpression create = new CodeDelegateCreateExpression ();
 864                                 create.DelegateType = new CodeTypeReference (typeof (RenderMethod));
 865                                 create.TargetObject = thisRef;
 866                                 create.MethodName = builder.renderMethod.Name;
 867
 868                                 CodeMethodInvokeExpression invoke = new CodeMethodInvokeExpression ();
 869                                 invoke.Method = new CodeMethodReferenceExpression (ctrlVar, "SetRenderMethodDelegate");
 870                                 invoke.Parameters.Add (create);
 871
 872                                 builder.method.Statements.Add (invoke);
 873                         }
 874
 875                         if (!childrenAsProperties && typeof (Control).IsAssignableFrom (builder.ControlType))
 876                                 builder.method.Statements.Add (new CodeMethodReturnStatement (ctrlVar));
 877                 }
 878
 879                 protected override void CreateMethods ()
 880                 {
 881                         base.CreateMethods ();
 882
 883                         CreateProperties ();
 884                         CreateControlTree (parser.RootBuilder, false, false);
 885                         CreateFrameworkInitializeMethod ();
 886                 }
 887
 888                 void CreateFrameworkInitializeMethod ()
 889                 {
 890                         CodeMemberMethod method = new CodeMemberMethod ();
 891                         method.Name = "FrameworkInitialize";
 892                         method.Attributes = MemberAttributes.Family | MemberAttributes.Override;
 893                         AddStatementsToFrameworkInitialize (method);
 894                         mainClass.Members.Add (method);
 895                 }
 896
 897                 protected virtual void AddStatementsToFrameworkInitialize (CodeMemberMethod method)
 898                 {
 899                         if (!parser.EnableViewState) {
 900                                 CodeAssignStatement stmt = new CodeAssignStatement ();
 901                                 stmt.Left = new CodePropertyReferenceExpression (thisRef, "EnableViewState");
 902                                 stmt.Right = new CodePrimitiveExpression (false);
 903                                 method.Statements.Add (stmt);
 904                         }
 905
 906                         CodeMethodReferenceExpression methodExpr;
 907                         methodExpr = new CodeMethodReferenceExpression (thisRef, "__BuildControlTree");
 908                         CodeMethodInvokeExpression expr = new CodeMethodInvokeExpression (methodExpr, thisRef);
 909                         method.Statements.Add (new CodeExpressionStatement (expr));
 910                 }
 911
 912                 protected override void AddApplicationAndSessionObjects ()
 913                 {
 914                         foreach (ObjectTagBuilder tag in GlobalAsaxCompiler.ApplicationObjects) {
 915                                 CreateFieldForObject (tag.Type, tag.ObjectID);
 916                                 CreateApplicationOrSessionPropertyForObject (tag.Type, tag.ObjectID, true, false);
 917                         }
 918
 919                         foreach (ObjectTagBuilder tag in GlobalAsaxCompiler.SessionObjects) {
 920                                 CreateApplicationOrSessionPropertyForObject (tag.Type, tag.ObjectID, false, false);
 921                         }
 922                 }
 923
 924                 protected void ProcessObjectTag (ObjectTagBuilder tag)
 925                 {
 926                         string fieldName = CreateFieldForObject (tag.Type, tag.ObjectID);
 927                         CreatePropertyForObject (tag.Type, tag.ObjectID, fieldName, false);
 928                 }
 929
 930                 void CreateProperties ()
 931                 {
 932                         if (!parser.AutoEventWireup) {
 933                                 CreateAutoEventWireup ();
 934                         } else {
 935                                 CreateAutoHandlers ();
 936                         }
 937
 938                         CreateApplicationInstance ();
 939                         CreateTemplateSourceDirectory ();
 940                 }
 941
 942                 void CreateTemplateSourceDirectory ()
 943                 {
 944                         CodeMemberProperty prop = new CodeMemberProperty ();
 945                         prop.Type = new CodeTypeReference (typeof (string));
 946                         prop.Name = "TemplateSourceDirectory";
 947                         prop.Attributes = MemberAttributes.Public | MemberAttributes.Override;
 948
 949                         CodePrimitiveExpression expr = new CodePrimitiveExpression (parser.BaseVirtualDir);
 950                         prop.GetStatements.Add (new CodeMethodReturnStatement (expr));
 951                         mainClass.Members.Add (prop);
 952                 }
 953
 954                 void CreateApplicationInstance ()
 955                 {
 956                         CodeMemberProperty prop = new CodeMemberProperty ();
 957                         Type appType = typeof (HttpApplication);
 958                         prop.Type = new CodeTypeReference (appType);
 959                         prop.Name = "ApplicationInstance";
 960                         prop.Attributes = MemberAttributes.Family | MemberAttributes.Final;
 961
 962                         CodePropertyReferenceExpression propRef = new CodePropertyReferenceExpression (thisRef, "Context");
 963
 964                         propRef = new CodePropertyReferenceExpression (propRef, "ApplicationInstance");
 965
 966                         CodeCastExpression cast = new CodeCastExpression (appType.FullName, propRef);
 967                         prop.GetStatements.Add (new CodeMethodReturnStatement (cast));
 968                         mainClass.Members.Add (prop);
 969                 }
 970
 971                 void CreateAutoHandlers ()
 972                 {
 973                         // Create AutoHandlers property
 974                         CodeMemberProperty prop = new CodeMemberProperty ();
 975                         prop.Type = new CodeTypeReference (typeof (int));
 976                         prop.Name = "AutoHandlers";
 977                         prop.Attributes = MemberAttributes.Family | MemberAttributes.Override;
 978
 979                         CodeMethodReturnStatement ret = new CodeMethodReturnStatement ();
 980                         CodeFieldReferenceExpression fldRef ;
 981                         fldRef = new CodeFieldReferenceExpression (mainClassExpr, "__autoHandlers");
 982                         ret.Expression = fldRef;
 983                         prop.GetStatements.Add (ret);
 984
 985                         prop.SetStatements.Add (new CodeAssignStatement (fldRef, new CodePropertySetValueReferenceExpression ()));
 986
 987                         mainClass.Members.Add (prop);
 988
 989                         // Add the __autoHandlers field
 990                         CodeMemberField fld = new CodeMemberField (typeof (int), "__autoHandlers");
 991                         fld.Attributes = MemberAttributes.Private | MemberAttributes.Static;
 992                         mainClass.Members.Add (fld);
 993                 }
 994
 995                 void CreateAutoEventWireup ()
 996                 {
 997                         // The getter returns false
 998                         CodeMemberProperty prop = new CodeMemberProperty ();
 999                         prop.Type = new CodeTypeReference (typeof (bool));
1000                         prop.Name = "SupportAutoEvents";
1001                         prop.Attributes = MemberAttributes.Family | MemberAttributes.Override;
1002                         prop.GetStatements.Add (new CodeMethodReturnStatement (new CodePrimitiveExpression (false)));
1003                         mainClass.Members.Add (prop);
1004                 }
1005
1006                 CodeExpression GetExpressionFromString (Type type, string str, MemberInfo member)
1007                 {
1008                         if (type == typeof (string))
1009                                 return new CodePrimitiveExpression (str);
1010
1011                         if (type == typeof (bool)) {
1012                                 if (str == null || str == "" || 0 == String.Compare (str, "true", true))
1013                                         return new CodePrimitiveExpression (true);
1014                                 else if (0 == String.Compare (str, "false", true))
1015                                         return new CodePrimitiveExpression (false);
1016                                 else
1017                                         throw new ParseException (currentLocation,
1018                                                         "Value '" + str  + "' is not a valid boolean.");
1019                         }
1020
1021                         if (str == null)
1022                                 return new CodePrimitiveExpression (null);
1023
1024                         if (type.IsPrimitive)
1025                                 return new CodePrimitiveExpression (Convert.ChangeType (str, type, CultureInfo.InvariantCulture));
1026
1027                         if (type == typeof (string [])) {
1028                                 string [] subs = str.Split (',');
1029                                 CodeArrayCreateExpression expr = new CodeArrayCreateExpression ();
1030                                 expr.CreateType = new CodeTypeReference (typeof (string));
1031                                 foreach (string v in subs) {
1032                                         expr.Initializers.Add (new CodePrimitiveExpression (v.Trim ()));
1033                                 }
1034
1035                                 return expr;
1036                         }
1037
1038                         if (type == typeof (Color)){
1039                                 if (colorConverter == null)
1040                                         colorConverter = TypeDescriptor.GetConverter (typeof (Color));
1041
1042                                 if (str.Trim().Length == 0) {
1043                                         CodeTypeReferenceExpression ft = new CodeTypeReferenceExpression (typeof (Color));
1044                                         return new CodeFieldReferenceExpression (ft, "Empty");
1045                                 }
1046
1047                                 Color c;
1048                                 try {
1049                                         if (str.IndexOf (',') == -1) {
1050                                                 c = (Color) colorConverter.ConvertFromString (str);
1051                                         } else {
1052                                                 int [] argb = new int [4];
1053                                                 argb [0] = 255;
1054
1055                                                 string [] parts = str.Split (',');
1056                                                 int length = parts.Length;
1057                                                 if (length < 3)
1058                                                         throw new Exception ();
1059
1060                                                 int basei = (length == 4) ? 0 : 1;
1061                                                 for (int i = length - 1; i >= 0; i--) {
1062                                                         argb [basei + i] = (int) Byte.Parse (parts [i]);
1063                                                 }
1064                                                 c = Color.FromArgb (argb [0], argb [1], argb [2], argb [3]);
1065                                         }
1066                                 } catch (Exception e){
1067                                         throw new ParseException (currentLocation,
1068                                                         "Color " + str + " is not a valid color.", e);
1069                                 }
1070
1071                                 if (c.IsKnownColor){
1072                                         CodeFieldReferenceExpression expr = new CodeFieldReferenceExpression ();
1073                                         if (c.IsSystemColor)
1074                                                 type = typeof (SystemColors);
1075
1076                                         expr.TargetObject = new CodeTypeReferenceExpression (type);
1077                                         expr.FieldName = c.Name;
1078                                         return expr;
1079                                 } else {
1080                                         CodeMethodReferenceExpression m = new CodeMethodReferenceExpression ();
1081                                         m.TargetObject = new CodeTypeReferenceExpression (type);
1082                                         m.MethodName = "FromArgb";
1083                                         CodeMethodInvokeExpression invoke = new CodeMethodInvokeExpression (m);
1084                                         invoke.Parameters.Add (new CodePrimitiveExpression (c.A));
1085                                         invoke.Parameters.Add (new CodePrimitiveExpression (c.R));
1086                                         invoke.Parameters.Add (new CodePrimitiveExpression (c.G));
1087                                         invoke.Parameters.Add (new CodePrimitiveExpression (c.B));
1088                                         return invoke;
1089                                 }
1090                         }
1091
1092                         TypeConverter converter = TypeDescriptor.GetProperties (member.DeclaringType) [member.Name].Converter;
1093
1094                         if (converter != null && converter.CanConvertFrom (typeof (string))) {
1095                                 object value = converter.ConvertFrom (str);
1096
1097                                 if (converter.CanConvertTo (typeof (InstanceDescriptor))) {
1098                                         InstanceDescriptor idesc = (InstanceDescriptor) converter.ConvertTo (value, typeof(InstanceDescriptor));
1099                                         return GenerateInstance (idesc, true);
1100                                 }
1101
1102                                 CodeExpression exp = GenerateObjectInstance (value, false);
1103                                 if (exp != null) return exp;
1104
1105                                 CodeMethodReferenceExpression m = new CodeMethodReferenceExpression ();
1106                                 m.TargetObject = new CodeTypeReferenceExpression (typeof (TypeDescriptor));
1107                                 m.MethodName = "GetConverter";
1108                                 CodeMethodInvokeExpression invoke = new CodeMethodInvokeExpression (m);
1109                                 CodeTypeReference tref = new CodeTypeReference (type);
1110                                 invoke.Parameters.Add (new CodeTypeOfExpression (tref));
1111
1112                                 invoke = new CodeMethodInvokeExpression (invoke, "ConvertFrom");
1113                                 invoke.Parameters.Add (new CodePrimitiveExpression (str));
1114
1115                                 return new CodeCastExpression (tref, invoke);
1116                         }
1117
1118                         Console.WriteLine ("Unknown type: " + type + " value: " + str);
1119
1120                         return new CodePrimitiveExpression (str);
1121                 }
1122
1123                 CodeExpression GenerateInstance (InstanceDescriptor idesc, bool throwOnError)
1124                 {
1125                         CodeExpression[] parameters = new CodeExpression [idesc.Arguments.Count];
1126                         int n = 0;
1127                         foreach (object ob in idesc.Arguments) {
1128                                 CodeExpression exp = GenerateObjectInstance (ob, throwOnError);
1129                                 if (exp == null) return null;
1130                                 parameters [n++] = exp;
1131                         }
1132
1133                         switch (idesc.MemberInfo.MemberType) {
1134                         case MemberTypes.Constructor:
1135                                 CodeTypeReference tob = new CodeTypeReference (idesc.MemberInfo.DeclaringType);
1136                                 return new CodeObjectCreateExpression (tob, parameters);
1137
1138                         case MemberTypes.Method:
1139                                 CodeTypeReferenceExpression mt = new CodeTypeReferenceExpression (idesc.MemberInfo.DeclaringType);
1140                                 return new CodeMethodInvokeExpression (mt, idesc.MemberInfo.Name, parameters);
1141
1142                         case MemberTypes.Field:
1143                                 CodeTypeReferenceExpression ft = new CodeTypeReferenceExpression (idesc.MemberInfo.DeclaringType);
1144                                 return new CodeFieldReferenceExpression (ft, idesc.MemberInfo.Name);
1145
1146                         case MemberTypes.Property:
1147                                 CodeTypeReferenceExpression pt = new CodeTypeReferenceExpression (idesc.MemberInfo.DeclaringType);
1148                                 return new CodePropertyReferenceExpression (pt, idesc.MemberInfo.Name);
1149                         }
1150                         throw new ParseException (currentLocation, "Invalid instance type.");
1151                 }
1152
1153                 CodeExpression GenerateObjectInstance (object value, bool throwOnError)
1154                 {
1155                         if (value == null)
1156                                 return new CodePrimitiveExpression (null);
1157
1158                         Type t = value.GetType();
1159                         if (t.IsPrimitive || value is string)
1160                                 return new CodePrimitiveExpression (value);
1161
1162                         if (t.IsArray) {
1163                                 Array ar = (Array) value;
1164                                 CodeExpression[] items = new CodeExpression [ar.Length];
1165                                 for (int n=0; n<ar.Length; n++) {
1166                                         CodeExpression exp = GenerateObjectInstance (ar.GetValue (n), throwOnError);
1167                                         if (exp == null) return null;
1168                                         items [n] = exp;
1169                                 }
1170                                 return new CodeArrayCreateExpression (new CodeTypeReference (t), items);
1171                         }
1172
1173                         TypeConverter converter = TypeDescriptor.GetConverter (t);
1174                         if (converter != null && converter.CanConvertTo (typeof (InstanceDescriptor))) {
1175                                 InstanceDescriptor idesc = (InstanceDescriptor) converter.ConvertTo (value, typeof(InstanceDescriptor));
1176                                 return GenerateInstance (idesc, throwOnError);
1177                         }
1178
1179                         InstanceDescriptor desc = GetDefaultInstanceDescriptor (value);
1180                         if (desc != null) return GenerateInstance (desc, throwOnError);
1181
1182                         if (throwOnError)
1183                                 throw new ParseException (currentLocation, "Cannot generate an instance for the type: " + t);
1184                         else
1185                                 return null;
1186                 }
1187
1188                 InstanceDescriptor GetDefaultInstanceDescriptor (object value)
1189                 {
1190                         if (value is System.Web.UI.WebControls.Unit) {
1191                                 System.Web.UI.WebControls.Unit s = (System.Web.UI.WebControls.Unit) value;
1192                                 MethodInfo met = typeof(System.Web.UI.WebControls.Unit).GetMethod ("Parse", new Type[] {typeof(string)});
1193                                 return new InstanceDescriptor (met, new object[] {s.ToString ()});
1194                         }
1195
1196                         if (value is System.Web.UI.WebControls.FontUnit) {
1197                                 System.Web.UI.WebControls.FontUnit s = (System.Web.UI.WebControls.FontUnit) value;
1198                                 MethodInfo met = typeof(System.Web.UI.WebControls.FontUnit).GetMethod ("Parse", new Type[] {typeof(string)});
1199                                 return new InstanceDescriptor (met, new object[] {s.ToString ()});
1200                         }
1201                         return null;
1202                 }
1203         }
1204 }
1205