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