mcs/class/System.XML/System.Xml.Serialization/SerializationCodeGenerator.cs

   1 //
   2 // System.Xml.Serialization.SerializationCodeGenerator.cs:
   3 //
   4 // Author:
   5 //   Lluis Sanchez Gual (lluis@ximian.com)
   6 //
   7 // (C) 2002, 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
  31 using System.IO;
  32 using System.Reflection;
  33 using System.Xml.Serialization;
  34 using System.Collections;
  35 using System.Globalization;
  36
  37 namespace System.Xml.Serialization
  38 {
  39         internal class SerializationCodeGenerator
  40         {
  41                 XmlMapping _typeMap;
  42                 SerializationFormat _format;
  43                 TextWriter _writer;
  44                 int _tempVarId = 0;
  45                 int _indent = 0;
  46                 Hashtable _uniqueNames = new Hashtable();
  47                 int _methodId = 0;
  48                 SerializerInfo _config;
  49                 ArrayList _mapsToGenerate = new ArrayList ();
  50                 ArrayList _fixupCallbacks;
  51                 ArrayList _referencedTypes = new ArrayList ();
  52                 GenerationResult[] _results;
  53                 GenerationResult _result;
  54                 XmlMapping[] _xmlMaps;
  55
  56                 CodeIdentifiers classNames = new CodeIdentifiers ();
  57
  58                 public SerializationCodeGenerator (XmlMapping[] xmlMaps): this (xmlMaps, null)
  59                 {
  60                 }
  61
  62                 public SerializationCodeGenerator (XmlMapping[] xmlMaps, SerializerInfo config)
  63                 {
  64                         _xmlMaps = xmlMaps;
  65                         _config = config;
  66                 }
  67
  68                 public SerializationCodeGenerator (XmlMapping xmlMap, SerializerInfo config)
  69                 {
  70                         _xmlMaps = new XmlMapping [] {xmlMap};
  71                         _config = config;
  72                 }
  73
  74                 public static void Generate (string configFileName, string outputPath)
  75                 {
  76                         SerializationCodeGeneratorConfiguration cnf = null;
  77                         StreamReader sr = new StreamReader (configFileName);
  78                         try
  79                         {
  80                                 XmlReflectionImporter ri = new XmlReflectionImporter ();
  81                                 ri.AllowPrivateTypes = true;
  82                                 XmlSerializer ser = new XmlSerializer (ri.ImportTypeMapping (typeof (SerializationCodeGeneratorConfiguration)));
  83                                 cnf = (SerializationCodeGeneratorConfiguration) ser.Deserialize (sr);
  84                         }
  85                         finally
  86                         {
  87                                 sr.Close ();
  88                         }
  89
  90                         if (outputPath == null) outputPath = "";
  91
  92                         CodeIdentifiers ids = new CodeIdentifiers ();
  93                         if (cnf.Serializers != null)
  94                         {
  95                                 foreach (SerializerInfo info in cnf.Serializers)
  96                                 {
  97                                         Type type;
  98                                         if (info.Assembly != null)
  99                                         {
 100                                                 Assembly asm;
 101                                                 try {
 102                                                         asm = Assembly.Load (info.Assembly);
 103                                                 } catch {
 104                                                         asm = Assembly.LoadFrom (info.Assembly);
 105                                                 }
 106                                                 type = asm.GetType (info.ClassName, true);
 107                                         }
 108                                         else
 109                                                 type = Type.GetType (info.ClassName);
 110
 111                                         if (type == null) throw new InvalidOperationException ("Type " + info.ClassName + " not found");
 112
 113                                         string file = info.OutFileName;
 114                                         if (file == null || file == "") {
 115                                                 int i = info.ClassName.LastIndexOf (".");
 116                                                 if (i != -1) file = info.ClassName.Substring (i+1);
 117                                                 else file = info.ClassName;
 118                                                 file = ids.AddUnique (file, type) + "Serializer.cs";
 119                                         }
 120                                         StreamWriter writer = new StreamWriter (Path.Combine (outputPath, file));
 121
 122                                         try
 123                                         {
 124                                                 XmlTypeMapping map;
 125
 126                                                 if (info.SerializationFormat == SerializationFormat.Literal) {
 127                                                         XmlReflectionImporter ri = new XmlReflectionImporter ();
 128                                                         map = ri.ImportTypeMapping (type);
 129                                                 }
 130                                                 else {
 131                                                         SoapReflectionImporter ri = new SoapReflectionImporter ();
 132                                                         map = ri.ImportTypeMapping (type);
 133                                                 }
 134
 135                                                 SerializationCodeGenerator gen = new SerializationCodeGenerator (map, info);
 136                                                 gen.GenerateSerializers (writer);
 137                                         }
 138                                         finally
 139                                         {
 140                                                 writer.Close ();
 141                                         }
 142                                 }
 143                         }
 144                 }
 145
 146                 public void GenerateSerializers (TextWriter writer)
 147                 {
 148                         _writer = writer;
 149                         _results = new GenerationResult [_xmlMaps.Length];
 150
 151                         WriteLine ("using System;");
 152                         WriteLine ("using System.Xml;");
 153                         WriteLine ("using System.Xml.Schema;");
 154                         WriteLine ("using System.Xml.Serialization;");
 155                         WriteLine ("using System.Text;");
 156                         WriteLine ("using System.Collections;");
 157                         WriteLine ("using System.Globalization;");
 158                         if (_config != null && _config.NamespaceImports != null && _config.NamespaceImports.Length > 0) {
 159                                 foreach (string ns in _config.NamespaceImports)
 160                                         WriteLine ("using " + ns + ";");
 161                         }
 162                         WriteLine ("");
 163
 164                         string readerClassName = null;
 165                         string writerClassName = null;
 166                         string namspace = null;
 167
 168                         if (_config != null)
 169                         {
 170                                 readerClassName = _config.ReaderClassName;
 171                                 writerClassName = _config.WriterClassName;
 172                                 namspace = _config.Namespace;
 173                         }
 174
 175                         if (readerClassName == null || readerClassName == "")
 176                                 readerClassName = "GeneratedReader";
 177
 178                         if (writerClassName == null || writerClassName == "")
 179                                 writerClassName = "GeneratedWriter";
 180
 181                         readerClassName = GetUniqueClassName (readerClassName);
 182                         writerClassName = GetUniqueClassName (writerClassName);
 183
 184                         Hashtable mapsByNamespace = new Hashtable ();
 185                         Hashtable generatedMaps = new Hashtable ();
 186
 187                         for (int n=0; n<_xmlMaps.Length; n++)
 188                         {
 189                                 _typeMap = _xmlMaps [n];
 190                                 if (_typeMap == null) continue;
 191
 192                                 _result = generatedMaps [_typeMap] as GenerationResult;
 193                                 if (_result != null) {
 194                                         _results[n] = _result;
 195                                         continue;
 196                                 }
 197
 198                                 _result = new GenerationResult ();
 199                                 _results[n] = _result;
 200
 201                                 generatedMaps [_typeMap] = _result;
 202
 203                                 string typeName;
 204                                 if (_typeMap is XmlTypeMapping) typeName = ((XmlTypeMapping)_typeMap).TypeName;
 205                                 else typeName = ((XmlMembersMapping)_typeMap).ElementName;
 206
 207                                 _result.ReaderClassName = readerClassName;
 208                                 _result.WriterClassName = writerClassName;
 209
 210                                 if (namspace == null || namspace == "")
 211                                         _result.Namespace = "Mono.GeneratedSerializers." + _typeMap.Format;
 212                                 else
 213                                         _result.Namespace = namspace;
 214
 215                                 _result.WriteMethodName = GetUniqueName ("rwo", _typeMap, "WriteRoot_" + typeName);
 216                                 _result.ReadMethodName = GetUniqueName ("rro", _typeMap, "ReadRoot_" + typeName);
 217
 218                                 _result.Mapping = _typeMap;
 219
 220                                 ArrayList maps = (ArrayList) mapsByNamespace [_result.Namespace];
 221                                 if (maps == null) {
 222                                         maps = new ArrayList ();
 223                                         mapsByNamespace [_result.Namespace] = maps;
 224                                 }
 225                                 maps.Add (_result);
 226                         }
 227
 228                         foreach (DictionaryEntry entry in mapsByNamespace)
 229                         {
 230                                 ArrayList maps = (ArrayList) entry.Value;
 231
 232                                 WriteLine ("namespace " + entry.Key);
 233                                 WriteLineInd ("{");
 234
 235                                 GenerateReader (readerClassName, maps);
 236                                 WriteLine ("");
 237                                 GenerateWriter (writerClassName, maps);
 238                                 WriteLine ("");
 239
 240 #if NET_2_0
 241                                 GenerateContract (maps);
 242 #endif
 243
 244                                 WriteLineUni ("}");
 245                                 WriteLine ("");
 246                         }
 247                 }
 248
 249                 public GenerationResult[] GenerationResults
 250                 {
 251                         get { return _results; }
 252                 }
 253
 254                 public ArrayList ReferencedTypes
 255                 {
 256                         get { return _referencedTypes; }
 257                 }
 258
 259                 void UpdateGeneratedTypes (ArrayList list)
 260                 {
 261                         for (int n=0; n<list.Count; n++)
 262                         {
 263                                 XmlTypeMapping map = list[n] as XmlTypeMapping;
 264                                 if (map != null && !_referencedTypes.Contains (map.TypeData.Type))
 265                                         _referencedTypes.Add (map.TypeData.Type);
 266                         }
 267                 }
 268
 269                 #region Writer Generation
 270
 271                 //*******************************************************
 272                 // Contract generation
 273                 //
 274
 275 #if NET_2_0
 276                 public void GenerateContract (ArrayList generatedMaps)
 277                 {
 278                         // Write the base serializer
 279
 280                         if (generatedMaps.Count == 0) return;
 281
 282                         GenerationResult main = (GenerationResult) generatedMaps[0];
 283
 284                         string baseSerializerName = GetUniqueClassName ("BaseXmlSerializer");
 285
 286                         WriteLine ("");
 287                         WriteLine ("public class " + baseSerializerName + " : System.Xml.Serialization.XmlSerializer");
 288                         WriteLineInd ("{");
 289                         WriteLineInd ("protected override System.Xml.Serialization.XmlSerializationReader CreateReader () {");
 290                         WriteLine ("return new " + main.ReaderClassName + " ();");
 291                         WriteLineUni ("}");
 292                         WriteLine ("");
 293
 294                         WriteLineInd ("protected override System.Xml.Serialization.XmlSerializationWriter CreateWriter () {");
 295                         WriteLine ("return new " + main.WriterClassName + " ();");
 296                         WriteLineUni ("}");
 297                         WriteLine ("");
 298
 299                         WriteLineInd ("public override bool CanDeserialize (System.Xml.XmlReader xmlReader) {");
 300                         WriteLine ("return true;");
 301                         WriteLineUni ("}");
 302
 303                         WriteLineUni ("}");
 304                         WriteLine ("");
 305
 306                         // Write a serializer for each imported map
 307
 308                         foreach (GenerationResult res in generatedMaps)
 309                         {
 310                                 res.SerializerClassName = GetUniqueClassName (res.Mapping.ElementName + "Serializer");
 311
 312                                 WriteLine ("public sealed class " + res.SerializerClassName + " : " + baseSerializerName);
 313                                 WriteLineInd ("{");
 314                                 WriteLineInd ("protected override void Serialize (object obj, System.Xml.Serialization.XmlSerializationWriter writer) {");
 315                                 WriteLine ("((" + res.WriterClassName + ")writer)." + res.WriteMethodName + "(obj);");
 316                                 WriteLineUni ("}");
 317                                 WriteLine ("");
 318
 319                                 WriteLineInd ("protected override object Deserialize (System.Xml.Serialization.XmlSerializationReader reader) {");
 320                                 WriteLine ("return ((" + res.ReaderClassName + ")reader)." + res.ReadMethodName + "();");
 321                                 WriteLineUni ("}");
 322
 323                                 WriteLineUni ("}");
 324                                 WriteLine ("");
 325                         }
 326
 327                         WriteLine ("public class XmlSerializerContract : System.Xml.Serialization.IXmlSerializerImplementation");
 328                         WriteLineInd ("{");
 329
 330                         WriteLine ("System.Collections.Hashtable readMethods = null;");
 331                         WriteLine ("System.Collections.Hashtable writeMethods = null;");
 332                         WriteLine ("System.Collections.Hashtable typedSerializers = null;");
 333                         WriteLine ("");
 334
 335                         WriteLineInd ("public System.Xml.Serialization.XmlSerializationReader Reader {");
 336                         WriteLineInd ("get {");
 337                         WriteLine ("return new " + main.ReaderClassName + "();");
 338                         WriteLineUni ("}");
 339                         WriteLineUni ("}");
 340                         WriteLine ("");
 341
 342                         WriteLineInd ("public System.Xml.Serialization.XmlSerializationWriter Writer {");
 343                         WriteLineInd ("get {");
 344                         WriteLine ("return new " + main.WriterClassName + "();");
 345                         WriteLineUni ("}");
 346                         WriteLineUni ("}");
 347                         WriteLine ("");
 348
 349                         WriteLineInd ("public System.Collections.Hashtable ReadMethods {");
 350                         WriteLineInd ("get {");
 351                         WriteLineInd ("lock (System.Xml.Serialization.XmlSerializationGeneratedCode.InternalSyncObject) {");
 352                         WriteLineInd ("if (readMethods == null) {");
 353                         WriteLine ("readMethods = new System.Collections.Hashtable ();");
 354                         foreach (GenerationResult res in generatedMaps)
 355                                 WriteLine ("readMethods.Add (@\"" + res.Mapping.GetKey () + "\", @\"" + res.ReadMethodName + "\");");
 356                         WriteLineUni ("}");
 357                         WriteLine ("return readMethods;");
 358                         WriteLineUni ("}");
 359                         WriteLineUni ("}");
 360                         WriteLineUni ("}");
 361                         WriteLine ("");
 362
 363                         WriteLineInd ("public System.Collections.Hashtable WriteMethods {");
 364                         WriteLineInd ("get {");
 365                         WriteLineInd ("lock (System.Xml.Serialization.XmlSerializationGeneratedCode.InternalSyncObject) {");
 366                         WriteLineInd ("if (writeMethods == null) {");
 367                         WriteLine ("writeMethods = new System.Collections.Hashtable ();");
 368                         foreach (GenerationResult res in generatedMaps)
 369                                 WriteLine ("writeMethods.Add (@\"" + res.Mapping.GetKey () + "\", @\"" + res.WriteMethodName + "\");");
 370                         WriteLineUni ("}");
 371                         WriteLine ("return writeMethods;");
 372                         WriteLineUni ("}");
 373                         WriteLineUni ("}");
 374                         WriteLineUni ("}");
 375                         WriteLine ("");
 376
 377                         WriteLineInd ("public System.Collections.Hashtable TypedSerializers {");
 378                         WriteLineInd ("get {");
 379                         WriteLineInd ("lock (System.Xml.Serialization.XmlSerializationGeneratedCode.InternalSyncObject) {");
 380                         WriteLineInd ("if (typedSerializers == null) {");
 381                         WriteLine ("typedSerializers = new System.Collections.Hashtable ();");
 382                         foreach (GenerationResult res in generatedMaps)
 383                                 WriteLine ("typedSerializers.Add (@\"" + res.Mapping.GetKey () + "\", new " + res.SerializerClassName + "());");
 384                         WriteLineUni ("}");
 385                         WriteLine ("return typedSerializers;");
 386                         WriteLineUni ("}");
 387                         WriteLineUni ("}");
 388                         WriteLineUni ("}");
 389
 390                         WriteLineInd ("public bool CanSerialize (System.Type type) {");
 391                         foreach (GenerationResult res in generatedMaps) {
 392                                 if (res.Mapping is XmlTypeMapping)
 393                                         WriteLine ("if (type == typeof(" + (res.Mapping as XmlTypeMapping).TypeData.FullTypeName +  ")) return true;");
 394                         }
 395                         WriteLine ("return false;");
 396                         WriteLineUni ("}");
 397
 398                         WriteLineUni ("}");
 399                         WriteLine ("");
 400                 }
 401 #endif
 402
 403
 404                 //*******************************************************
 405                 // Writer generation
 406                 //
 407
 408                 public void GenerateWriter (string writerClassName, ArrayList maps)
 409                 {
 410                         _mapsToGenerate = new ArrayList ();
 411
 412                         InitHooks ();
 413
 414                         WriteLine ("public class " + writerClassName + " : XmlSerializationWriter");
 415                         WriteLineInd ("{");
 416
 417                         for (int n=0; n<maps.Count; n++)
 418                         {
 419                                 GenerationResult res = (GenerationResult) maps [n];
 420                                 _typeMap = res.Mapping;
 421                                 _format = _typeMap.Format;
 422                                 _result = res;
 423
 424                                 GenerateWriteRoot ();
 425                         }
 426
 427                         for (int n=0; n<_mapsToGenerate.Count; n++)
 428                         {
 429                                 XmlTypeMapping map = (XmlTypeMapping) _mapsToGenerate[n];
 430                                 GenerateWriteObject (map);
 431                                 if (map.TypeData.SchemaType == SchemaTypes.Enum)
 432                                         GenerateGetXmlEnumValue (map);
 433                         }
 434
 435                         GenerateWriteInitCallbacks ();
 436                         UpdateGeneratedTypes (_mapsToGenerate);
 437
 438                         WriteLineUni ("}");
 439                 }
 440
 441                 void GenerateWriteRoot ()
 442                 {
 443                         WriteLine ("public void " +_result.WriteMethodName + " (object o)");
 444                         WriteLineInd ("{");
 445                         WriteLine ("WriteStartDocument ();");
 446
 447                         if (_typeMap is XmlTypeMapping)
 448                         {
 449                                 WriteLine (GetRootTypeName () + " ob = (" + GetRootTypeName () + ") o;");
 450                                 XmlTypeMapping mp = (XmlTypeMapping) _typeMap;
 451                                 if (mp.TypeData.SchemaType == SchemaTypes.Class || mp.TypeData.SchemaType == SchemaTypes.Array)
 452                                         WriteLine ("TopLevelElement ();");
 453
 454                                 if (_format == SerializationFormat.Literal) {
 455                                         WriteLine (GetWriteObjectName (mp) + " (ob, " + GetLiteral(mp.ElementName) + ", " + GetLiteral(mp.Namespace) + ", true, false, true);");
 456                                 }
 457                                 else {
 458                                         RegisterReferencingMap (mp);
 459                                         WriteLine ("WritePotentiallyReferencingElement (" + GetLiteral(mp.ElementName) + ", " + GetLiteral(mp.Namespace) + ", ob, " + GetTypeOf(mp.TypeData) + ", true, false);");
 460                                 }
 461                         }
 462                         else if (_typeMap is XmlMembersMapping) {
 463                                 WriteLine ("object[] pars = (object[]) o;");
 464                                 GenerateWriteMessage ((XmlMembersMapping) _typeMap);
 465                         }
 466                         else
 467                                 throw new InvalidOperationException ("Unknown type map");
 468
 469                         if (_format == SerializationFormat.Encoded)
 470                                 WriteLine ("WriteReferencedElements ();");
 471
 472                         WriteLineUni ("}");
 473                         WriteLine ("");
 474                 }
 475
 476                 void GenerateWriteMessage (XmlMembersMapping membersMap)
 477                 {
 478                         if (membersMap.HasWrapperElement) {
 479                                 WriteLine ("TopLevelElement ();");
 480                                 WriteLine ("WriteStartElement (" + GetLiteral (membersMap.ElementName) + ", " + GetLiteral (membersMap.Namespace) + ", (" + GetLiteral(_format == SerializationFormat.Encoded) + "));");
 481
 482 /*                              WriteLineInd ("if (Writer.LookupPrefix (XmlSchema.Namespace) == null)");
 483                                 WriteLine ("WriteAttribute (\"xmlns\",\"xsd\",XmlSchema.Namespace,XmlSchema.Namespace);");
 484                                 Unindent ();
 485
 486                                 WriteLineInd ("if (Writer.LookupPrefix (XmlSchema.InstanceNamespace) == null)");
 487                                 WriteLine ("WriteAttribute (\"xmlns\",\"xsi\",XmlSchema.InstanceNamespace,XmlSchema.InstanceNamespace);");
 488                                 Unindent ();
 489 */
 490                         }
 491
 492                         GenerateWriteObjectElement (membersMap, "pars", true);
 493
 494                         if (membersMap.HasWrapperElement)
 495                                 WriteLine ("WriteEndElement();");
 496                 }
 497
 498                 void GenerateGetXmlEnumValue (XmlTypeMapping map)
 499                 {
 500                         EnumMap emap = (EnumMap) map.ObjectMap;
 501
 502                         WriteLine ("string " + GetGetEnumValueName (map) + " (" + map.TypeFullName + " val)");
 503                         WriteLineInd ("{");
 504
 505                         WriteLine ("switch (val)");
 506                         WriteLineInd ("{");
 507                         foreach (EnumMap.EnumMapMember mem in emap.Members)
 508                                 WriteLine ("case " + map.TypeFullName + "." + mem.EnumName + ": return " + GetLiteral (mem.XmlName) + ";");
 509
 510                         if (emap.IsFlags)
 511                         {
 512                                 WriteLineInd ("default:");
 513                                 WriteLine ("System.Text.StringBuilder sb = new System.Text.StringBuilder ();");
 514                                 WriteLine ("string[] enumNames = val.ToString().Split (',');");
 515                                 WriteLine ("foreach (string name in enumNames)");
 516                                 WriteLineInd ("{");
 517                                 WriteLine ("switch (name.Trim())");
 518                                 WriteLineInd ("{");
 519
 520                                 foreach (EnumMap.EnumMapMember mem in emap.Members)
 521                                         WriteLine ("case " + GetLiteral(mem.EnumName) + ": sb.Append (" + GetLiteral(mem.XmlName) + ").Append (' '); break; ");
 522
 523                                 WriteLine ("default: sb.Append (name.Trim()).Append (' '); break; ");
 524                                 WriteLineUni ("}");
 525                                 WriteLineUni ("}");
 526                                 WriteLine ("return sb.ToString ().Trim();");
 527                                 Unindent ();
 528                         }
 529                         else
 530                                 WriteLine ("default: return ((long)val).ToString(CultureInfo.InvariantCulture);");
 531
 532                         WriteLineUni ("}");
 533
 534                         WriteLineUni ("}");
 535                         WriteLine ("");
 536                 }
 537
 538                 void GenerateWriteObject (XmlTypeMapping typeMap)
 539                 {
 540                         WriteLine ("void " + GetWriteObjectName (typeMap) + " (" + typeMap.TypeFullName + " ob, string element, string namesp, bool isNullable, bool needType, bool writeWrappingElem)");
 541                         WriteLineInd ("{");
 542
 543                         PushHookContext ();
 544
 545                         SetHookVar ("$TYPE", typeMap.TypeName);
 546                         SetHookVar ("$FULLTYPE", typeMap.TypeFullName);
 547                         SetHookVar ("$OBJECT", "ob");
 548                         SetHookVar ("$ELEMENT", "element");
 549                         SetHookVar ("$NAMESPACE", "namesp");
 550                         SetHookVar ("$NULLABLE", "isNullable");
 551
 552                         if (GenerateWriteHook (HookType.type, typeMap.TypeData.Type))
 553                         {
 554                                 WriteLineUni ("}");
 555                                 WriteLine ("");
 556                                 PopHookContext ();
 557                                 return;
 558                         }
 559
 560                         if (!typeMap.TypeData.IsValueType)
 561                         {
 562                                 WriteLine ("if (ob == null)");
 563                                 WriteLineInd ("{");
 564                                 WriteLineInd ("if (isNullable)");
 565
 566                                 if (_format == SerializationFormat.Literal)
 567                                         WriteLine ("WriteNullTagLiteral(element, namesp);");
 568                                 else
 569                                         WriteLine ("WriteNullTagEncoded (element, namesp);");
 570
 571                                 WriteLineUni ("return;");
 572                                 WriteLineUni ("}");
 573                                 WriteLine ("");
 574                         }
 575
 576                         if (typeMap.TypeData.SchemaType == SchemaTypes.XmlNode)
 577                         {
 578                                 if (_format == SerializationFormat.Literal)
 579                                         WriteLine ("WriteElementLiteral (ob, \"\", \"\", true, false);");
 580                                 else
 581                                         WriteLine ("WriteElementEncoded (ob, \"\", \"\", true, false);");
 582
 583                                 GenerateEndHook ();
 584                                 WriteLineUni ("}");
 585                                 WriteLine ("");
 586                                 PopHookContext ();
 587                                 return;
 588                         }
 589
 590                         if (typeMap.TypeData.SchemaType == SchemaTypes.XmlSerializable)
 591                         {
 592                                 WriteLine ("WriteSerializable (ob, element, namesp, isNullable);");
 593
 594                                 GenerateEndHook ();
 595                                 WriteLineUni ("}");
 596                                 WriteLine ("");
 597                                 PopHookContext ();
 598                                 return;
 599                         }
 600
 601                         ArrayList types = typeMap.DerivedTypes;
 602
 603                         WriteLine ("System.Type type = ob.GetType ();");
 604                         WriteLine ("if (type == typeof(" + typeMap.TypeFullName + "))");
 605                         WriteLine ("\t;");
 606
 607                         for (int n=0; n<types.Count; n++)
 608                         {
 609                                 XmlTypeMapping map = (XmlTypeMapping)types[n];
 610
 611                                 WriteLineInd ("else if (type == typeof(" + map.TypeFullName + ")) { ");
 612                                 WriteLine (GetWriteObjectName (map) + "((" + map.TypeFullName + ")ob, element, namesp, isNullable, true, writeWrappingElem);");
 613                                 WriteLine ("return;");
 614                                 WriteLineUni ("}");
 615                         }
 616
 617                         if (typeMap.TypeData.Type == typeof (object)) {
 618                                 WriteLineInd ("else {");
 619                                 WriteLine ("WriteTypedPrimitive (element, namesp, ob, true);");
 620                                 WriteLine ("return;");
 621                                 WriteLineUni ("}");
 622                         }
 623                         else
 624                         {
 625                                 WriteLineInd ("else {");
 626                                 WriteLine ("throw CreateUnknownTypeException (ob);");
 627                                 WriteLineUni ("}");
 628                                 WriteLine ("");
 629
 630                                 WriteLineInd ("if (writeWrappingElem) {");
 631                                 if (_format == SerializationFormat.Encoded) WriteLine ("needType = true;");
 632                                 WriteLine ("WriteStartElement (element, namesp, ob);");
 633                                 WriteLineUni ("}");
 634                                 WriteLine ("");
 635
 636                                 WriteLine ("if (needType) WriteXsiType(" + GetLiteral(typeMap.XmlType) + ", " + GetLiteral(typeMap.XmlTypeNamespace) + ");");
 637                                 WriteLine ("");
 638
 639                                 switch (typeMap.TypeData.SchemaType)
 640                                 {
 641                                         case SchemaTypes.Class: GenerateWriteObjectElement (typeMap, "ob", false); break;
 642                                         case SchemaTypes.Array: GenerateWriteListElement (typeMap, "ob"); break;
 643                                         case SchemaTypes.Primitive: GenerateWritePrimitiveElement (typeMap, "ob"); break;
 644                                         case SchemaTypes.Enum: GenerateWriteEnumElement (typeMap, "ob"); break;
 645                                 }
 646
 647                                 WriteLine ("if (writeWrappingElem) WriteEndElement (ob);");
 648                         }
 649
 650                         GenerateEndHook ();
 651                         WriteLineUni ("}");
 652                         WriteLine ("");
 653                         PopHookContext ();
 654                 }
 655
 656                 void GenerateWriteObjectElement (XmlMapping xmlMap, string ob, bool isValueList)
 657                 {
 658                         XmlTypeMapping typeMap = xmlMap as XmlTypeMapping;
 659                         Type xmlMapType = (typeMap != null) ? typeMap.TypeData.Type : typeof(object[]);
 660
 661                         ClassMap map = (ClassMap)xmlMap.ObjectMap;
 662                         if (!GenerateWriteHook (HookType.attributes, xmlMapType))
 663                         {
 664                                 if (map.NamespaceDeclarations != null) {
 665                                         WriteLine ("WriteNamespaceDeclarations ((XmlSerializerNamespaces) " + ob + ".@" + map.NamespaceDeclarations.Name + ");");
 666                                         WriteLine ("");
 667                                 }
 668
 669                                 ICollection attributes = map.AttributeMembers;
 670                                 if (attributes != null)
 671                                 {
 672                                         foreach (XmlTypeMapMemberAttribute attr in attributes)
 673                                         {
 674                                                 if (GenerateWriteMemberHook (xmlMapType, attr)) continue;
 675
 676                                                 string val = GenerateGetMemberValue (attr, ob, isValueList);
 677                                                 string cond = GenerateMemberHasValueCondition (attr, ob, isValueList);
 678
 679                                                 if (cond != null) WriteLineInd ("if (" + cond + ") {");
 680
 681                                                 string strVal = GenerateGetStringValue (attr.MappedType, attr.TypeData, val);
 682                                                 WriteLine ("WriteAttribute (" + GetLiteral(attr.AttributeName) + ", " + GetLiteral(attr.Namespace) + ", " + strVal + ");");
 683
 684                                                 if (cond != null) WriteLineUni ("}");
 685                                                 GenerateEndHook ();
 686                                         }
 687                                         WriteLine ("");
 688                                 }
 689
 690                                 XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
 691                                 if (anyAttrMember != null)
 692                                 {
 693                                         if (!GenerateWriteMemberHook (xmlMapType, anyAttrMember))
 694                                         {
 695                                                 string cond = GenerateMemberHasValueCondition (anyAttrMember, ob, isValueList);
 696                                                 if (cond != null) WriteLineInd ("if (" + cond + ") {");
 697
 698                                                 string tmpVar = GetObTempVar ();
 699                                                 WriteLine ("ICollection " + tmpVar + " = " + GenerateGetMemberValue (anyAttrMember, ob, isValueList) + ";");
 700                                                 WriteLineInd ("if (" + tmpVar + " != null) {");
 701
 702                                                 string tmpVar2 = GetObTempVar ();
 703                                                 WriteLineInd ("foreach (XmlAttribute " + tmpVar2 + " in " + tmpVar + ")");
 704                                                 WriteLine ("WriteXmlAttribute (" + tmpVar2 + ", " + ob + ");");
 705                                                 Unindent ();
 706                                                 WriteLineUni ("}");
 707
 708                                                 if (cond != null) WriteLineUni ("}");
 709                                                 WriteLine ("");
 710                                                 GenerateEndHook ();
 711                                         }
 712                                 }
 713                                 GenerateEndHook ();
 714                         }
 715
 716                         if (!GenerateWriteHook (HookType.elements, xmlMapType))
 717                         {
 718                                 ICollection members = map.ElementMembers;
 719                                 if (members != null)
 720                                 {
 721                                         foreach (XmlTypeMapMemberElement member in members)
 722                                         {
 723                                                 if (GenerateWriteMemberHook (xmlMapType, member)) continue;
 724
 725                                                 string cond = GenerateMemberHasValueCondition (member, ob, isValueList);
 726                                                 if (cond != null) WriteLineInd ("if (" + cond + ") {");
 727
 728                                                 string memberValue = GenerateGetMemberValue (member, ob, isValueList);
 729                                                 Type memType = member.GetType();
 730
 731                                                 if (memType == typeof(XmlTypeMapMemberList))
 732                                                 {
 733                                                         GenerateWriteMemberElement ((XmlTypeMapElementInfo) member.ElementInfo[0], memberValue);
 734                                                 }
 735                                                 else if (memType == typeof(XmlTypeMapMemberFlatList))
 736                                                 {
 737                                                         WriteLineInd ("if (" + memberValue + " != null) {");
 738                                                         GenerateWriteListContent (member.TypeData, ((XmlTypeMapMemberFlatList)member).ListMap, memberValue, false);
 739                                                         WriteLineUni ("}");
 740                                                 }
 741                                                 else if (memType == typeof(XmlTypeMapMemberAnyElement))
 742                                                 {
 743                                                         WriteLineInd ("if (" + memberValue + " != null) {");
 744                                                         GenerateWriteAnyElementContent ((XmlTypeMapMemberAnyElement)member, memberValue);
 745                                                         WriteLineUni ("}");
 746                                                 }
 747                                                 else if (memType == typeof(XmlTypeMapMemberAnyElement))
 748                                                 {
 749                                                         WriteLineInd ("if (" + memberValue + " != null) {");
 750                                                         GenerateWriteAnyElementContent ((XmlTypeMapMemberAnyElement)member, memberValue);
 751                                                         WriteLineUni ("}");
 752                                                 }
 753                                                 else if (memType == typeof(XmlTypeMapMemberAnyAttribute))
 754                                                 {
 755                                                         // Ignore
 756                                                 }
 757                                                 else if (memType == typeof(XmlTypeMapMemberElement))
 758                                                 {
 759                                                         if (member.ElementInfo.Count == 1) {
 760                                                                 GenerateWriteMemberElement ((XmlTypeMapElementInfo)member.ElementInfo[0], memberValue);
 761                                                         }
 762                                                         else if (member.ChoiceMember != null)
 763                                                         {
 764                                                                 string choiceValue = ob + ".@" + member.ChoiceMember;
 765                                                                 foreach (XmlTypeMapElementInfo elem in member.ElementInfo) {
 766                                                                         WriteLineInd ("if (" + choiceValue + " == " + GetLiteral(elem.ChoiceValue) + ") {");
 767                                                                         GenerateWriteMemberElement (elem, GetCast(elem.TypeData, member.TypeData, memberValue));
 768                                                                         WriteLineUni ("}");
 769                                                                 }
 770                                                         }
 771                                                         else
 772                                                         {
 773         //                                                      WriteLineInd ("if (" + memberValue + " == null) {");
 774         //                                                      GenerateWriteMemberElement ((XmlTypeMapElementInfo)member.ElementInfo[0], memberValue);
 775         //                                                      WriteLineUni ("}");
 776
 777                                                                 bool first = true;
 778                                                                 foreach (XmlTypeMapElementInfo elem in member.ElementInfo)
 779                                                                 {
 780                                                                         WriteLineInd ((first?"":"else ") + "if (" + memberValue + " is " + elem.TypeData.FullTypeName + ") {");
 781                                                                         GenerateWriteMemberElement (elem, GetCast(elem.TypeData, member.TypeData, memberValue));
 782                                                                         WriteLineUni ("}");
 783                                                                         first = false;
 784                                                                 }
 785                                                         }
 786                                                 }
 787                                                 else
 788                                                         throw new InvalidOperationException ("Unknown member type");
 789
 790                                                 if (cond != null)
 791                                                         WriteLineUni ("}");
 792
 793                                                 GenerateEndHook ();
 794                                         }
 795                                 }
 796                                 GenerateEndHook ();
 797                         }
 798                 }
 799
 800                 void GenerateWriteMemberElement (XmlTypeMapElementInfo elem, string memberValue)
 801                 {
 802                         switch (elem.TypeData.SchemaType)
 803                         {
 804                                 case SchemaTypes.XmlNode:
 805                                         string elemName = elem.WrappedElement ? elem.ElementName : "";
 806                                         if (_format == SerializationFormat.Literal)
 807                                                 WriteMetCall ("WriteElementLiteral", memberValue, GetLiteral(elemName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false");
 808                                         else
 809                                                 WriteMetCall ("WriteElementEncoded", memberValue, GetLiteral(elemName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false");
 810                                         break;
 811
 812                                 case SchemaTypes.Enum:
 813                                 case SchemaTypes.Primitive:
 814                                         if (_format == SerializationFormat.Literal)
 815                                                 GenerateWritePrimitiveValueLiteral (memberValue, elem.ElementName, elem.Namespace, elem.MappedType, elem.TypeData, elem.WrappedElement, elem.IsNullable);
 816                                         else
 817                                                 GenerateWritePrimitiveValueEncoded (memberValue, elem.ElementName, elem.Namespace, new XmlQualifiedName (elem.TypeData.XmlType, elem.DataTypeNamespace), elem.MappedType, elem.TypeData, elem.WrappedElement, elem.IsNullable);
 818                                         break;
 819
 820                                 case SchemaTypes.Array:
 821                                         WriteLineInd ("if (" + memberValue + " != null) {");
 822
 823                                         if (elem.MappedType.MultiReferenceType) {
 824                                                 WriteMetCall ("WriteReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, GetLiteral(elem.IsNullable));
 825                                                 RegisterReferencingMap (elem.MappedType);
 826                                         }
 827                                         else {
 828                                                 WriteMetCall ("WriteStartElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue);
 829                                                 GenerateWriteListContent (elem.TypeData, (ListMap) elem.MappedType.ObjectMap, memberValue, false);
 830                                                 WriteMetCall ("WriteEndElement", memberValue);
 831                                         }
 832                                         WriteLineUni ("}");
 833
 834                                         if (elem.IsNullable) {
 835                                                 WriteLineInd ("else");
 836                                                 if (_format == SerializationFormat.Literal)
 837                                                         WriteMetCall ("WriteNullTagLiteral", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace));
 838                                                 else
 839                                                         WriteMetCall ("WriteNullTagEncoded", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace));
 840                                                 Unindent ();
 841                                         }
 842
 843                                         break;
 844
 845                                 case SchemaTypes.Class:
 846                                         if (elem.MappedType.MultiReferenceType) {
 847                                                 RegisterReferencingMap (elem.MappedType);
 848                                                 if (elem.MappedType.TypeData.Type == typeof(object))
 849                                                         WriteMetCall ("WritePotentiallyReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, "null", "false", GetLiteral(elem.IsNullable));
 850                                                 else
 851                                                         WriteMetCall ("WriteReferencingElement", GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), memberValue, GetLiteral(elem.IsNullable));
 852                                         }
 853                                         else
 854                                                 WriteMetCall (GetWriteObjectName(elem.MappedType), memberValue, GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable), "false", "true");
 855                                         break;
 856
 857                                 case SchemaTypes.XmlSerializable:
 858                                         WriteMetCall ("WriteSerializable", memberValue, GetLiteral(elem.ElementName), GetLiteral(elem.Namespace), GetLiteral(elem.IsNullable));
 859                                         break;
 860
 861                                 default:
 862                                         throw new NotSupportedException ("Invalid value type");
 863                         }
 864                 }
 865
 866                 void GenerateWriteListElement (XmlTypeMapping typeMap, string ob)
 867                 {
 868                         if (_format == SerializationFormat.Encoded)
 869                         {
 870                                 string n, ns;
 871                                 string itemCount = GenerateGetListCount (typeMap.TypeData, ob);
 872                                 GenerateGetArrayType ((ListMap) typeMap.ObjectMap, itemCount, out n, out ns);
 873
 874                                 string arrayType;
 875                                 if (ns != string.Empty)
 876                                         arrayType = "FromXmlQualifiedName (new XmlQualifiedName(" + n + "," + ns + "))";
 877                                 else
 878                                         arrayType = GetLiteral (n);
 879
 880                                 WriteMetCall ("WriteAttribute", GetLiteral("arrayType"), GetLiteral(XmlSerializer.EncodingNamespace), arrayType);
 881                         }
 882                         GenerateWriteListContent (typeMap.TypeData, (ListMap) typeMap.ObjectMap, ob, false);
 883                 }
 884
 885                 void GenerateWriteAnyElementContent (XmlTypeMapMemberAnyElement member, string memberValue)
 886                 {
 887                         bool singleElement = (member.TypeData.Type == typeof (XmlElement));
 888                         string var;
 889
 890                         if (singleElement)
 891                                 var = memberValue;
 892                         else {
 893                                 var = GetObTempVar ();
 894                                 WriteLineInd ("foreach (XmlNode " + var + " in " + memberValue + ") {");
 895                         }
 896
 897                         string elem = GetObTempVar ();
 898                         WriteLine ("XmlElement " + elem + " = " + var + " as XmlElement;");
 899                         WriteLine ("if (" + elem + " == null) throw CreateUnknownTypeException (" + elem + ");");
 900
 901                         if (!member.IsDefaultAny) {
 902                                 for (int n=0; n<member.ElementInfo.Count; n++) {
 903                                         XmlTypeMapElementInfo info = (XmlTypeMapElementInfo)member.ElementInfo[n];
 904                                         string txt = "(" + elem + ".Name == " + GetLiteral(info.ElementName) + " && " + elem + ".NamespaceURI == " + GetLiteral(info.Namespace) + ")";
 905                                         if (n == member.ElementInfo.Count-1) txt += ") {";
 906                                         if (n == 0) WriteLineInd ("if (" + txt);
 907                                         else WriteLine ("|| " + txt);
 908                                 }
 909                         }
 910
 911                         if (_format == SerializationFormat.Literal)
 912                                 WriteLine ("WriteElementLiteral (" + elem + ", \"\", \"\", false, true);");
 913                         else
 914                                 WriteLine ("WriteElementEncoded (" + elem + ", \"\", \"\", false, true);");
 915
 916                         if (!member.IsDefaultAny) {
 917                                 WriteLineUni ("}");
 918                                 WriteLineInd ("else");
 919                                 WriteLine ("throw CreateUnknownAnyElementException (" + elem + ".Name, " + elem + ".NamespaceURI);");
 920                                 Unindent ();
 921                         }
 922
 923                         if (!singleElement)
 924                                 WriteLineUni ("}");
 925                 }
 926
 927                 void GenerateWritePrimitiveElement (XmlTypeMapping typeMap, string ob)
 928                 {
 929                         string strVal = GenerateGetStringValue (typeMap, typeMap.TypeData, ob);
 930                         WriteLine ("Writer.WriteString (" + strVal + ");");
 931                 }
 932
 933                 void GenerateWriteEnumElement (XmlTypeMapping typeMap, string ob)
 934                 {
 935                         string strVal = GenerateGetEnumXmlValue (typeMap, ob);
 936                         WriteLine ("Writer.WriteString (" + strVal + ");");
 937                 }
 938
 939                 string GenerateGetStringValue (XmlTypeMapping typeMap, TypeData type, string value)
 940                 {
 941                         if (type.SchemaType == SchemaTypes.Array) {
 942                                 string str = GetStrTempVar ();
 943                                 WriteLine ("string " + str + " = null;");
 944                                 WriteLineInd ("if (" + value + " != null) {");
 945                                 string res = GenerateWriteListContent (typeMap.TypeData, (ListMap)typeMap.ObjectMap, value, true);
 946                                 WriteLine (str + " = " + res + ".ToString ().Trim ();");
 947                                 WriteLineUni ("}");
 948                                 return str;
 949                         }
 950                         else if (type.SchemaType == SchemaTypes.Enum) {
 951                                 return GenerateGetEnumXmlValue (typeMap, value);
 952                         }
 953                         else if (type.Type == typeof (XmlQualifiedName))
 954                                 return "FromXmlQualifiedName (" + value + ")";
 955                         else if (value == null)
 956                                 return null;
 957                         else
 958                                 return XmlCustomFormatter.GenerateToXmlString (type, value);
 959                 }
 960
 961                 string GenerateGetEnumXmlValue (XmlTypeMapping typeMap, string ob)
 962                 {
 963                         return GetGetEnumValueName (typeMap) + " (" + ob + ")";
 964                 }
 965
 966                 string GenerateGetListCount (TypeData listType, string ob)
 967                 {
 968                         if (listType.Type.IsArray)
 969                                 return "ob.Length";
 970                         else
 971                                 return "ob.Count";
 972                 }
 973
 974                 void GenerateGetArrayType (ListMap map, string itemCount, out string localName, out string ns)
 975                 {
 976                         string arrayDim;
 977                         if (itemCount != "") arrayDim = "";
 978                         else arrayDim = "[]";
 979
 980                         XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) map.ItemInfo[0];
 981                         if (info.TypeData.SchemaType == SchemaTypes.Array)
 982                         {
 983                                 string nm;
 984                                 GenerateGetArrayType ((ListMap)info.MappedType.ObjectMap, "", out nm, out ns);
 985                                 localName = nm + arrayDim;
 986                         }
 987                         else
 988                         {
 989                                 if (info.MappedType != null)
 990                                 {
 991                                         localName = info.MappedType.XmlType + arrayDim;
 992                                         ns = info.MappedType.Namespace;
 993                                 }
 994                                 else
 995                                 {
 996                                         localName = info.TypeData.XmlType + arrayDim;
 997                                         ns = info.DataTypeNamespace;
 998                                 }
 999                         }
1000                         if (itemCount != "") {
1001                                 localName = "\"" + localName + "[\" + " + itemCount + " + \"]\"";
1002                                 ns = GetLiteral (ns);
1003                         }
1004                 }
1005
1006                 string GenerateWriteListContent (TypeData listType, ListMap map, string ob, bool writeToString)
1007                 {
1008                         string targetString = null;
1009
1010                         if (writeToString)
1011                         {
1012                                 targetString = GetStrTempVar ();
1013                                 WriteLine ("System.Text.StringBuilder " + targetString + " = new System.Text.StringBuilder();");
1014                         }
1015
1016                         if (listType.Type.IsArray)
1017                         {
1018                                 string itemVar = GetNumTempVar ();
1019                                 WriteLineInd ("for (int "+itemVar+" = 0; "+itemVar+" < " + ob + ".Length; "+itemVar+"++) {");
1020                                 GenerateListLoop (map, ob + "["+itemVar+"]", listType.ListItemTypeData, targetString);
1021                                 WriteLineUni ("}");
1022                         }
1023                         else if (typeof(ICollection).IsAssignableFrom (listType.Type))
1024                         {
1025                                 string itemVar = GetNumTempVar ();
1026                                 WriteLineInd ("for (int "+itemVar+" = 0; "+itemVar+" < " + ob + ".Count; "+itemVar+"++) {");
1027                                 GenerateListLoop (map, ob + "["+itemVar+"]", listType.ListItemTypeData, targetString);
1028                                 WriteLineUni ("}");
1029                         }
1030                         else if (typeof(IEnumerable).IsAssignableFrom (listType.Type))
1031                         {
1032                                 string itemVar = GetObTempVar ();
1033                                 WriteLineInd ("foreach (" + listType.ListItemTypeData.FullTypeName + " " + itemVar + " in " + ob + ") {");
1034                                 GenerateListLoop (map, itemVar, listType.ListItemTypeData, targetString);
1035                                 WriteLineUni ("}");
1036                         }
1037                         else
1038                                 throw new Exception ("Unsupported collection type");
1039
1040                         return targetString;
1041                 }
1042
1043                 void GenerateListLoop (ListMap map, string item, TypeData itemTypeData, string targetString)
1044                 {
1045                         bool multichoice = (map.ItemInfo.Count > 1);
1046
1047                         if (multichoice)
1048                                 WriteLine ("if (" + item + " == null) { }");
1049
1050                         foreach (XmlTypeMapElementInfo info in map.ItemInfo)
1051                         {
1052                                 if (multichoice)
1053                                         WriteLineInd ("else if (" + item + ".GetType() == typeof(" + info.TypeData.FullTypeName + ")) {");
1054
1055                                 if (targetString == null)
1056                                         GenerateWriteMemberElement (info, GetCast (info.TypeData, itemTypeData, item));
1057                                 else
1058                                 {
1059                                         string strVal = GenerateGetStringValue (info.MappedType, info.TypeData, GetCast (info.TypeData, itemTypeData, item));
1060                                         WriteLine (targetString + ".Append (" + strVal + ").Append (\" \");");
1061                                 }
1062
1063                                 if (multichoice)
1064                                         WriteLineUni ("}");
1065                         }
1066
1067                         if (multichoice)
1068                                 WriteLine ("else throw CreateUnknownTypeException (" + item + ");");
1069                 }
1070
1071                 void GenerateWritePrimitiveValueLiteral (string memberValue, string name, string ns, XmlTypeMapping mappedType, TypeData typeData, bool wrapped, bool isNullable)
1072                 {
1073                         if (!wrapped) {
1074                                 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1075                                 WriteMetCall ("WriteValue", strVal);
1076                         }
1077                         else if (isNullable) {
1078                                 if (typeData.Type == typeof(XmlQualifiedName))
1079                                         WriteMetCall ("WriteNullableQualifiedNameLiteral", GetLiteral(name), GetLiteral(ns), memberValue);
1080                                 else  {
1081                                         string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1082                                         WriteMetCall ("WriteNullableStringLiteral", GetLiteral(name), GetLiteral(ns), strVal);
1083                                 }
1084                         }
1085                         else {
1086                                 if (typeData.Type == typeof(XmlQualifiedName))
1087                                         WriteMetCall ("WriteElementQualifiedName", GetLiteral(name), GetLiteral(ns), memberValue);
1088                                 else {
1089                                         string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1090                                         WriteMetCall ("WriteElementString", GetLiteral(name),GetLiteral(ns), strVal);
1091                                 }
1092                         }
1093                 }
1094
1095                 void GenerateWritePrimitiveValueEncoded (string memberValue, string name, string ns, XmlQualifiedName xsiType, XmlTypeMapping mappedType, TypeData typeData, bool wrapped, bool isNullable)
1096                 {
1097                         if (!wrapped) {
1098                                 string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1099                                 WriteMetCall ("WriteValue", strVal);
1100                         }
1101                         else if (isNullable) {
1102                                 if (typeData.Type == typeof(XmlQualifiedName))
1103                                         WriteMetCall ("WriteNullableQualifiedNameEncoded", GetLiteral(name), GetLiteral(ns), memberValue, GetLiteral(xsiType));
1104                                 else  {
1105                                         string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1106                                         WriteMetCall ("WriteNullableStringEncoded", GetLiteral(name), GetLiteral(ns), strVal, GetLiteral(xsiType));
1107                                 }
1108                         }
1109                         else {
1110                                 if (typeData.Type == typeof(XmlQualifiedName))
1111                                         WriteMetCall ("WriteElementQualifiedName", GetLiteral(name), GetLiteral(ns), memberValue, GetLiteral(xsiType));
1112                                 else {
1113                                         string strVal = GenerateGetStringValue (mappedType, typeData, memberValue);
1114                                         WriteMetCall ("WriteElementString", GetLiteral(name),GetLiteral(ns), strVal, GetLiteral(xsiType));
1115                                 }
1116                         }
1117                 }
1118
1119                 string GenerateGetMemberValue (XmlTypeMapMember member, string ob, bool isValueList)
1120                 {
1121                         if (isValueList) return GetCast (member.TypeData, TypeTranslator.GetTypeData (typeof(object)), ob + "[" + member.Index + "]");
1122                         else return ob + ".@" + member.Name;
1123                 }
1124
1125                 string GenerateMemberHasValueCondition (XmlTypeMapMember member, string ob, bool isValueList)
1126                 {
1127                         if (isValueList) {
1128                                 return ob + ".Length > " + member.Index;
1129                         }
1130                         else if (member.DefaultValue != System.DBNull.Value) {
1131                                 string mem = ob + ".@" + member.Name;
1132                                 if (member.DefaultValue == null)
1133                                         return mem + " != null";
1134                                 else if (member.TypeData.SchemaType == SchemaTypes.Enum)
1135                                         return mem + " != " + GetCast (member.TypeData, GetLiteral (member.DefaultValue));
1136                                 else
1137                                         return mem + " != " + GetLiteral (member.DefaultValue);
1138                         }
1139                         else if (member.IsOptionalValueType)
1140                                 return ob + ".@" + member.Name + "Specified";
1141                         return null;
1142                 }
1143
1144                 void GenerateWriteInitCallbacks ()
1145                 {
1146                         WriteLine ("protected override void InitCallbacks ()");
1147                         WriteLineInd ("{");
1148
1149                         if (_format == SerializationFormat.Encoded)
1150                         {
1151                                 foreach (XmlMapping xmap in _mapsToGenerate)  {
1152                                         XmlTypeMapping map = xmap as XmlTypeMapping;
1153                                         if (map != null)
1154                                                 WriteMetCall ("AddWriteCallback", GetTypeOf(map.TypeData), GetLiteral(map.XmlType), GetLiteral(map.Namespace), "new XmlSerializationWriteCallback (" + GetWriteObjectCallbackName (map) + ")");
1155                                 }
1156                         }
1157
1158                         WriteLineUni ("}");
1159                         WriteLine ("");
1160
1161                         if (_format == SerializationFormat.Encoded)
1162                         {
1163                                 foreach (XmlTypeMapping xmap in _mapsToGenerate)  {
1164                                         XmlTypeMapping map = xmap as XmlTypeMapping;
1165                                         if (map == null) continue;
1166                                         if (map.TypeData.SchemaType == SchemaTypes.Enum)
1167                                                 WriteWriteEnumCallback (map);
1168                                         else
1169                                                 WriteWriteObjectCallback (map);
1170                                 }
1171                         }
1172                 }
1173
1174                 void WriteWriteEnumCallback (XmlTypeMapping map)
1175                 {
1176                         WriteLine ("void " + GetWriteObjectCallbackName (map) + " (object ob)");
1177                         WriteLineInd ("{");
1178                         WriteMetCall (GetWriteObjectName(map), GetCast (map.TypeData, "ob"), GetLiteral(map.ElementName), GetLiteral(map.Namespace), "false", "true", "false");
1179                         WriteLineUni ("}");
1180                         WriteLine ("");
1181                 }
1182
1183                 void WriteWriteObjectCallback (XmlTypeMapping map)
1184                 {
1185                         WriteLine ("void " + GetWriteObjectCallbackName (map) + " (object ob)");
1186                         WriteLineInd ("{");
1187                         WriteMetCall (GetWriteObjectName(map), GetCast (map.TypeData, "ob"), GetLiteral(map.ElementName), GetLiteral(map.Namespace), "false", "false", "false");
1188                         WriteLineUni ("}");
1189                         WriteLine ("");
1190                 }
1191
1192                 #endregion
1193
1194                 #region Reader Generation
1195
1196                 //*******************************************************
1197                 // Reader generation
1198                 //
1199
1200                 public void GenerateReader (string readerClassName, ArrayList maps)
1201                 {
1202                         WriteLine ("public class " + readerClassName + " : XmlSerializationReader");
1203                         WriteLineInd ("{");
1204
1205                         _mapsToGenerate = new ArrayList ();
1206                         _fixupCallbacks = new ArrayList ();
1207                         InitHooks ();
1208
1209                         for (int n=0; n<maps.Count; n++)
1210                         {
1211                                 GenerationResult res = (GenerationResult) maps [n];
1212                                 _typeMap = res.Mapping;
1213                                 _format = _typeMap.Format;
1214                                 _result = res;
1215
1216                                 GenerateReadRoot ();
1217                         }
1218
1219                         for (int n=0; n<_mapsToGenerate.Count; n++)
1220                         {
1221                                 XmlTypeMapping map = _mapsToGenerate [n] as XmlTypeMapping;
1222                                 if (map == null) continue;
1223
1224                                 GenerateReadObject (map);
1225                                 if (map.TypeData.SchemaType == SchemaTypes.Enum)
1226                                         GenerateGetEnumValue (map);
1227                         }
1228
1229                         GenerateReadInitCallbacks ();
1230
1231                         if (_format == SerializationFormat.Encoded)
1232                         {
1233                                 GenerateFixupCallbacks ();
1234                                 GenerateFillerCallbacks ();
1235                         }
1236
1237                         WriteLineUni ("}");
1238                         UpdateGeneratedTypes (_mapsToGenerate);
1239                 }
1240
1241                 void GenerateReadRoot ()
1242                 {
1243                         WriteLine ("public object " + _result.ReadMethodName + " ()");
1244                         WriteLineInd ("{");
1245                         WriteLine ("Reader.MoveToContent();");
1246
1247                         if (_typeMap is XmlTypeMapping)
1248                         {
1249                                 XmlTypeMapping typeMap = (XmlTypeMapping) _typeMap;
1250 //                              Console.WriteLine ("> " + typeMap.TypeName);
1251
1252                                 if (_format == SerializationFormat.Literal)
1253                                 {
1254                                         if (typeMap.TypeData.SchemaType == SchemaTypes.XmlNode)
1255                                                 throw new Exception ("Not supported for XmlNode types");
1256
1257 //                                      Console.WriteLine ("This should be string:" + typeMap.ElementName.GetType());
1258                                         WriteLineInd ("if (Reader.LocalName != " + GetLiteral (typeMap.ElementName) + " || Reader.NamespaceURI != " + GetLiteral (typeMap.Namespace) + ")");
1259                                         WriteLine ("throw CreateUnknownNodeException();");
1260                                         Unindent ();
1261
1262                                         WriteLine ("return " + GetReadObjectCall (typeMap, "true", "true") + ";");
1263                                 }
1264                                 else
1265                                 {
1266                                         WriteLine ("object ob = null;");
1267                                         WriteLine ("Reader.MoveToContent();");
1268                                         WriteLine ("if (Reader.NodeType == System.Xml.XmlNodeType.Element) ");
1269                                         WriteLineInd ("{");
1270                                         WriteLineInd ("if (Reader.LocalName == " + GetLiteral(typeMap.ElementName) + " && Reader.NamespaceURI == " + GetLiteral (typeMap.Namespace) + ")");
1271                                         WriteLine ("ob = ReadReferencedElement();");
1272                                         Unindent ();
1273                                         WriteLineInd ("else ");
1274                                         WriteLine ("throw CreateUnknownNodeException();");
1275                                         Unindent ();
1276                                         WriteLineUni ("}");
1277                                         WriteLineInd ("else ");
1278                                         WriteLine ("UnknownNode(null);");
1279                                         Unindent ();
1280                                         WriteLine ("");
1281                                         WriteLine ("ReadReferencedElements();");
1282                                         WriteLine ("return ob;");
1283                                         RegisterReferencingMap (typeMap);
1284                                 }
1285                         }
1286                         else {
1287                                 WriteLine ("return " + GenerateReadMessage ((XmlMembersMapping)_typeMap) + ";");
1288                         }
1289
1290                         WriteLineUni ("}");
1291                         WriteLine ("");
1292                 }
1293
1294                 string GenerateReadMessage (XmlMembersMapping typeMap)
1295                 {
1296                         WriteLine ("object[] parameters = new object[" + typeMap.Count + "];");
1297                         WriteLine ("");
1298
1299                         if (typeMap.HasWrapperElement)
1300                         {
1301                                 if (_format == SerializationFormat.Encoded)
1302                                 {
1303                                         WriteLine ("while (Reader.NodeType == System.Xml.XmlNodeType.Element)");
1304                                         WriteLineInd ("{");
1305                                         WriteLine ("string root = Reader.GetAttribute (\"root\", " + GetLiteral(XmlSerializer.EncodingNamespace) + ");");
1306                                         WriteLine ("if (root == null || System.Xml.XmlConvert.ToBoolean(root)) break;");
1307                                         WriteLine ("ReadReferencedElement ();");
1308                                         WriteLine ("Reader.MoveToContent ();");
1309                                         WriteLineUni ("}");
1310                                         WriteLine ("");
1311                                         WriteLine ("if (Reader.NodeType != System.Xml.XmlNodeType.EndElement)");
1312                                         WriteLineInd ("{");
1313                                         WriteLineInd ("if (Reader.IsEmptyElement) {");
1314                                         WriteLine ("Reader.Skip();");
1315                                         WriteLineUni ("}");
1316                                         WriteLineInd ("else {");
1317                                         WriteLine ("Reader.ReadStartElement();");
1318                                         GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "parameters", true, false);
1319                                         WriteLine ("ReadEndElement();");
1320                                         WriteLineUni ("}");
1321                                         WriteLine ("");
1322                                         WriteLine ("Reader.MoveToContent();");
1323                                         WriteLineUni ("}");
1324                                 }
1325                                 else
1326                                 {
1327                                         WriteLine ("while (Reader.NodeType != System.Xml.XmlNodeType.EndElement)");
1328                                         WriteLineInd ("{");
1329                                         WriteLine ("if (Reader.IsStartElement(" + GetLiteral(typeMap.ElementName) + ", " + GetLiteral(typeMap.Namespace) + "))");
1330                                         WriteLineInd ("{");
1331                                         WriteLine ("if (Reader.IsEmptyElement) { Reader.Skip(); Reader.MoveToContent(); continue; }");
1332                                         WriteLine ("Reader.ReadStartElement();");
1333                                         GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "parameters", true, false);
1334                                         WriteLine ("ReadEndElement();");
1335                                         WriteLine ("break;");
1336                                         WriteLineUni ("}");
1337                                         WriteLineInd ("else ");
1338                                         WriteLine ("UnknownNode(null);");
1339                                         Unindent ();
1340                                         WriteLine ("");
1341                                         WriteLine ("Reader.MoveToContent();");
1342                                         WriteLineUni ("}");
1343                                 }
1344                         }
1345                         else
1346                                 GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "parameters", true, _format == SerializationFormat.Encoded);
1347
1348                         if (_format == SerializationFormat.Encoded)
1349                                 WriteLine ("ReadReferencedElements();");
1350
1351                         return "parameters";
1352                 }
1353
1354                 void GenerateReadObject (XmlTypeMapping typeMap)
1355                 {
1356                         string isNullable;
1357                         if (_format == SerializationFormat.Literal) {
1358                                 WriteLine ("public " + typeMap.TypeFullName + " " + GetReadObjectName (typeMap) + " (bool isNullable, bool checkType)");
1359                                 isNullable = "isNullable";
1360                         }
1361                         else {
1362                                 WriteLine ("public object " + GetReadObjectName (typeMap) + " ()");
1363                                 isNullable = "true";
1364                         }
1365
1366                         WriteLineInd ("{");
1367
1368                         PushHookContext ();
1369
1370                         SetHookVar ("$TYPE", typeMap.TypeName);
1371                         SetHookVar ("$FULLTYPE", typeMap.TypeFullName);
1372                         SetHookVar ("$NULLABLE", "isNullable");
1373
1374                         switch (typeMap.TypeData.SchemaType)
1375                         {
1376                                 case SchemaTypes.Class: GenerateReadClassInstance (typeMap, isNullable, "checkType"); break;
1377                                 case SchemaTypes.Array:
1378                                         WriteLine ("return " + GenerateReadListElement (typeMap, null, isNullable, true) + ";");
1379                                         break;
1380                                 case SchemaTypes.XmlNode: GenerateReadXmlNodeElement (typeMap, isNullable); break;
1381                                 case SchemaTypes.Primitive: GenerateReadPrimitiveElement (typeMap, isNullable); break;
1382                                 case SchemaTypes.Enum: GenerateReadEnumElement (typeMap, isNullable); break;
1383                                 case SchemaTypes.XmlSerializable: GenerateReadXmlSerializableElement (typeMap, isNullable); break;
1384                                 default: throw new Exception ("Unsupported map type");
1385                         }
1386
1387                         WriteLineUni ("}");
1388                         WriteLine ("");
1389                         PopHookContext ();
1390                 }
1391
1392                 void GenerateReadClassInstance (XmlTypeMapping typeMap, string isNullable, string checkType)
1393                 {
1394                         SetHookVar ("$OBJECT", "ob");
1395                         if (!typeMap.TypeData.IsValueType)
1396                         {
1397                                 WriteLine (typeMap.TypeFullName + " ob = null;");
1398
1399                                 if (GenerateReadHook (HookType.type, typeMap.TypeData.Type)) {
1400                                         WriteLine ("return ob;");
1401                                         return;
1402                                 }
1403
1404                                 if (_format == SerializationFormat.Literal) {
1405                                         WriteLine ("if (" + isNullable + " && ReadNull()) return null;");
1406                                         WriteLine ("");
1407                                         WriteLine ("if (checkType) ");
1408                                         WriteLineInd ("{");
1409                                 }
1410                                 else {
1411                                         WriteLine ("if (ReadNull()) return null;");
1412                                         WriteLine ("");
1413                                 }
1414                         }
1415                         else
1416                         {
1417                                 WriteLine (typeMap.TypeFullName + " ob = new " + typeMap.TypeFullName + " ();");
1418
1419                                 if (GenerateReadHook (HookType.type, typeMap.TypeData.Type)) {
1420                                         WriteLine ("return ob;");
1421                                         return;
1422                                 }
1423                         }
1424
1425                         WriteLine ("System.Xml.XmlQualifiedName t = GetXsiType();");
1426                         WriteLine ("if (t == null)");
1427                         if (typeMap.TypeData.Type != typeof(object))
1428                                 WriteLine ("\t;");
1429                         else
1430                                 WriteLine ("\treturn " + GetCast (typeMap.TypeData, "ReadTypedPrimitive (new System.Xml.XmlQualifiedName(\"anyType\", System.Xml.Schema.XmlSchema.Namespace))") + ";");
1431
1432                         foreach (XmlTypeMapping realMap in typeMap.DerivedTypes)
1433                         {
1434                                 WriteLineInd ("else if (t.Name == " + GetLiteral (realMap.XmlType) + " && t.Namespace == " + GetLiteral (realMap.XmlTypeNamespace) + ")");
1435                                 WriteLine ("return " + GetReadObjectCall(realMap, isNullable, checkType) + ";");
1436                                 Unindent ();
1437                         }
1438
1439                         WriteLine ("else if (t.Name != " + GetLiteral (typeMap.XmlType) + " || t.Namespace != " + GetLiteral (typeMap.XmlTypeNamespace) + ")");
1440                         if (typeMap.TypeData.Type == typeof(object))
1441                                 WriteLine ("\treturn " + GetCast (typeMap.TypeData, "ReadTypedPrimitive (t)") + ";");
1442                         else
1443                                 WriteLine ("\tthrow CreateUnknownTypeException(t);");
1444
1445                         if (!typeMap.TypeData.IsValueType)
1446                         {
1447                                 if (_format == SerializationFormat.Literal)
1448                                         WriteLineUni ("}");
1449
1450                                 if (typeMap.TypeData.Type.IsAbstract) {
1451                                         GenerateEndHook ();
1452                                         WriteLine ("return ob;");
1453                                         return;
1454                                 }
1455
1456                                 WriteLine ("");
1457                                 WriteLine ("ob = new " + typeMap.TypeFullName + " ();");
1458                         }
1459
1460                         WriteLine ("");
1461
1462                         WriteLine ("Reader.MoveToElement();");
1463                         WriteLine ("");
1464
1465                         GenerateReadMembers (typeMap, (ClassMap)typeMap.ObjectMap, "ob", false, false);
1466
1467                         WriteLine ("");
1468
1469                         GenerateEndHook ();
1470                         WriteLine ("return ob;");
1471                 }
1472
1473                 void GenerateReadMembers (XmlMapping xmlMap, ClassMap map, string ob, bool isValueList, bool readByOrder)
1474                 {
1475                         XmlTypeMapping typeMap = xmlMap as XmlTypeMapping;
1476                         Type xmlMapType = (typeMap != null) ? typeMap.TypeData.Type : typeof(object[]);
1477
1478                         // Load the default value of members
1479                         if (map.MembersWithDefault != null)
1480                         {
1481                                 ArrayList members = map.MembersWithDefault;
1482                                 for (int n=0; n<members.Count; n++) {
1483                                         XmlTypeMapMember mem = (XmlTypeMapMember) members[n];
1484                                         GenerateSetMemberValueFromAttr (mem, ob, GetLiteral (mem.DefaultValue), isValueList);
1485                                 }
1486                         }
1487
1488                         // A value list cannot have attributes
1489
1490                         bool first;
1491                         if (!isValueList && !GenerateReadHook (HookType.attributes, xmlMapType))
1492                         {
1493                                 // Reads attributes
1494
1495                                 XmlTypeMapMember anyAttrMember = map.DefaultAnyAttributeMember;
1496
1497                                 if (anyAttrMember != null)
1498                                 {
1499                                         WriteLine ("int anyAttributeIndex = 0;");
1500                                         WriteLine (anyAttrMember.TypeData.FullTypeName + " anyAttributeArray = null;");
1501                                 }
1502
1503                                 WriteLine ("while (Reader.MoveToNextAttribute())");
1504                                 WriteLineInd ("{");
1505                                 first = true;
1506                                 if (map.AttributeMembers != null) {
1507                                         foreach (XmlTypeMapMemberAttribute at in map.AttributeMembers)
1508                                         {
1509                                                 WriteLineInd ((first?"":"else ") + "if (Reader.LocalName == " + GetLiteral (at.AttributeName) + " && Reader.NamespaceURI == " + GetLiteral (at.Namespace) + ") {");
1510                                                 if (!GenerateReadMemberHook (xmlMapType, at)) {
1511                                                         GenerateSetMemberValue (at, ob, GenerateGetValueFromXmlString ("Reader.Value", at.TypeData, at.MappedType), isValueList);
1512                                                         GenerateEndHook ();
1513                                                 }
1514                                                 WriteLineUni ("}");
1515                                                 first = false;
1516                                         }
1517                                 }
1518                                 WriteLineInd ((first?"":"else ") + "if (IsXmlnsAttribute (Reader.Name)) {");
1519
1520                                 // If the map has NamespaceDeclarations,
1521                                 // then store this xmlns to the given member.
1522                                 // If the instance doesn't exist, then create.
1523
1524                                 if (map.NamespaceDeclarations != null) {
1525                                         if (!GenerateReadMemberHook (xmlMapType, map.NamespaceDeclarations)) {
1526                                                 string nss = ob + ".@" + map.NamespaceDeclarations.Name;
1527                                                 WriteLine ("if (" + nss + " == null) " + nss + " = new XmlSerializerNamespaces ();");
1528                                                 WriteLineInd ("if (Reader.Prefix == \"xmlns\")");
1529                                                 WriteLine (nss + ".Add (Reader.LocalName, Reader.Value);");
1530                                                 Unindent ();
1531                                                 WriteLineInd ("else");
1532                                                 WriteLine (nss + ".Add (\"\", Reader.Value);");
1533                                                 Unindent ();
1534                                                 GenerateEndHook ();
1535                                         }
1536                                 }
1537
1538                                 WriteLineUni ("}");
1539                                 WriteLineInd ("else {");
1540
1541                                 if (anyAttrMember != null)
1542                                 {
1543                                         if (!GenerateReadArrayMemberHook (xmlMapType, anyAttrMember, "anyAttributeIndex")) {
1544                                                 WriteLine ("System.Xml.XmlAttribute attr = (System.Xml.XmlAttribute) Document.ReadNode(Reader);");
1545                                                 if (typeof(System.Xml.Schema.XmlSchemaAnnotated).IsAssignableFrom (xmlMapType))
1546                                                         WriteLine ("ParseWsdlArrayType (attr);");
1547                                                 GenerateAddListValue (anyAttrMember.TypeData, "anyAttributeArray", "anyAttributeIndex", GetCast (anyAttrMember.TypeData.ListItemTypeData, "attr"), true);
1548                                                 GenerateEndHook ();
1549                                         }
1550                                         WriteLine ("anyAttributeIndex++;");
1551                                 }
1552                                 else {
1553                                         if (!GenerateReadHook (HookType.unknownAttribute, xmlMapType)) {
1554                                                 WriteLine ("UnknownNode (" + ob + ");");
1555                                                 GenerateEndHook ();
1556                                         }
1557                                 }
1558
1559                                 WriteLineUni ("}");
1560                                 WriteLineUni ("}");
1561
1562                                 if (anyAttrMember != null && !MemberHasReadReplaceHook (xmlMapType, anyAttrMember))
1563                                 {
1564                                         WriteLine ("");
1565                                         WriteLine("anyAttributeArray = (" + anyAttrMember.TypeData.FullTypeName + ") ShrinkArray (anyAttributeArray, anyAttributeIndex, " + GetTypeOf(anyAttrMember.TypeData.Type.GetElementType()) + ", true);");
1566                                         GenerateSetMemberValue (anyAttrMember, ob, "anyAttributeArray", isValueList);
1567                                 }
1568                                 WriteLine ("");
1569
1570                                 GenerateEndHook ();
1571                         }
1572
1573                         if (!isValueList)
1574                         {
1575                                 WriteLine ("Reader.MoveToElement();");
1576                                 WriteLineInd ("if (Reader.IsEmptyElement) {");
1577                                 WriteLine ("Reader.Skip ();");
1578                                 WriteLine ("return " + ob + ";");
1579                                 WriteLineUni ("}");
1580                                 WriteLine ("");
1581
1582                                 WriteLine ("Reader.ReadStartElement();");
1583                         }
1584
1585                         // Reads elements
1586
1587                         WriteLine("Reader.MoveToContent();");
1588                         WriteLine ("");
1589
1590                         if (!GenerateReadHook (HookType.elements, xmlMapType))
1591                         {
1592                                 string[] readFlag = null;
1593                                 if (map.ElementMembers != null && !readByOrder)
1594                                 {
1595                                         string readFlagsVars = "bool ";
1596                                         readFlag = new string[map.ElementMembers.Count];
1597                                         for (int n=0; n<map.ElementMembers.Count; n++) {
1598                                                 readFlag[n] = GetBoolTempVar ();
1599                                                 if (n > 0) readFlagsVars += ", ";
1600                                                 readFlagsVars += readFlag[n] + "=false";
1601                                         }
1602                                         if (map.ElementMembers.Count > 0) WriteLine (readFlagsVars + ";");
1603                                         WriteLine ("");
1604                                 }
1605
1606                                 string[] indexes = null;
1607                                 string[] flatLists = null;
1608
1609                                 if (map.FlatLists != null)
1610                                 {
1611                                         indexes = new string[map.FlatLists.Count];
1612                                         flatLists = new string[map.FlatLists.Count];
1613
1614                                         string code = "int ";
1615                                         for (int n=0; n<map.FlatLists.Count; n++)
1616                                         {
1617                                                 XmlTypeMapMember mem = (XmlTypeMapMember)map.FlatLists[n];
1618                                                 indexes[n] = GetNumTempVar ();
1619                                                 if (n > 0) code += ", ";
1620                                                 code += indexes[n] + "=0";
1621                                                 if (!MemberHasReadReplaceHook (xmlMapType, mem)) {
1622                                                         flatLists[n] = GetObTempVar ();
1623                                                         string rval = "null";
1624                                                         if (IsReadOnly (typeMap, mem, mem.TypeData, isValueList)) rval = ob + ".@" + mem.Name;
1625                                                         WriteLine (mem.TypeData.FullTypeName + " " + flatLists[n] + " = " + rval + ";");
1626                                                 }
1627                                         }
1628                                         WriteLine (code + ";");
1629                                         WriteLine ("");
1630                                 }
1631
1632                                 if (_format == SerializationFormat.Encoded && map.ElementMembers != null)
1633                                 {
1634                                         _fixupCallbacks.Add (xmlMap);
1635                                         WriteLine ("Fixup fixup = new Fixup(" + ob + ", new XmlSerializationFixupCallback(" + GetFixupCallbackName (xmlMap) + "), " + map.ElementMembers.Count + ");");
1636                                         WriteLine ("AddFixup (fixup);");
1637                                         WriteLine ("");
1638                                 }
1639
1640                                 ArrayList infos = null;
1641
1642                                 int maxInd;
1643                                 if (readByOrder) {
1644                                         if (map.ElementMembers != null) maxInd = map.ElementMembers.Count;
1645                                         else maxInd = 0;
1646                                 }
1647                                 else
1648                                 {
1649                                         infos = new ArrayList ();
1650                                         infos.AddRange (map.AllElementInfos);
1651                                         maxInd = infos.Count;
1652
1653                                         WriteLine ("while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) ");
1654                                         WriteLineInd ("{");
1655                                         WriteLine ("if (Reader.NodeType == System.Xml.XmlNodeType.Element) ");
1656                                         WriteLineInd ("{");
1657                                 }
1658
1659                                 first = true;
1660                                 for (int ind = 0; ind < maxInd; ind++)
1661                                 {
1662                                         XmlTypeMapElementInfo info = readByOrder ? map.GetElement (ind) : (XmlTypeMapElementInfo) infos [ind];
1663
1664                                         if (!readByOrder)
1665                                         {
1666                                                 if (info.IsTextElement || info.IsUnnamedAnyElement) continue;
1667                                                 string elemCond = first ? "" : "else ";
1668                                                 elemCond += "if (";
1669                                                 if (!(info.Member.IsReturnValue && _format == SerializationFormat.Encoded)) {
1670                                                         elemCond += "Reader.LocalName == " + GetLiteral (info.ElementName);
1671                                                         if (!map.IgnoreMemberNamespace) elemCond += " && Reader.NamespaceURI == " + GetLiteral (info.Namespace);
1672                                                         elemCond += " && ";
1673                                                 }
1674                                                 elemCond += "!" + readFlag[info.Member.Index] + ") {";
1675                                                 WriteLineInd (elemCond);
1676                                         }
1677
1678                                         if (info.Member.GetType() == typeof (XmlTypeMapMemberList))
1679                                         {
1680                                                 if (_format == SerializationFormat.Encoded && info.MultiReferenceType)
1681                                                 {
1682                                                         string list = GetObTempVar ();
1683                                                         WriteLine ("object " + list + " = ReadReferencingElement (out fixup.Ids[" + info.Member.Index + "]);");
1684                                                         RegisterReferencingMap (info.MappedType);
1685
1686                                                         WriteLineInd ("if (fixup.Ids[" + info.Member.Index + "] == null) {");   // Already read
1687                                                         if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList))
1688                                                                 WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral(info.TypeData.FullTypeName) + ");");
1689                                                         else
1690                                                                 GenerateSetMemberValue (info.Member, ob, GetCast (info.Member.TypeData,list), isValueList);
1691                                                         WriteLineUni ("}");
1692
1693                                                         if (!info.MappedType.TypeData.Type.IsArray)
1694                                                         {
1695                                                                 WriteLineInd ("else {");
1696                                                                 if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList))
1697                                                                         WriteLine (list + " = " + GenerateGetMemberValue (info.Member, ob, isValueList) + ";");
1698                                                                 else {
1699                                                                         WriteLine (list + " = " + GenerateCreateList (info.MappedType.TypeData.Type) + ";");
1700                                                                         GenerateSetMemberValue (info.Member, ob, GetCast (info.Member.TypeData,list), isValueList);
1701                                                                 }
1702                                                                 WriteLine ("AddFixup (new CollectionFixup (" + list + ", new XmlSerializationCollectionFixupCallback (" + GetFillListName(info.Member.TypeData) + "), fixup.Ids[" + info.Member.Index + "]));");
1703                                                                 WriteLine ("fixup.Ids[" + info.Member.Index + "] = null;");             // The member already has the value, no further fix needed.
1704                                                                 WriteLineUni ("}");
1705                                                         }
1706                                                 }
1707                                                 else
1708                                                 {
1709                                                         if (!GenerateReadMemberHook (xmlMapType, info.Member)) {
1710                                                                 if (IsReadOnly (typeMap, info.Member, info.TypeData, isValueList)) GenerateReadListElement (info.MappedType, GenerateGetMemberValue (info.Member, ob, isValueList), GetLiteral(info.IsNullable), false);
1711                                                                 else GenerateSetMemberValue (info.Member, ob, GenerateReadListElement (info.MappedType, null, GetLiteral(info.IsNullable), true), isValueList);
1712                                                                 GenerateEndHook ();
1713                                                         }
1714                                                 }
1715                                                 if (!readByOrder)
1716                                                         WriteLine (readFlag[info.Member.Index] + " = true;");
1717                                         }
1718                                         else if (info.Member.GetType() == typeof (XmlTypeMapMemberFlatList))
1719                                         {
1720                                                 XmlTypeMapMemberFlatList mem = (XmlTypeMapMemberFlatList)info.Member;
1721                                                 if (!GenerateReadArrayMemberHook (xmlMapType, info.Member, indexes[mem.FlatArrayIndex])) {
1722                                                         GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GenerateReadObjectElement (info), !IsReadOnly (typeMap, info.Member, info.TypeData, isValueList));
1723                                                         GenerateEndHook ();
1724                                                 }
1725                                                 WriteLine (indexes[mem.FlatArrayIndex] + "++;");
1726                                         }
1727                                         else if (info.Member.GetType() == typeof (XmlTypeMapMemberAnyElement))
1728                                         {
1729                                                 XmlTypeMapMemberAnyElement mem = (XmlTypeMapMemberAnyElement)info.Member;
1730                                                 if (mem.TypeData.IsListType) {
1731                                                         if (!GenerateReadArrayMemberHook (xmlMapType, info.Member, indexes[mem.FlatArrayIndex])) {
1732                                                                 GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GetReadXmlNode (mem.TypeData.ListItemTypeData, false), true);
1733                                                                 GenerateEndHook ();
1734                                                         }
1735                                                         WriteLine (indexes[mem.FlatArrayIndex] + "++;");
1736                                                 }
1737                                                 else {
1738                                                         if (!GenerateReadMemberHook (xmlMapType, info.Member)) {
1739                                                                 GenerateSetMemberValue (mem, ob, GetReadXmlNode(mem.TypeData, false), isValueList);
1740                                                                 GenerateEndHook ();
1741                                                         }
1742                                                 }
1743                                         }
1744                                         else if (info.Member.GetType() == typeof(XmlTypeMapMemberElement))
1745                                         {
1746                                                 if (!readByOrder)
1747                                                         WriteLine (readFlag[info.Member.Index] + " = true;");
1748                                                 if (_format == SerializationFormat.Encoded)
1749                                                 {
1750                                                         string val = GetObTempVar ();
1751                                                         RegisterReferencingMap (info.MappedType);
1752
1753                                                         if (info.Member.TypeData.SchemaType != SchemaTypes.Primitive)
1754                                                                 WriteLine ("object " + val + " = ReadReferencingElement (out fixup.Ids[" + info.Member.Index + "]);");
1755                                                         else
1756                                                                 WriteLine ("object " + val + " = ReadReferencingElement (" + GetLiteral(info.Member.TypeData.XmlType) + ", " + GetLiteral(System.Xml.Schema.XmlSchema.Namespace) + ", out fixup.Ids[" + info.Member.Index + "]);");
1757
1758                                                         if (info.MultiReferenceType)
1759                                                                 WriteLineInd ("if (fixup.Ids[" + info.Member.Index + "] == null) {");   // already read
1760                                                         else
1761                                                                 WriteLineInd ("if (" + val + " != null) {");    // null value
1762
1763                                                         GenerateSetMemberValue (info.Member, ob, GetCast (info.Member.TypeData,val), isValueList);
1764                                                         WriteLineUni ("}");
1765                                                 }
1766                                                 else if (!GenerateReadMemberHook (xmlMapType, info.Member)) {
1767                                                         GenerateSetMemberValue (info.Member, ob, GenerateReadObjectElement (info), isValueList);
1768                                                         GenerateEndHook ();
1769                                                 }
1770                                         }
1771                                         else
1772                                                 throw new InvalidOperationException ("Unknown member type");
1773
1774                                         if (!readByOrder)
1775                                                 WriteLineUni ("}");
1776                                         first = false;
1777                                 }
1778
1779                                 if (!readByOrder)
1780                                 {
1781                                         if (!first) WriteLineInd ("else {");
1782
1783                                         if (map.DefaultAnyElementMember != null)
1784                                         {
1785                                                 XmlTypeMapMemberAnyElement mem = map.DefaultAnyElementMember;
1786                                                 if (mem.TypeData.IsListType) {
1787                                                         if (!GenerateReadArrayMemberHook (xmlMapType, mem, indexes[mem.FlatArrayIndex])) {
1788                                                                 GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], GetReadXmlNode(mem.TypeData.ListItemTypeData, false), true);
1789                                                                 GenerateEndHook ();
1790                                                         }
1791                                                         WriteLine (indexes[mem.FlatArrayIndex] + "++;");
1792                                                 }
1793                                                 else if (! GenerateReadMemberHook (xmlMapType, mem)) {
1794                                                         GenerateSetMemberValue (mem, ob, GetReadXmlNode(mem.TypeData, false), isValueList);
1795                                                         GenerateEndHook ();
1796                                                 }
1797                                         }
1798                                         else {
1799                                                 if (!GenerateReadHook (HookType.unknownElement, xmlMapType)) {
1800                                                         WriteLine ("UnknownNode (" + ob + ");");
1801                                                         GenerateEndHook ();
1802                                                 }
1803                                         }
1804
1805                                         if (!first) WriteLineUni ("}");
1806
1807                                         WriteLineUni ("}");
1808
1809                                         if (map.XmlTextCollector != null)
1810                                         {
1811                                                 WriteLine ("else if (Reader.NodeType == System.Xml.XmlNodeType.Text)");
1812                                                 WriteLineInd ("{");
1813
1814                                                 if (map.XmlTextCollector is XmlTypeMapMemberExpandable)
1815                                                 {
1816                                                         XmlTypeMapMemberExpandable mem = (XmlTypeMapMemberExpandable)map.XmlTextCollector;
1817                                                         XmlTypeMapMemberFlatList flatl = mem as XmlTypeMapMemberFlatList;
1818                                                         TypeData itype = (flatl == null) ? mem.TypeData.ListItemTypeData : flatl.ListMap.FindTextElement().TypeData;
1819
1820                                                         if (!GenerateReadArrayMemberHook (xmlMapType, map.XmlTextCollector, indexes[mem.FlatArrayIndex])) {
1821                                                                 string val = (itype.Type == typeof (string)) ? "Reader.ReadString()" : GetReadXmlNode (itype, false);
1822                                                                 GenerateAddListValue (mem.TypeData, flatLists[mem.FlatArrayIndex], indexes[mem.FlatArrayIndex], val, true);
1823                                                                 GenerateEndHook ();
1824                                                         }
1825                                                         WriteLine (indexes[mem.FlatArrayIndex] + "++;");
1826                                                 }
1827                                                 else if (!GenerateReadMemberHook (xmlMapType, map.XmlTextCollector))
1828                                                 {
1829                                                         XmlTypeMapMemberElement mem = (XmlTypeMapMemberElement) map.XmlTextCollector;
1830                                                         XmlTypeMapElementInfo info = (XmlTypeMapElementInfo) mem.ElementInfo [0];
1831                                                         if (info.TypeData.Type == typeof (string))
1832                                                                 GenerateSetMemberValue (mem, ob, "ReadString (" + GenerateGetMemberValue (mem, ob, isValueList) + ")", isValueList);
1833                                                         else
1834                                                                 GenerateSetMemberValue (mem, ob, GenerateGetValueFromXmlString ("Reader.ReadString()", info.TypeData, info.MappedType), isValueList);
1835                                                         GenerateEndHook ();
1836                                                 }
1837                                                 WriteLineUni ("}");
1838                                         }
1839
1840                                         WriteLine ("else");
1841                                         WriteLine ("\tUnknownNode(" + ob + ");");
1842                                         WriteLine ("");
1843                                         WriteLine ("Reader.MoveToContent();");
1844                                         WriteLineUni ("}");
1845                                 }
1846                                 else
1847                                         WriteLine ("Reader.MoveToContent();");
1848
1849                                 if (flatLists != null)
1850                                 {
1851                                         WriteLine ("");
1852                                         foreach (XmlTypeMapMemberExpandable mem in map.FlatLists)
1853                                         {
1854                                                 if (MemberHasReadReplaceHook (xmlMapType, mem)) continue;
1855
1856                                                 string list = flatLists[mem.FlatArrayIndex];
1857                                                 if (mem.TypeData.Type.IsArray)
1858                                                         WriteLine (list + " = (" + mem.TypeData.FullTypeName + ") ShrinkArray (" + list + ", " + indexes[mem.FlatArrayIndex] + ", " + GetTypeOf(mem.TypeData.Type.GetElementType()) + ", true);");
1859                                                 if (!IsReadOnly (typeMap, mem, mem.TypeData, isValueList))
1860                                                         GenerateSetMemberValue (mem, ob, list, isValueList);
1861                                         }
1862                                 }
1863                                 GenerateEndHook ();
1864                         }
1865
1866                         if (!isValueList)
1867                         {
1868                                 WriteLine ("");
1869                                 WriteLine ("ReadEndElement();");
1870                         }
1871                 }
1872
1873                 bool IsReadOnly (XmlTypeMapping map, XmlTypeMapMember member, TypeData memType, bool isValueList)
1874                 {
1875                         if (isValueList) return !memType.HasPublicConstructor;
1876                         else return member.IsReadOnly (map.TypeData.Type) || !memType.HasPublicConstructor;
1877                 }
1878
1879                 void GenerateSetMemberValue (XmlTypeMapMember member, string ob, string value, bool isValueList)
1880                 {
1881                         if (isValueList) WriteLine (ob + "[" + member.Index + "] = " + value + ";");
1882                         else {
1883                                 WriteLine (ob + ".@" + member.Name + " = " + value + ";");
1884                                 if (member.IsOptionalValueType)
1885                                         WriteLine (ob + "." + member.Name + "Specified = true;");
1886                         }
1887                 }
1888
1889                 void GenerateSetMemberValueFromAttr (XmlTypeMapMember member, string ob, string value, bool isValueList)
1890                 {
1891                         // Enumeration values specified in custom attributes are stored as integer
1892                         // values if the custom attribute property is of type object. So, it is
1893                         // necessary to convert to the enum type before asigning the value to the field.
1894
1895                         if (member.TypeData.Type.IsEnum)
1896                                 value = GetCast (member.TypeData.Type, value);
1897                         GenerateSetMemberValue (member, ob, value, isValueList);
1898                 }
1899
1900                 object GenerateGetMemberValue (XmlTypeMapMember member, object ob, bool isValueList)
1901                 {
1902                         if (isValueList) return ob + "[" + member.Index + "]";
1903                         else return ob + ".@" + member.Name;
1904                 }
1905
1906                 string GenerateReadObjectElement (XmlTypeMapElementInfo elem)
1907                 {
1908                         switch (elem.TypeData.SchemaType)
1909                         {
1910                                 case SchemaTypes.XmlNode:
1911                                         return GetReadXmlNode (elem.TypeData, true);
1912
1913                                 case SchemaTypes.Primitive:
1914                                 case SchemaTypes.Enum:
1915                                         return GenerateReadPrimitiveValue (elem);
1916
1917                                 case SchemaTypes.Array:
1918                                         return GenerateReadListElement (elem.MappedType, null, GetLiteral(elem.IsNullable), true);
1919
1920                                 case SchemaTypes.Class:
1921                                         return GetReadObjectCall (elem.MappedType, GetLiteral(elem.IsNullable), "true");
1922
1923                                 case SchemaTypes.XmlSerializable:
1924                                         return GetCast (elem.TypeData, "ReadSerializable (new " + elem.TypeData.FullTypeName + " ())");
1925
1926                                 default:
1927                                         throw new NotSupportedException ("Invalid value type");
1928                         }
1929                 }
1930
1931                 string GenerateReadPrimitiveValue (XmlTypeMapElementInfo elem)
1932                 {
1933                         if (elem.TypeData.Type == typeof (XmlQualifiedName)) {
1934                                 if (elem.IsNullable) return "ReadNullableQualifiedName ()";
1935                                 else return "ReadElementQualifiedName ()";
1936                         }
1937                         else if (elem.IsNullable)
1938                                 return GenerateGetValueFromXmlString ("ReadNullableString ()", elem.TypeData, elem.MappedType);
1939                         else
1940                                 return GenerateGetValueFromXmlString ("Reader.ReadElementString ()", elem.TypeData, elem.MappedType);
1941                 }
1942
1943                 string GenerateGetValueFromXmlString (string value, TypeData typeData, XmlTypeMapping typeMap)
1944                 {
1945                         if (typeData.SchemaType == SchemaTypes.Array)
1946                                 return GenerateReadListString (typeMap, value);
1947                         else if (typeData.SchemaType == SchemaTypes.Enum)
1948                                 return GenerateGetEnumValue (typeMap, value);
1949                         else if (typeData.Type == typeof (XmlQualifiedName))
1950                                 return "ToXmlQualifiedName (" + value + ")";
1951                         else
1952                                 return XmlCustomFormatter.GenerateFromXmlString (typeData, value);
1953                 }
1954
1955                 string GenerateReadListElement (XmlTypeMapping typeMap, string list, string isNullable, bool canCreateInstance)
1956                 {
1957                         Type listType = typeMap.TypeData.Type;
1958                         ListMap listMap = (ListMap)typeMap.ObjectMap;
1959
1960                         if (canCreateInstance && typeMap.TypeData.HasPublicConstructor)
1961                         {
1962                                 list = GetObTempVar ();
1963                                 WriteLine (typeMap.TypeFullName + " " + list + " = null;");
1964                                 WriteLineInd ("if (!ReadNull()) {");
1965                                 WriteLine (list + " = " + GenerateCreateList (listType) + ";");
1966                         }
1967                         else
1968                         {
1969                                 if (list != null) {
1970                                         WriteLineInd ("if (" + list + " == null)");
1971                                         WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral (typeMap.TypeFullName) + ");");
1972                                         Unindent ();
1973                                         WriteLineInd ("if (!ReadNull()) {");
1974                                 }
1975                                 else {
1976                                         list = GetObTempVar ();
1977                                         WriteLine (typeMap.TypeFullName + " " + list + " = null;");
1978                                         WriteLineInd ("if (" + list + " == null)");
1979                                         WriteLine ("throw CreateReadOnlyCollectionException (" + GetLiteral (typeMap.TypeFullName) + ");");
1980                                         Unindent ();
1981                                         return list;
1982                                 }
1983                         }
1984
1985                         WriteLineInd ("if (Reader.IsEmptyElement) {");
1986                         WriteLine ("Reader.Skip();");
1987                         if (listType.IsArray)
1988                                 WriteLine (list + " = (" + typeMap.TypeFullName + ") ShrinkArray (" + list + ", 0, " + GetTypeOf(listType.GetElementType()) + ", " + isNullable + ");");
1989
1990                         Unindent ();
1991                         WriteLineInd ("} else {");
1992
1993                         string index = GetNumTempVar ();
1994                         WriteLine ("int " + index + " = 0;");
1995                         WriteLine ("Reader.ReadStartElement();");
1996                         WriteLine ("Reader.MoveToContent();");
1997                         WriteLine ("");
1998
1999                         WriteLine ("while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) ");
2000                         WriteLineInd ("{");
2001                         WriteLine ("if (Reader.NodeType == System.Xml.XmlNodeType.Element) ");
2002                         WriteLineInd ("{");
2003
2004                         bool first = true;
2005                         foreach (XmlTypeMapElementInfo elemInfo in listMap.ItemInfo)
2006                         {
2007                                 WriteLineInd ((first?"":"else ") + "if (Reader.LocalName == " + GetLiteral (elemInfo.ElementName) + " && Reader.NamespaceURI == " + GetLiteral (elemInfo.Namespace) + ") {");
2008                                 GenerateAddListValue (typeMap.TypeData, list, index, GenerateReadObjectElement (elemInfo), false);
2009                                 WriteLine (index + "++;");
2010                                 WriteLineUni ("}");
2011                                 first = false;
2012                         }
2013                         if (!first) WriteLine ("else UnknownNode (null);");
2014                         else WriteLine ("UnknownNode (null);");
2015
2016                         WriteLineUni ("}");
2017                         WriteLine ("else UnknownNode (null);");
2018                         WriteLine ("");
2019                         WriteLine ("Reader.MoveToContent();");
2020                         WriteLineUni ("}");
2021
2022                         WriteLine ("ReadEndElement();");
2023
2024                         if (listType.IsArray)
2025                                 WriteLine (list + " = (" + typeMap.TypeFullName + ") ShrinkArray (" + list + ", " + index + ", " + GetTypeOf(listType.GetElementType()) + ", " + isNullable + ");");
2026
2027                         WriteLineUni ("}");
2028                         WriteLineUni ("}");
2029
2030                         return list;
2031                 }
2032
2033                 string GenerateReadListString (XmlTypeMapping typeMap, string values)
2034                 {
2035                         Type listType = typeMap.TypeData.Type;
2036                         ListMap listMap = (ListMap)typeMap.ObjectMap;
2037                         string itemType = listType.GetElementType().FullName;
2038
2039                         string list = GetObTempVar ();
2040                         WriteLine (itemType + "[] " + list + ";");
2041
2042                         string var = GetStrTempVar ();
2043                         WriteLine ("string " + var + " = " + values + ".Trim();");
2044                         WriteLineInd ("if (" + var + " != string.Empty) {");
2045
2046                         string valueArray = GetObTempVar ();
2047                         WriteLine ("string[] " + valueArray + " = " + var + ".Split (' ');");
2048
2049                         WriteLine (list + " = new " + itemType + " [" + valueArray + ".Length];");
2050
2051                         XmlTypeMapElementInfo info = (XmlTypeMapElementInfo)listMap.ItemInfo[0];
2052
2053                         string index = GetNumTempVar ();
2054                         WriteLineInd ("for (int " + index + " = 0; " + index + " < " + valueArray + ".Length; " + index + "++)");
2055                         WriteLine (list + "[" + index + "] = " + GenerateGetValueFromXmlString (valueArray + "[" + index + "]", info.TypeData, info.MappedType) + ";");
2056                         Unindent ();
2057                         WriteLineUni ("}");
2058                         WriteLine ("else");
2059                         WriteLine ("\t" + list + " = new " + itemType + " [0];");
2060
2061                         return list;
2062                 }
2063
2064                 void GenerateAddListValue (TypeData listType, string list, string index, string value, bool canCreateInstance)
2065                 {
2066                         Type type = listType.Type;
2067                         if (type.IsArray)
2068                         {
2069                                 WriteLine (list + " = (" + type.FullName + ") EnsureArrayIndex (" + list + ", " + index + ", " + GetTypeOf(type.GetElementType()) + ");");
2070                                 WriteLine (list + "[" + index + "] = " + value + ";");
2071                         }
2072                         else    // Must be IEnumerable
2073                         {
2074                                 WriteLine ("if (" + list + " == null)");
2075                                 if (canCreateInstance)
2076                                         WriteLine ("\t" + list + " = new " + listType.FullTypeName + "();");
2077                                 else
2078                                         WriteLine ("\tthrow CreateReadOnlyCollectionException (" + GetLiteral (listType.FullTypeName) + ");");
2079
2080                                 WriteLine (list + ".Add (" + value + ");");
2081                         }
2082                 }
2083
2084                 string GenerateCreateList (Type listType)
2085                 {
2086                         if (listType.IsArray)
2087                                 return "(" + listType.FullName + ") EnsureArrayIndex (null, 0, " + GetTypeOf(listType.GetElementType()) + ")";
2088                         else
2089                                 return "new " + listType.FullName + "()";
2090                 }
2091
2092                 void GenerateFillerCallbacks ()
2093                 {
2094                         foreach (TypeData td in _listsToFill)
2095                         {
2096                                 string metName = GetFillListName (td);
2097                                 WriteLine ("void " + metName + " (object list, object source)");
2098                                 WriteLineInd ("{");
2099                                 WriteLine ("if (list == null) throw CreateReadOnlyCollectionException (" + GetLiteral (td.FullTypeName) + ");");
2100                                 WriteLine ("");
2101
2102                                 WriteLine (td.FullTypeName + " dest = (" + td.FullTypeName + ") list;");
2103                                 WriteLine ("foreach (object ob in (IEnumerable)source)");
2104                                 WriteLine ("\tdest.Add (" + GetCast (td.ListItemTypeData, "ob") + ");");
2105                                 WriteLineUni ("}");
2106                                 WriteLine ("");
2107                         }
2108                 }
2109
2110                 void GenerateReadXmlNodeElement (XmlTypeMapping typeMap, string isNullable)
2111                 {
2112                         WriteLine ("return " + GetReadXmlNode (typeMap.TypeData, false) + ";");
2113                 }
2114
2115                 void GenerateReadPrimitiveElement (XmlTypeMapping typeMap, string isNullable)
2116                 {
2117                         WriteLine ("XmlQualifiedName t = GetXsiType();");
2118                         WriteLine ("if (t == null) t = new XmlQualifiedName (" + GetLiteral(typeMap.XmlType) + ", " + GetLiteral(typeMap.Namespace) + ");");
2119                         WriteLine ("return " + GetCast (typeMap.TypeData, "ReadTypedPrimitive (t)") + ";");
2120                 }
2121
2122                 void GenerateReadEnumElement (XmlTypeMapping typeMap, string isNullable)
2123                 {
2124                         WriteLine ("Reader.ReadStartElement ();");
2125                         WriteLine (typeMap.TypeFullName + " res = " + GenerateGetEnumValue (typeMap, "Reader.ReadString()") + ";");
2126                         WriteLine ("Reader.ReadEndElement ();");
2127                         WriteLine ("return res;");
2128                 }
2129
2130                 string GenerateGetEnumValue (XmlTypeMapping typeMap, string val)
2131                 {
2132                         return GetGetEnumValueName (typeMap) + " (" + val + ")";
2133                 }
2134
2135                 void GenerateGetEnumValue (XmlTypeMapping typeMap)
2136                 {
2137                         string metName = GetGetEnumValueName (typeMap);
2138                         EnumMap map = (EnumMap) typeMap.ObjectMap;
2139
2140                         if (map.IsFlags)
2141                         {
2142                                 string switchMethod =  metName + "_Switch";
2143                                 WriteLine (typeMap.TypeFullName + " " + metName + " (string xmlName)");
2144                                 WriteLineInd ("{");
2145                                 WriteLine ("xmlName = xmlName.Trim();");
2146                                 WriteLine ("if (xmlName.Length == 0) return (" + typeMap.TypeFullName + ")0;");
2147                                 WriteLine ("if (xmlName.IndexOf (' ') != -1)");
2148                                 WriteLineInd ("{");
2149                                 WriteLine (typeMap.TypeFullName + " sb = (" + typeMap.TypeFullName + ")0;");
2150                                 WriteLine ("string[] enumNames = xmlName.ToString().Split (' ');");
2151                                 WriteLine ("foreach (string name in enumNames)");
2152                                 WriteLineInd ("{");
2153                                 WriteLine ("if (name == string.Empty) continue;");
2154                                 WriteLine ("sb |= " + switchMethod + " (name); ");
2155                                 WriteLineUni ("}");
2156                                 WriteLine ("return sb;");
2157                                 WriteLineUni ("}");
2158                                 WriteLine ("else");
2159                                 WriteLine ("\treturn " + switchMethod + " (xmlName);");
2160                                 WriteLineUni ("}");
2161                                 metName = switchMethod;
2162                         }
2163
2164                         WriteLine (typeMap.TypeFullName + " " + metName + " (string xmlName)");
2165                         WriteLineInd ("{");
2166                         GenerateGetSingleEnumValue (typeMap, "xmlName");
2167                         WriteLineUni ("}");
2168                         WriteLine ("");
2169                 }
2170
2171                 void GenerateGetSingleEnumValue (XmlTypeMapping typeMap, string val)
2172                 {
2173                         EnumMap map = (EnumMap) typeMap.ObjectMap;
2174                         WriteLine ("switch (" + val + ")");
2175                         WriteLineInd ("{");
2176                         foreach (EnumMap.EnumMapMember mem in map.Members)
2177                         {
2178                                 WriteLine ("case " + GetLiteral (mem.XmlName) + ": return " + typeMap.TypeFullName + "." + mem.EnumName + ";");
2179                         }
2180                         WriteLineInd ("default:");
2181                         WriteLineInd ("try {");
2182                         WriteLine ("return (" + typeMap.TypeFullName + ") Int64.Parse (" + val + ", CultureInfo.InvariantCulture);");
2183                         WriteLineUni ("}");
2184                         WriteLineInd ("catch {");
2185                         WriteLine ("throw CreateUnknownConstantException (" + val + ", typeof(" + typeMap.TypeFullName + "));");
2186                         WriteLineUni ("}");
2187                         Unindent ();
2188                         WriteLineUni ("}");
2189                 }
2190
2191                 void GenerateReadXmlSerializableElement (XmlTypeMapping typeMap, string isNullable)
2192                 {
2193                         WriteLine ("Reader.MoveToContent ();");
2194                         WriteLine ("if (Reader.NodeType == XmlNodeType.Element)");
2195                         WriteLineInd ("{");
2196                         WriteLine ("if (Reader.LocalName == " + GetLiteral (typeMap.ElementName) + " && Reader.NamespaceURI == " + GetLiteral (typeMap.Namespace) + ")");
2197                         WriteLine ("\treturn ReadSerializable (new " + typeMap.TypeData.FullTypeName + "());");
2198                         WriteLine ("else");
2199                         WriteLine ("\tthrow CreateUnknownNodeException ();");
2200                         WriteLineUni ("}");
2201                         WriteLine ("else UnknownNode (null);");
2202                         WriteLine ("");
2203                         WriteLine ("return null;");
2204                 }
2205
2206                 void GenerateReadInitCallbacks ()
2207                 {
2208                         WriteLine ("protected override void InitCallbacks ()");
2209                         WriteLineInd ("{");
2210
2211                         if (_format == SerializationFormat.Encoded)
2212                         {
2213                                 foreach (XmlMapping xmap in _mapsToGenerate)
2214                                 {
2215                                         XmlTypeMapping map = xmap as XmlTypeMapping;
2216                                         if (map == null) continue;
2217                                         if (map.TypeData.SchemaType == SchemaTypes.Class || map.TypeData.SchemaType == SchemaTypes.Enum)
2218                                                 WriteMetCall ("AddReadCallback", GetLiteral (map.XmlType), GetLiteral(map.Namespace), GetTypeOf(map.TypeData.Type), "new XmlSerializationReadCallback (" + GetReadObjectName (map) + ")");
2219                                 }
2220                         }
2221
2222                         WriteLineUni ("}");
2223                         WriteLine ("");
2224
2225                         WriteLine ("protected override void InitIDs ()");
2226                         WriteLine ("{");
2227                         WriteLine ("}");
2228                         WriteLine ("");
2229                 }
2230
2231                 void GenerateFixupCallbacks ()
2232                 {
2233                         foreach (XmlMapping map in _fixupCallbacks)
2234                         {
2235                                 bool isList = map is XmlMembersMapping;
2236                                 string tname = !isList ? ((XmlTypeMapping)map).TypeFullName : "object[]";
2237                                 WriteLine ("void " + GetFixupCallbackName (map) + " (object obfixup)");
2238                                 WriteLineInd ("{");
2239                                 WriteLine ("Fixup fixup = (Fixup)obfixup;");
2240                                 WriteLine (tname + " source = (" + tname + ") fixup.Source;");
2241                                 WriteLine ("string[] ids = fixup.Ids;");
2242                                 WriteLine ("");
2243
2244                                 ClassMap cmap = (ClassMap)map.ObjectMap;
2245                                 ICollection members = cmap.ElementMembers;
2246                                 if (members != null) {
2247                                         foreach (XmlTypeMapMember member in members)
2248                                         {
2249                                                 WriteLineInd ("if (ids[" + member.Index + "] != null)");
2250                                                 GenerateSetMemberValue (member, "source", GetCast (member.TypeData, "GetTarget(ids[" + member.Index + "])"), isList);
2251                                                 Unindent ();
2252                                         }
2253                                 }
2254                                 WriteLineUni ("}");
2255                                 WriteLine ("");
2256                         }
2257                 }
2258
2259                 string GetReadXmlNode (TypeData type, bool wrapped)
2260                 {
2261                         if (type.Type == typeof (XmlDocument))
2262                                 return GetCast (type, TypeTranslator.GetTypeData (typeof(XmlDocument)), "ReadXmlDocument (" + GetLiteral(wrapped) + ")");
2263                         else
2264                                 return GetCast (type, TypeTranslator.GetTypeData (typeof(XmlNode)), "ReadXmlNode (" + GetLiteral(wrapped) + ")");
2265                 }
2266
2267                 #endregion
2268
2269                 #region Helper methods
2270
2271                 //*******************************************************
2272                 // Helper methods
2273                 //
2274
2275                 ArrayList _listsToFill = new ArrayList ();
2276                 Hashtable _hooks;
2277                 Hashtable _hookVariables;
2278                 Stack _hookContexts;
2279                 Stack _hookOpenHooks;
2280
2281                 class HookInfo {
2282                         public HookType HookType;
2283                         public Type Type;
2284                         public string Member;
2285                         public HookDir Direction;
2286                 }
2287
2288                 void InitHooks ()
2289                 {
2290                         _hookContexts = new Stack ();
2291                         _hookOpenHooks = new Stack ();
2292                         _hookVariables = new Hashtable ();
2293                         _hooks = new Hashtable ();
2294                 }
2295
2296                 void PushHookContext ()
2297                 {
2298                         _hookContexts.Push (_hookVariables);
2299                         _hookVariables = (Hashtable) _hookVariables.Clone ();
2300                 }
2301
2302                 void PopHookContext ()
2303                 {
2304                         _hookVariables = (Hashtable) _hookContexts.Pop ();
2305                 }
2306
2307                 void SetHookVar (string var, string value)
2308                 {
2309                         _hookVariables [var] = value;
2310                 }
2311
2312                 bool GenerateReadHook (HookType hookType, Type type)
2313                 {
2314                         return GenerateHook (hookType, HookDir.Read, type, null);
2315                 }
2316
2317                 bool GenerateWriteHook (HookType hookType, Type type)
2318                 {
2319                         return GenerateHook (hookType, HookDir.Write, type, null);
2320                 }
2321
2322                 bool GenerateWriteMemberHook (Type type, XmlTypeMapMember member)
2323                 {
2324                         SetHookVar ("$MEMBER", member.Name);
2325                         return GenerateHook (HookType.member, HookDir.Write, type, member.Name);
2326                 }
2327
2328                 bool GenerateReadMemberHook (Type type, XmlTypeMapMember member)
2329                 {
2330                         SetHookVar ("$MEMBER", member.Name);
2331                         return GenerateHook (HookType.member, HookDir.Read, type, member.Name);
2332                 }
2333
2334                 bool GenerateReadArrayMemberHook (Type type, XmlTypeMapMember member, string index)
2335                 {
2336                         SetHookVar ("$INDEX", index);
2337                         return GenerateReadMemberHook (type, member);
2338                 }
2339
2340                 bool MemberHasReadReplaceHook (Type type, XmlTypeMapMember member)
2341                 {
2342                         if (_config == null) return false;
2343                         return _config.GetHooks (HookType.member, HookDir.Read, HookAction.Replace, type, member.Name).Count > 0;
2344                 }
2345
2346                 bool GenerateHook (HookType hookType, HookDir dir, Type type, string member)
2347                 {
2348                         GenerateHooks (hookType, dir, type, null, HookAction.InsertBefore);
2349                         if (GenerateHooks (hookType, dir, type, null, HookAction.Replace))
2350                         {
2351                                 GenerateHooks (hookType, dir, type, null, HookAction.InsertAfter);
2352                                 return true;
2353                         }
2354                         else
2355                         {
2356                                 HookInfo hi = new HookInfo ();
2357                                 hi.HookType = hookType;
2358                                 hi.Type = type;
2359                                 hi.Member = member;
2360                                 hi.Direction = dir;
2361                                 _hookOpenHooks.Push (hi);
2362                                 return false;
2363                         }
2364                 }
2365
2366                 void GenerateEndHook ()
2367                 {
2368                         HookInfo hi = (HookInfo) _hookOpenHooks.Pop();
2369                         GenerateHooks (hi.HookType, hi.Direction, hi.Type, hi.Member, HookAction.InsertAfter);
2370                 }
2371
2372                 bool GenerateHooks (HookType hookType, HookDir dir, Type type, string member, HookAction action)
2373                 {
2374                         if (_config == null) return false;
2375                         ArrayList hooks = _config.GetHooks (hookType, dir, action, type, null);
2376                         if (hooks.Count == 0) return false;
2377                         foreach (Hook hook in hooks)
2378                         {
2379                                 string code = hook.GetCode (action);
2380                                 foreach (DictionaryEntry de in _hookVariables)
2381                                         code = code.Replace ((string)de.Key, (string)de.Value);
2382                                 WriteMultilineCode (code);
2383                         }
2384                         return true;
2385                 }
2386
2387                 string GetRootTypeName ()
2388                 {
2389                         if (_typeMap is XmlTypeMapping) return ((XmlTypeMapping)_typeMap).TypeFullName;
2390                         else return "object[]";
2391                 }
2392
2393                 string GetNumTempVar ()
2394                 {
2395                         return "n" + (_tempVarId++);
2396                 }
2397
2398                 string GetObTempVar ()
2399                 {
2400                         return "o" + (_tempVarId++);
2401                 }
2402
2403                 string GetStrTempVar ()
2404                 {
2405                         return "s" + (_tempVarId++);
2406                 }
2407
2408                 string GetBoolTempVar ()
2409                 {
2410                         return "b" + (_tempVarId++);
2411                 }
2412
2413                 string GetUniqueName (string uniqueGroup, object ob, string name)
2414                 {
2415                         name = name.Replace ("[]","_array");
2416                         Hashtable names = (Hashtable) _uniqueNames [uniqueGroup];
2417                         if (names == null) {
2418                                 names = new Hashtable ();
2419                                 _uniqueNames [uniqueGroup] = names;
2420                         }
2421
2422                         string res = (string) names [ob];
2423                         if (res != null) return res;
2424
2425                         foreach (string n in names.Values)
2426                                 if (n == name) return GetUniqueName (uniqueGroup, ob, name + (_methodId++));
2427
2428                         names [ob] = name;
2429                         return name;
2430                 }
2431
2432                 void RegisterReferencingMap (XmlTypeMapping typeMap)
2433                 {
2434                         if (typeMap != null && !_mapsToGenerate.Contains (typeMap))
2435                                 _mapsToGenerate.Add (typeMap);
2436                 }
2437
2438                 string GetWriteObjectName (XmlTypeMapping typeMap)
2439                 {
2440                         if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2441                         return GetUniqueName ("rw", typeMap, "WriteObject_" + typeMap.XmlType);
2442                 }
2443
2444                 string GetReadObjectName (XmlTypeMapping typeMap)
2445                 {
2446                         if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2447                         return GetUniqueName ("rr", typeMap, "ReadObject_" + typeMap.XmlType);
2448                 }
2449
2450                 string GetGetEnumValueName (XmlTypeMapping typeMap)
2451                 {
2452                         if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2453                         return GetUniqueName ("ge", typeMap, "GetEnumValue_" + typeMap.XmlType);
2454                 }
2455
2456                 string GetWriteObjectCallbackName (XmlTypeMapping typeMap)
2457                 {
2458                         if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2459                         return GetUniqueName ("wc", typeMap, "WriteCallback_" + typeMap.XmlType);
2460                 }
2461
2462                 string GetFixupCallbackName (XmlMapping typeMap)
2463                 {
2464                         if (!_mapsToGenerate.Contains (typeMap)) _mapsToGenerate.Add (typeMap);
2465
2466                         if (typeMap is XmlTypeMapping)
2467                                 return GetUniqueName ("fc", typeMap, "FixupCallback_" + ((XmlTypeMapping)typeMap).XmlType);
2468                         else
2469                                 return GetUniqueName ("fc", typeMap, "FixupCallback__Message");
2470                 }
2471
2472                 string GetUniqueClassName (string s)
2473                 {
2474                         return classNames.AddUnique (s, null);
2475                 }
2476
2477                 string GetReadObjectCall (XmlTypeMapping typeMap, string isNullable, string checkType)
2478                 {
2479                         if (_format == SerializationFormat.Literal)
2480                                 return GetReadObjectName (typeMap) + " (" + isNullable + ", " + checkType + ")";
2481                         else
2482                                 return GetCast (typeMap.TypeData, GetReadObjectName (typeMap) + " ()");
2483                 }
2484
2485                 string GetFillListName (TypeData td)
2486                 {
2487                         if (!_listsToFill.Contains (td)) _listsToFill.Add (td);
2488                         return GetUniqueName ("fl", td, "Fill_" + td.TypeName);
2489                 }
2490
2491                 string GetCast (TypeData td, TypeData tdval, string val)
2492                 {
2493                         if (td.FullTypeName == tdval.FullTypeName) return val;
2494                         else return GetCast (td, val);
2495                 }
2496
2497                 string GetCast (TypeData td, string val)
2498                 {
2499                         return "((" + td.FullTypeName + ") " + val + ")";
2500                 }
2501
2502                 string GetCast (Type td, string val)
2503                 {
2504                         return "((" + td.FullName + ") " + val + ")";
2505                 }
2506
2507                 string GetTypeOf (TypeData td)
2508                 {
2509                         return "typeof(" + td.FullTypeName + ")";
2510                 }
2511
2512                 string GetTypeOf (Type td)
2513                 {
2514                         return "typeof(" + td.FullName + ")";
2515                 }
2516
2517                 string GetString (string str)
2518                 {
2519                         return "\"" + str + "\"";
2520                 }
2521
2522                 string GetLiteral (object ob)
2523                 {
2524                         if (ob == null) return "null";
2525                         if (ob is string) return "\"" + ob.ToString().Replace("\"","\"\"") + "\"";
2526                         if (ob is bool) return ((bool)ob) ? "true" : "false";
2527                         if (ob is XmlQualifiedName) {
2528                                 XmlQualifiedName qn = (XmlQualifiedName)ob;
2529                                 return "new XmlQualifiedName (" + GetLiteral(qn.Name) + "," + GetLiteral(qn.Namespace) + ")";
2530                         }
2531                         if (ob is Enum) return ob.GetType () + "." + ob;
2532                         return (ob is IFormattable) ? ((IFormattable) ob).ToString (null, CultureInfo.InvariantCulture) : ob.ToString ();
2533                 }
2534
2535                 void WriteLineInd (string code)
2536                 {
2537                         WriteLine (code);
2538                         _indent++;
2539                 }
2540
2541                 void WriteLineUni (string code)
2542                 {
2543                         if (_indent > 0) _indent--;
2544                         WriteLine (code);
2545                 }
2546
2547                 void WriteLine (string code)
2548                 {
2549                         if (code != "") _writer.Write (new String ('\t',_indent));
2550                         _writer.WriteLine (code);
2551                 }
2552
2553                 void WriteMultilineCode (string code)
2554                 {
2555                         string tabs = new string ('\t',_indent);
2556                         code = code.Replace ("\r","");
2557                         code = code.Replace ("\t","");
2558                         while (code.StartsWith ("\n")) code = code.Substring (1);
2559                         while (code.EndsWith ("\n")) code = code.Substring (0, code.Length - 1);
2560                         code = code.Replace ("\n", "\n" + tabs);
2561                         WriteLine (code);
2562                 }
2563
2564                 string Params (params string[] pars)
2565                 {
2566                         string res = "";
2567                         foreach (string p in pars)
2568                         {
2569                                 if (res != "") res += ", ";
2570                                 res += p;
2571                         }
2572                         return res;
2573                 }
2574
2575                 void WriteMetCall (string method, params string[] pars)
2576                 {
2577                         WriteLine (method + " (" + Params (pars) + ");");
2578                 }
2579
2580                 void Indent ()
2581                 {
2582                         _indent++;
2583                 }
2584
2585                 void Unindent ()
2586                 {
2587                         _indent--;
2588                 }
2589
2590                 #endregion
2591
2592         }
2593
2594         internal class GenerationResult
2595         {
2596                 public XmlMapping Mapping;
2597                 public string ReaderClassName;
2598                 public string ReadMethodName;
2599                 public string WriterClassName;
2600                 public string WriteMethodName;
2601                 public string Namespace;
2602                 public string SerializerClassName;
2603         }
2604
2605 }