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