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