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

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