mcs/class/referencesource/System.Xml/System/Xml/Schema/Inference/Infer.cs

   1 //------------------------------------------------------------------------------
   2 // <copyright file="Infer.cs" company="Microsoft">
   3 //     Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 // <owner current="true" primary="true">Microsoft</owner>
   6 // <owner current="false" primary="false">Microsoft</owner>
   7 //------------------------------------------------------------------------------
   8
   9 using System;
  10 using System.IO;
  11 using System.Xml;
  12 using System.Collections;
  13 using System.Diagnostics;
  14 using System.Globalization;
  15 using System.Security.Permissions;
  16
  17
  18
  19
  20 namespace System.Xml.Schema
  21
  22 {
  23         /// <include file='doc\Infer.uex' path='docs/doc[@for="Infer"]/*' />
  24         /// <summary>
  25         /// Infer class serves for infering XML Schema from given XML instance document.
  26         /// </summary>
  27         public sealed class XmlSchemaInference
  28         {
  29             internal static XmlQualifiedName ST_boolean = new XmlQualifiedName("boolean", XmlSchema.Namespace);
  30             internal static XmlQualifiedName ST_byte = new XmlQualifiedName("byte", XmlSchema.Namespace);
  31             internal static XmlQualifiedName ST_unsignedByte = new XmlQualifiedName("unsignedByte", XmlSchema.Namespace);
  32             internal static XmlQualifiedName ST_short = new XmlQualifiedName("short", XmlSchema.Namespace);
  33             internal static XmlQualifiedName ST_unsignedShort = new XmlQualifiedName("unsignedShort", XmlSchema.Namespace);
  34             internal static XmlQualifiedName ST_int = new XmlQualifiedName("int", XmlSchema.Namespace);
  35             internal static XmlQualifiedName ST_unsignedInt = new XmlQualifiedName("unsignedInt", XmlSchema.Namespace);
  36             internal static XmlQualifiedName ST_long = new XmlQualifiedName("long", XmlSchema.Namespace);
  37             internal static XmlQualifiedName ST_unsignedLong = new XmlQualifiedName("unsignedLong", XmlSchema.Namespace);
  38             internal static XmlQualifiedName ST_integer = new XmlQualifiedName("integer", XmlSchema.Namespace);
  39             internal static XmlQualifiedName ST_decimal = new XmlQualifiedName("decimal", XmlSchema.Namespace);
  40             internal static XmlQualifiedName ST_float = new XmlQualifiedName("float", XmlSchema.Namespace);
  41             internal static XmlQualifiedName ST_double = new XmlQualifiedName("double", XmlSchema.Namespace);
  42             internal static XmlQualifiedName ST_duration = new XmlQualifiedName("duration", XmlSchema.Namespace);
  43             internal static XmlQualifiedName ST_dateTime = new XmlQualifiedName("dateTime", XmlSchema.Namespace);
  44             internal static XmlQualifiedName ST_time = new XmlQualifiedName("time", XmlSchema.Namespace);
  45             internal static XmlQualifiedName ST_date = new XmlQualifiedName("date", XmlSchema.Namespace);
  46             internal static XmlQualifiedName ST_gYearMonth = new XmlQualifiedName("gYearMonth", XmlSchema.Namespace);
  47             internal static XmlQualifiedName ST_string = new XmlQualifiedName("string", XmlSchema.Namespace);
  48             internal static XmlQualifiedName ST_anySimpleType = new XmlQualifiedName("anySimpleType", XmlSchema.Namespace);
  49
  50             internal static XmlQualifiedName[] SimpleTypes =
  51             {
  52                 ST_boolean,
  53                 ST_byte,
  54                 ST_unsignedByte,
  55                 ST_short,
  56                 ST_unsignedShort,
  57                 ST_int,
  58                 ST_unsignedInt,
  59                 ST_long,
  60                 ST_unsignedLong,
  61                 ST_integer,
  62                 ST_decimal,
  63                 ST_float,
  64                 ST_double,
  65                 ST_duration,
  66                 ST_dateTime,
  67                 ST_time,
  68                 ST_date,
  69                 ST_gYearMonth,
  70                 ST_string
  71             };
  72
  73             internal const short HC_ST_boolean = 0;
  74             internal const short HC_ST_byte = 1;
  75             internal const short HC_ST_unsignedByte = 2;
  76             internal const short HC_ST_short = 3;
  77             internal const short HC_ST_unsignedShort = 4;
  78             internal const short HC_ST_int = 5;
  79             internal const short HC_ST_unsignedInt = 6;
  80             internal const short HC_ST_long = 7;
  81             internal const short HC_ST_unsignedLong = 8;
  82             internal const short HC_ST_integer = 9;
  83             internal const short HC_ST_decimal = 10;
  84             internal const short HC_ST_float = 11;
  85             internal const short HC_ST_double = 12;
  86             internal const short HC_ST_duration = 13;
  87             internal const short HC_ST_dateTime = 14;
  88             internal const short HC_ST_time = 15;
  89             internal const short HC_ST_date = 16;
  90             internal const short HC_ST_gYearMonth = 17;
  91             internal const short HC_ST_string = 18;
  92             internal const short HC_ST_Count = HC_ST_string +1;
  93
  94
  95             internal const int TF_boolean = 1<<HC_ST_boolean;
  96             internal const int TF_byte = 1<<HC_ST_byte;
  97             internal const int TF_unsignedByte = 1<<HC_ST_unsignedByte;
  98             internal const int TF_short = 1<<HC_ST_short;
  99             internal const int TF_unsignedShort = 1<<HC_ST_unsignedShort;
 100             internal const int TF_int = 1<<HC_ST_int;
 101             internal const int TF_unsignedInt = 1<<HC_ST_unsignedInt;
 102             internal const int TF_long = 1<<HC_ST_long;
 103             internal const int TF_unsignedLong = 1<<HC_ST_unsignedLong;
 104             internal const int TF_integer = 1<<HC_ST_integer;
 105             internal const int TF_decimal = 1<<HC_ST_decimal;
 106             internal const int TF_float = 1<<HC_ST_float;
 107             internal const int TF_double = 1<<HC_ST_double;
 108             internal const int TF_duration = 1<<HC_ST_duration;
 109             internal const int TF_dateTime = 1<<HC_ST_dateTime;
 110             internal const int TF_time = 1<<HC_ST_time;
 111             internal const int TF_date = 1<<HC_ST_date;
 112             internal const int TF_gYearMonth = 1<<HC_ST_gYearMonth;
 113             internal const int TF_string = 1<<HC_ST_string;
 114
 115             XmlSchema rootSchema = null; //(XmlSchema) xsc[TargetNamespace];
 116             private XmlSchemaSet schemaSet;
 117             private XmlReader xtr;
 118             private NameTable nametable;
 119             private string TargetNamespace;
 120             private XmlNamespaceManager NamespaceManager;
 121             //private Hashtable schemas;    //contains collection of schemas before they get added to the XmlSchemaSet xsc
 122             //private bool bRefine = false; //indicates if we are going to infer or refine schema when InferSchema is called
 123             ArrayList schemaList;
 124             InferenceOption occurrence = InferenceOption.Restricted;
 125             InferenceOption typeInference = InferenceOption.Restricted;
 126
 127           /*  internal struct ReplaceList
 128             {
 129                 internal XmlSchemaObjectCollection col;
 130                 internal int position;
 131
 132                 internal ReplaceList(XmlSchemaObjectCollection col, int position)
 133                 {
 134                     this.col = col;
 135                     this.position = position;
 136                 }
 137             }*/
 138
 139             /// <include file='doc\Infer.uex' path='docs/doc[@for="InferenceOption"]/*' />
 140             public enum InferenceOption
 141             {
 142                 /// <include file='doc\Infer.uex' path='docs/doc[@for="InferenceOption.Restricted"]/*' />
 143                 Restricted,
 144                 /// <include file='doc\Infer.uex' path='docs/doc[@for="InferenceOption.Relaxed"]/*' />
 145                 Relaxed
 146             };
 147
 148             /// <include file='doc\Infer.uex' path='docs/doc[@for="Infer.Occurrence"]/*' />
 149             public InferenceOption Occurrence
 150             {
 151                 set
 152                 {
 153                     this.occurrence = value;
 154                 }
 155                 get
 156                 {
 157                     return this.occurrence;
 158                 }
 159             }
 160
 161             /// <include file='doc\Infer.uex' path='docs/doc[@for="Infer.TypeInference"]/*' />
 162             public InferenceOption TypeInference
 163             {
 164                 set
 165                 {
 166                     this.typeInference = value;
 167                 }
 168                 get
 169                 {
 170                     return this.typeInference;
 171                 }
 172             }
 173
 174             /// <include file='doc\Infer.uex' path='docs/doc[@for="Infer.Infer"]/*' />
 175             public XmlSchemaInference()
 176             {
 177                 this.nametable = new NameTable();
 178                 this.NamespaceManager = new XmlNamespaceManager(nametable);
 179                 this.NamespaceManager.AddNamespace("xs", XmlSchema.Namespace);
 180                 this.schemaList = new ArrayList();
 181             }
 182
 183             /// <include file='doc\Infer.uex' path='docs/doc[@for="Infer.InferSchema"]/*' />
 184             public XmlSchemaSet InferSchema(XmlReader instanceDocument)
 185             {
 186                 return InferSchema1(instanceDocument, new XmlSchemaSet(nametable));
 187             }
 188
 189             /// <include file='doc\Infer.uex' path='docs/doc[@for="Infer.InferSchema1"]/*' />
 190             public XmlSchemaSet InferSchema(XmlReader instanceDocument, XmlSchemaSet schemas)
 191             {
 192                 if (schemas == null)
 193                 {
 194                     schemas = new XmlSchemaSet(nametable);
 195                 }
 196                 return InferSchema1(instanceDocument, schemas);
 197             }
 198             internal XmlSchemaSet InferSchema1(XmlReader instanceDocument, XmlSchemaSet schemas)
 199             {
 200                 if (instanceDocument == null)
 201                 {
 202                     throw new ArgumentNullException("instanceDocument");
 203                 }
 204                 this.rootSchema = null;
 205                 xtr = instanceDocument;
 206                 schemas.Compile();
 207                 this.schemaSet = schemas;
 208                 //schemas = new Hashtable();
 209                 //while(xtr.Read())
 210
 211                 while (xtr.NodeType != XmlNodeType.Element && xtr.Read()) ;
 212
 213
 214                 if (xtr.NodeType == XmlNodeType.Element)
 215                 {
 216                     //Create and process the root element
 217                     TargetNamespace = xtr.NamespaceURI;
 218                     if ( xtr.NamespaceURI == XmlSchema.Namespace)
 219                     {
 220                         throw new XmlSchemaInferenceException(Res.SchInf_schema, 0, 0);
 221                     }
 222                     XmlSchemaElement xse = null;
 223                     foreach (XmlSchemaElement elem in schemas.GlobalElements.Values)
 224                     {
 225                         if (elem.Name == xtr.LocalName && elem.QualifiedName.Namespace == xtr.NamespaceURI)
 226                         {
 227                             rootSchema = elem.Parent as XmlSchema;
 228                             xse = elem;
 229                             break;
 230                         }
 231                     }
 232
 233                     if (rootSchema == null)
 234                     {
 235                         //rootSchema = CreateXmlSchema(xtr.NamespaceURI);
 236                         xse = AddElement(xtr.LocalName, xtr.Prefix, xtr.NamespaceURI, null, null, -1);
 237                     }
 238                     else
 239                     {
 240                         //bRefine = true;
 241                         InferElement(xse, false, rootSchema);
 242                     }
 243
 244                   /*  foreach (ReplaceList listItem in schemaList)
 245                     {
 246                         if (listItem.position < listItem.col.Count)
 247                         {
 248                             XmlSchemaElement particle = listItem.col[listItem.position] as XmlSchemaElement;
 249                             if (particle != null && (particle.RefName.Namespace == XmlSchema.Namespace))
 250                             {
 251                                 XmlSchemaAny any = new XmlSchemaAny();
 252                                 if (particle.MaxOccurs != 1)
 253                                 {
 254                                     any.MaxOccurs = particle.MaxOccurs;
 255                                 }
 256                                 if (particle.MinOccurs != 1)
 257                                 {
 258                                     any.MinOccurs = particle.MinOccurs;
 259                                 }
 260                                 any.ProcessContents = XmlSchemaContentProcessing.Skip;
 261                                 any.MinOccurs = decimal.Zero;
 262                                 any.Namespace = particle.RefName.Namespace;
 263                                 listItem.col[listItem.position] = any;
 264                             }
 265                         }
 266                     }*/
 267                     foreach(String prefix in this.NamespaceManager)
 268                     {
 269                         if (!prefix.Equals("xml") && !prefix.Equals("xmlns"))
 270                         {
 271                             String ns = this.NamespaceManager.LookupNamespace(this.nametable.Get(prefix));
 272                             if (ns.Length != 0) { //Do not add xmlns=""
 273                                 rootSchema.Namespaces.Add(prefix, ns);
 274                             }
 275                         }
 276                     }
 277                     Debug.Assert(this.rootSchema != null, "rootSchema is null");
 278                     schemas.Reprocess(rootSchema);
 279                     schemas.Compile();
 280                     //break;
 281                 }
 282                 else
 283                 {
 284                     throw new XmlSchemaInferenceException(Res.SchInf_NoElement, 0, 0);
 285                 }
 286                 return schemas;
 287             }
 288
 289             private XmlSchemaAttribute AddAttribute(string localName, string prefix, string childURI, string attrValue, bool bCreatingNewType, XmlSchema parentSchema, XmlSchemaObjectCollection addLocation, XmlSchemaObjectTable compiledAttributes)
 290             {
 291                 if (childURI == XmlSchema.Namespace)
 292                 {
 293                     throw new XmlSchemaInferenceException(Res.SchInf_schema, 0, 0);
 294                 }
 295
 296                 XmlSchemaAttribute xsa = null;
 297                 int AttributeType = -1;
 298                 XmlSchemaAttribute returnedAttribute = null;    //this value will change to attributeReference if childURI!= parentURI
 299                 XmlSchema xs = null;
 300                 bool add = true;
 301
 302                 Debug.Assert(compiledAttributes != null); //AttributeUses is never null
 303                 // First we need to look into the already compiled attributes
 304                 //   (they come from the schemaset which we got on input)
 305                 // If there are none or we don't find it there, then we must search the list of attributes
 306                 //   where we are going to add a new one (if it doesn't exist).
 307                 //   This is necessary to avoid adding duplicate attribute declarations.
 308                 ICollection searchCollectionPrimary, searchCollectionSecondary;
 309                 if (compiledAttributes.Count > 0) {
 310                     searchCollectionPrimary = compiledAttributes.Values;
 311                     searchCollectionSecondary = addLocation;
 312                 }
 313                 else {
 314                     searchCollectionPrimary = addLocation;
 315                     searchCollectionSecondary = null;
 316                 }
 317                 if (childURI == XmlReservedNs.NsXml)
 318                 {
 319                     XmlSchemaAttribute attributeReference = null;
 320                     //see if the reference exists
 321                     attributeReference = FindAttributeRef(searchCollectionPrimary, localName, childURI);
 322                     if (attributeReference == null && searchCollectionSecondary != null) {
 323                         attributeReference = FindAttributeRef(searchCollectionSecondary, localName, childURI);
 324                     }
 325                     if (attributeReference == null)
 326                     {
 327                         attributeReference = new XmlSchemaAttribute();
 328                         attributeReference.RefName = new XmlQualifiedName(localName, childURI);
 329                         if (bCreatingNewType && this.Occurrence == InferenceOption.Restricted)
 330                         {
 331                             attributeReference.Use = XmlSchemaUse.Required;
 332                         }
 333                         else
 334                         {
 335                             attributeReference.Use = XmlSchemaUse.Optional;
 336                         }
 337
 338                         addLocation.Add(attributeReference);
 339                     }
 340                     returnedAttribute = attributeReference;
 341                 }
 342                 else
 343                 {
 344                     if (childURI.Length == 0)
 345                     {
 346                         xs = parentSchema;
 347                         add = false;
 348                     }
 349                     else if (childURI != null && !schemaSet.Contains(childURI))
 350                     {
 351                         /*if (parentSchema.AttributeFormDefault = XmlSchemaForm.Unqualified && childURI.Length == 0)
 352                     {
 353                         xs = parentSchema;
 354                         add = false;
 355                         break;
 356                     }*/
 357                         xs = new XmlSchema();
 358                         xs.AttributeFormDefault = XmlSchemaForm.Unqualified;
 359                         xs.ElementFormDefault = XmlSchemaForm.Qualified;
 360                         if (childURI.Length != 0)
 361                             xs.TargetNamespace = childURI;
 362                         //schemas.Add(childURI, xs);
 363                         this.schemaSet.Add(xs);
 364                         if (prefix.Length != 0 && String.Compare(prefix, "xml", StringComparison.OrdinalIgnoreCase) != 0)
 365                             NamespaceManager.AddNamespace(prefix, childURI);
 366                     }
 367                     else
 368                     {
 369                         ArrayList col = this.schemaSet.Schemas(childURI) as ArrayList;
 370                         if (col != null && col.Count > 0)
 371                         {
 372                             xs = col[0] as XmlSchema;
 373                         }
 374
 375                     }
 376                     if (childURI.Length != 0) //
 377                     {
 378                         XmlSchemaAttribute attributeReference = null;
 379                         //see if the reference exists
 380                         attributeReference = FindAttributeRef(searchCollectionPrimary, localName, childURI);
 381                         if (attributeReference == null & searchCollectionSecondary != null) {
 382                             attributeReference = FindAttributeRef(searchCollectionSecondary, localName, childURI);
 383                         }
 384                         if (attributeReference == null)
 385                         {
 386                             attributeReference = new XmlSchemaAttribute();
 387                             attributeReference.RefName = new XmlQualifiedName(localName, childURI);
 388                             if (bCreatingNewType && this.Occurrence == InferenceOption.Restricted)
 389                             {
 390                                 attributeReference.Use = XmlSchemaUse.Required;
 391                             }
 392                             else
 393                             {
 394                                 attributeReference.Use = XmlSchemaUse.Optional;
 395                             }
 396
 397                             addLocation.Add(attributeReference);
 398                         }
 399                         returnedAttribute = attributeReference;
 400
 401                         //see if the attribute exists on the global level
 402                         xsa = FindAttribute(xs.Items, localName);
 403                         if (xsa == null)
 404                         {
 405                             xsa = new XmlSchemaAttribute();
 406                             xsa.Name = localName;
 407                             xsa.SchemaTypeName = RefineSimpleType(attrValue, ref AttributeType);
 408                             xsa.LineNumber = AttributeType; //we use LineNumber to store flags of valid types
 409                             xs.Items.Add(xsa);
 410
 411                         }
 412                         else
 413                         {
 414                             if (xsa.Parent == null)
 415                             {
 416                                 AttributeType = xsa.LineNumber; // we use LineNumber to store flags of valid types
 417                             }
 418                             else
 419                             {
 420                                 AttributeType = GetSchemaType(xsa.SchemaTypeName);
 421                                 xsa.Parent = null;
 422                             }
 423                             xsa.SchemaTypeName = RefineSimpleType(attrValue, ref AttributeType);
 424                             xsa.LineNumber = AttributeType; // we use LineNumber to store flags of valid types
 425                         }
 426                     }
 427                     else
 428                     {
 429                         xsa = FindAttribute(searchCollectionPrimary, localName);
 430                         if (xsa == null && searchCollectionSecondary != null) {
 431                             xsa = FindAttribute(searchCollectionSecondary, localName);
 432                         }
 433                         if (xsa == null)
 434                         {
 435                             xsa = new XmlSchemaAttribute();
 436                             xsa.Name = localName;
 437                             xsa.SchemaTypeName = RefineSimpleType(attrValue, ref AttributeType);
 438                             xsa.LineNumber = AttributeType; // we use LineNumber to store flags of valid types
 439                             if (bCreatingNewType && this.Occurrence == InferenceOption.Restricted)
 440                                 xsa.Use = XmlSchemaUse.Required;
 441                             else
 442                                 xsa.Use = XmlSchemaUse.Optional;
 443                             addLocation.Add(xsa);
 444                             if (xs.AttributeFormDefault != XmlSchemaForm.Unqualified)
 445                             {
 446                                 xsa.Form = XmlSchemaForm.Unqualified;
 447                             }
 448                         }
 449                         else
 450                         {
 451                             if (xsa.Parent == null)
 452                             {
 453                                 AttributeType = xsa.LineNumber; // we use LineNumber to store flags of valid types
 454                             }
 455                             else
 456                             {
 457                                 AttributeType = GetSchemaType(xsa.SchemaTypeName);
 458                                 xsa.Parent = null;
 459                             }
 460                             xsa.SchemaTypeName = RefineSimpleType(attrValue, ref AttributeType);
 461                             xsa.LineNumber = AttributeType; // we use LineNumber to store flags of valid types
 462                         }
 463                         returnedAttribute = xsa;
 464                     }
 465                 }
 466                 string nullString = null;
 467                 if (add && childURI != parentSchema.TargetNamespace)
 468                 {
 469                     for (int i = 0; i < parentSchema.Includes.Count; ++i)
 470                     {
 471                         XmlSchemaImport import = parentSchema.Includes[i] as XmlSchemaImport;
 472                         if (import == null)
 473                         {
 474                             continue;
 475                         }
 476                         if (import.Namespace == childURI)
 477                         {
 478                             add = false;
 479                         }
 480                     }
 481                     if (add)
 482                     {
 483                         XmlSchemaImport import = new XmlSchemaImport();
 484                         import.Schema = xs;
 485                         if (childURI.Length != 0)
 486                         {
 487                             nullString = childURI;
 488                         }
 489                         import.Namespace = nullString;
 490                         parentSchema.Includes.Add(import);
 491                     }
 492                 }
 493
 494
 495                 return returnedAttribute;
 496             }
 497
 498             private XmlSchema CreateXmlSchema(string targetNS)
 499             {
 500                 Debug.Assert(targetNS == null || targetNS.Length > 0 , "targetns for schema is empty");
 501                 XmlSchema xs = new XmlSchema();
 502                 xs.AttributeFormDefault = XmlSchemaForm.Unqualified;
 503                 xs.ElementFormDefault = XmlSchemaForm.Qualified;
 504                 xs.TargetNamespace = targetNS;
 505                 this.schemaSet.Add(xs);
 506                 return xs;
 507             }
 508
 509             private XmlSchemaElement AddElement(string localName, string prefix, string childURI, XmlSchema parentSchema, XmlSchemaObjectCollection addLocation, int positionWithinCollection)
 510             {
 511                 if (childURI == XmlSchema.Namespace)
 512                 {
 513                     throw new XmlSchemaInferenceException(Res.SchInf_schema, 0, 0);
 514                 }
 515
 516                 XmlSchemaElement xse = null;
 517                 XmlSchemaElement returnedElement = xse; //this value will change to elementReference if childURI!= parentURI
 518                 XmlSchema xs = null;
 519                 bool bCreatingNewType = true;
 520                 if (childURI == String.Empty)
 521                 {
 522                     childURI = null;
 523                 }
 524                 // The new element belongs to the same ns as parent and addlocation is not null
 525                 if (parentSchema != null && childURI == parentSchema.TargetNamespace)
 526                 {
 527                     xse = new XmlSchemaElement();
 528                     xse.Name = localName;
 529                     xs = parentSchema;
 530                     if (xs.ElementFormDefault != XmlSchemaForm.Qualified && addLocation != null)
 531                     {
 532                         xse.Form = XmlSchemaForm.Qualified;
 533                     }
 534                 }
 535                 else if (schemaSet.Contains(childURI))
 536                 {
 537                     xse = this.FindGlobalElement(childURI, localName, out xs);
 538                     if (xse == null)
 539                     {
 540                         ArrayList col = this.schemaSet.Schemas(childURI)as ArrayList;
 541                         if (col != null && col.Count > 0 )
 542                         {
 543                             xs = col[0] as XmlSchema;
 544                         }
 545                         xse = new XmlSchemaElement();
 546                         xse.Name = localName;
 547                         xs.Items.Add(xse);
 548                     }
 549                     else
 550                         bCreatingNewType = false;
 551
 552                 }
 553                 else
 554                 {
 555                     xs = CreateXmlSchema(childURI);
 556                     if (prefix.Length!=0)
 557                         NamespaceManager.AddNamespace(prefix, childURI);
 558                     xse=new XmlSchemaElement();
 559                     xse.Name = localName;
 560                     xs.Items.Add(xse);  //add global element declaration only when creating new schema
 561                 }
 562                 if (parentSchema == null)
 563                 {
 564                     parentSchema = xs;
 565                     this.rootSchema = parentSchema;
 566                 }
 567
 568                 if (childURI != parentSchema.TargetNamespace )
 569                 {
 570                     bool add = true;
 571
 572                     for (int i = 0; i < parentSchema.Includes.Count; ++i)
 573                     {
 574                         XmlSchemaImport import = parentSchema.Includes[i] as XmlSchemaImport;
 575                         if (import == null)
 576                         {
 577                             continue;
 578                         }
 579                         //Debug.WriteLine(import.Schema.TargetNamespace);
 580
 581                         if (import.Namespace == childURI)
 582                         {
 583                             add = false;
 584                         }
 585                     }
 586                     if (add)
 587                     {
 588                         XmlSchemaImport import = new XmlSchemaImport();
 589                         import.Schema = xs;
 590                         import.Namespace = childURI;
 591                         parentSchema.Includes.Add(import);
 592                     }
 593                 }
 594                 returnedElement = xse;
 595                 if (addLocation != null)
 596                 {
 597                     if (childURI == parentSchema.TargetNamespace )
 598                     {
 599                         if (this.Occurrence == InferenceOption.Relaxed /*&& parentSchema.Items != addLocation*/)
 600                         {
 601                             xse.MinOccurs = 0;
 602                         }
 603                         if (positionWithinCollection == -1)
 604                         {
 605                             positionWithinCollection = addLocation.Add(xse);
 606                         }
 607                         else
 608                         {
 609                             addLocation.Insert(positionWithinCollection, xse);
 610                         }
 611                     }
 612                     else
 613                     {
 614                         XmlSchemaElement elementReference = new XmlSchemaElement();
 615                         elementReference.RefName = new XmlQualifiedName(localName, childURI);
 616                         if (this.Occurrence == InferenceOption.Relaxed)
 617                         {
 618                             elementReference.MinOccurs = 0;
 619                         }
 620                         if (positionWithinCollection == -1)
 621                         {
 622                             positionWithinCollection = addLocation.Add(elementReference);
 623                         }
 624                         else
 625                         {
 626                             addLocation.Insert(positionWithinCollection, elementReference);
 627                         }
 628                         returnedElement = elementReference;
 629                        /* if (childURI == XmlSchema.Namespace)
 630                         {
 631                             schemaList.Add(new ReplaceList(addLocation, positionWithinCollection));
 632                         }*/
 633                     }
 634                 }
 635
 636
 637                 InferElement(xse, bCreatingNewType, xs);
 638
 639                 return returnedElement;
 640             }
 641
 642             /// <summary>
 643             /// Sets type of the xse based on the currently read element.
 644             /// If the type is already set, verifies that it matches the instance and if not, updates the type to validate the instance.
 645             /// </summary>
 646             /// <param name="xse">XmlSchemaElement corresponding to the element just read by the xtr XmlTextReader</param>
 647             /// <param name="bCreatingNewType">true if the type is newly created, false if the type already existed and matches the current element name</param>
 648             /// <param name="nsContext">namespaceURI of the parent element. Used to distinguish if ref= should be used when parent is in different ns than child.</param>
 649             internal void InferElement(XmlSchemaElement xse, bool bCreatingNewType, XmlSchema parentSchema)
 650             {
 651
 652                 bool bEmptyElement = xtr.IsEmptyElement;
 653                 int lastUsedSeqItem = -1;
 654
 655                 Hashtable table = new Hashtable();
 656                 XmlSchemaType schemaType = GetEffectiveSchemaType(xse, bCreatingNewType);
 657                 XmlSchemaComplexType ct = schemaType as XmlSchemaComplexType;
 658
 659                 //infer type based on content of the current element
 660                 if (xtr.MoveToFirstAttribute())
 661                 {
 662                     ProcessAttributes(ref xse, schemaType, bCreatingNewType, parentSchema);
 663                 }
 664                 else
 665                 {
 666                     if (!bCreatingNewType && ct != null)
 667                     {   //if type already exists and can potentially have attributes
 668                         MakeExistingAttributesOptional(ct, null);
 669                     }
 670                 }
 671                 if (ct == null || ct == XmlSchemaComplexType.AnyType) { //It was null or simple type, after processing attributes, this might have been set
 672                     ct = xse.SchemaType as XmlSchemaComplexType;
 673                 }
 674                 //xse's type is set either to complex type if attributes exist or null
 675                 if (bEmptyElement)  //<element attr="3232" />
 676                 {
 677                     if (!bCreatingNewType)
 678                     {
 679                         if (null != ct)
 680                         {
 681                             if (null!= ct.Particle )
 682
 683                             {
 684                                 ct.Particle.MinOccurs = 0;
 685                             }
 686                             else if (null != ct.ContentModel)
 687                             {
 688                                 XmlSchemaSimpleContentExtension sce = CheckSimpleContentExtension(ct);
 689                                 sce.BaseTypeName = ST_string;
 690                                 sce.LineNumber = TF_string;
 691                             }
 692                         }
 693                         else if (!xse.SchemaTypeName.IsEmpty)
 694                         {
 695                             xse.LineNumber = TF_string;
 696                             xse.SchemaTypeName = ST_string;
 697                         }
 698                     }
 699                     else
 700                     {
 701                         xse.LineNumber = TF_string;
 702                         //xse.SchemaTypeName = ST_string; //My change
 703                     }
 704                     return; //We are done processing this element - all attributes are already added
 705                 }
 706                 bool bWhiteSpace = false;
 707                 do
 708                 {
 709                     xtr.Read();
 710                     if (xtr.NodeType == XmlNodeType.Whitespace)
 711                     {
 712                         bWhiteSpace = true;
 713                     }
 714                     if (xtr.NodeType == XmlNodeType.EntityReference)
 715                     {
 716                         throw new XmlSchemaInferenceException(Res.SchInf_entity, 0, 0);
 717                     }
 718                 } while( (!xtr.EOF) && (xtr.NodeType != XmlNodeType.EndElement) && (xtr.NodeType != XmlNodeType.CDATA)&&(xtr.NodeType != XmlNodeType.Element)&&(xtr.NodeType != XmlNodeType.Text) );
 719
 720                 if (xtr.NodeType == XmlNodeType.EndElement)
 721                 {
 722                     if (bWhiteSpace) {
 723                         if (ct != null)
 724                         {
 725                             if (null != ct.ContentModel)
 726                             {
 727                                 XmlSchemaSimpleContentExtension sce = CheckSimpleContentExtension(ct);
 728                                 sce.BaseTypeName = ST_string;
 729                                 sce.LineNumber = TF_string;
 730                             }
 731                             else if (bCreatingNewType)
 732                             {
 733                                 //attributes exist, but both Particle and ContentModel == null - this must be complex type with simpleContent extension
 734                                 XmlSchemaSimpleContent sc = new XmlSchemaSimpleContent();
 735                                 ct.ContentModel = sc;
 736                                 XmlSchemaSimpleContentExtension sce = new XmlSchemaSimpleContentExtension();
 737                                 sc.Content = sce;
 738
 739                                 MoveAttributes(ct, sce, bCreatingNewType);
 740
 741                                 sce.BaseTypeName = ST_string;
 742                                 sce.LineNumber = TF_string;
 743                             }
 744                             else
 745                                 ct.IsMixed = true;
 746                         }
 747                         else
 748                         {
 749                             xse.SchemaTypeName = ST_string;
 750                             xse.LineNumber = TF_string;
 751                         }
 752                     }
 753                     if (bCreatingNewType)
 754                     {
 755                         xse.LineNumber = TF_string;
 756                         //xse.SchemaTypeName = ST_string; //my change
 757                     }
 758                     else
 759                     {
 760                         if (null != ct)
 761                         {
 762                             if (null!= ct.Particle)
 763                             {
 764                                 ct.Particle.MinOccurs = 0;
 765                             }
 766                             else if (null != ct.ContentModel)
 767                             {
 768                                 XmlSchemaSimpleContentExtension sce = CheckSimpleContentExtension(ct);
 769                                 sce.BaseTypeName = ST_string;
 770                                 sce.LineNumber = TF_string;
 771                             }
 772                         }
 773                         else if (!xse.SchemaTypeName.IsEmpty)
 774                         {
 775                             xse.LineNumber = TF_string;
 776                             xse.SchemaTypeName = ST_string;
 777                         }
 778                     }
 779
 780                     return; //<element attr="232"></element>
 781                 }
 782                 int iChildNumber = 0;
 783                 bool bCreatingNewSequence = false;
 784                 while (!xtr.EOF && (xtr.NodeType != XmlNodeType.EndElement))
 785                 {
 786                     bool bNextNodeAlreadyRead = false;  //In some cases we have to look ahead one node. If true means that we did look ahead.
 787                     iChildNumber++;
 788                     if ((xtr.NodeType == XmlNodeType.Text) || (xtr.NodeType == XmlNodeType.CDATA) ) //node can be simple type, complex with simple content or complex with mixed content
 789                     {
 790                         if (null != ct)
 791                         {
 792                             if (null != ct.Particle)
 793                             {
 794                                 ct.IsMixed = true;
 795                                 if (iChildNumber==1)
 796                                 {
 797                                     //if this is the only child and other elements do not follow, we must set particle minOccurs="0"
 798                                     do{ xtr.Read();} while( (!xtr.EOF) && ((xtr.NodeType == XmlNodeType.CDATA)||(xtr.NodeType == XmlNodeType.Text) ||  (xtr.NodeType == XmlNodeType.Comment) || (xtr.NodeType == XmlNodeType.ProcessingInstruction) || (xtr.NodeType == XmlNodeType.Whitespace) || (xtr.NodeType == XmlNodeType.SignificantWhitespace) || (xtr.NodeType == XmlNodeType.XmlDeclaration)));
 799                                     bNextNodeAlreadyRead = true;
 800                                     if (xtr.NodeType == XmlNodeType.EndElement)
 801                                         ct.Particle.MinOccurs=decimal.Zero;
 802                                 }
 803                             }
 804                             else if (null!=ct.ContentModel)
 805                             {   //complexType with simpleContent
 806                                 XmlSchemaSimpleContentExtension sce = CheckSimpleContentExtension(ct);
 807                                 if ((xtr.NodeType == XmlNodeType.Text) && (iChildNumber==1))
 808                                 {
 809                                     int SimpleType = -1;
 810                                     if (xse.Parent == null)
 811                                     {
 812                                         SimpleType = sce.LineNumber; // we use LineNumber to represent valid type flags
 813                                     }
 814                                     else
 815                                     {
 816                                         SimpleType = GetSchemaType(sce.BaseTypeName);
 817                                         xse.Parent = null;
 818                                     }
 819                                     sce.BaseTypeName = RefineSimpleType(xtr.Value, ref SimpleType);
 820                                     sce.LineNumber = SimpleType; // we use LineNumber to represent valid type flags
 821                                 }
 822                                 else
 823                                 {
 824                                     sce.BaseTypeName = ST_string;
 825                                     sce.LineNumber = TF_string;
 826                                 }
 827                             }
 828                             else
 829                             {
 830                                 //attributes exist, but both Particle and ContentModel == null - this must be complex type with simpleContent extension
 831                                 XmlSchemaSimpleContent sc = new XmlSchemaSimpleContent();
 832                                 ct.ContentModel = sc;
 833                                 XmlSchemaSimpleContentExtension sce = new XmlSchemaSimpleContentExtension();
 834                                 sc.Content = sce;
 835
 836                                 MoveAttributes(ct, sce, bCreatingNewType);
 837
 838                                 if (xtr.NodeType == XmlNodeType.Text)
 839                                 {
 840                                     int TypeFlags;
 841                                     if(!bCreatingNewType)
 842                                         //previously this was empty element
 843                                         TypeFlags=TF_string;
 844                                     else
 845                                         TypeFlags = -1;
 846                                     sce.BaseTypeName = RefineSimpleType(xtr.Value, ref TypeFlags);
 847                                     sce.LineNumber = TypeFlags; // we use LineNumber to store flags of valid types
 848                                 }
 849                                 else
 850                                 {
 851                                     sce.BaseTypeName = ST_string;
 852                                     sce.LineNumber = TF_string;
 853                                 }
 854
 855                             }
 856                         }
 857                         else
 858                         {   //node is currently empty or with SimpleType
 859                             //node will become simple type
 860                             if (iChildNumber>1)
 861                             {
 862                                 //more than one consecutive text nodes probably with PI in between
 863                                 xse.SchemaTypeName = ST_string;
 864                                 xse.LineNumber = TF_string;// we use LineNumber to store flags of valid types
 865                             }
 866                             else
 867                             {
 868                                 int TypeFlags = -1;
 869                                 if (bCreatingNewType)
 870                                     if (xtr.NodeType == XmlNodeType.Text)
 871                                     {
 872                                         xse.SchemaTypeName = RefineSimpleType(xtr.Value, ref TypeFlags);
 873                                         xse.LineNumber = TypeFlags; // we use LineNumber to store flags of valid types
 874                                     }
 875                                     else
 876                                     {
 877                                         xse.SchemaTypeName = ST_string;
 878                                         xse.LineNumber = TF_string;// we use LineNumber to store flags of valid types
 879                                     }
 880                                 else if (xtr.NodeType == XmlNodeType.Text)
 881                                 {
 882                                     if (xse.Parent == null)
 883                                     {
 884                                         TypeFlags = xse.LineNumber;
 885                                     }
 886                                     else
 887                                     {
 888                                         TypeFlags = GetSchemaType(xse.SchemaTypeName);
 889                                         if (TypeFlags == -1 && xse.LineNumber == TF_string) { //Since schemaTypeName is not set for empty elements (<e></e>)
 890                                             TypeFlags = TF_string;
 891                                         }
 892                                         xse.Parent = null;
 893                                     }
 894                                     xse.SchemaTypeName = RefineSimpleType(xtr.Value, ref TypeFlags);    //simple type
 895                                     xse.LineNumber = TypeFlags; // we use LineNumber to store flags of valid types
 896                                 }
 897                                 else
 898                                 {
 899                                     xse.SchemaTypeName = ST_string;
 900                                     xse.LineNumber = TF_string;// we use LineNumber to store flags of valid types
 901                                 }
 902                             }
 903                         }
 904                     }
 905                     else if (xtr.NodeType == XmlNodeType.Element)
 906                     {
 907                         XmlQualifiedName qname = new XmlQualifiedName(xtr.LocalName, xtr.NamespaceURI);
 908                         bool Maxoccursflag = false;
 909                         if (table.Contains(qname))
 910                         {
 911                             Maxoccursflag = true;
 912                         }
 913                         else
 914                         {
 915                             table.Add(qname, null);
 916                         }
 917                         if (ct==null)
 918                         { //untill now the element was empty or SimpleType - it now becomes complex type
 919                             ct = new XmlSchemaComplexType();
 920                             xse.SchemaType = ct;
 921                             if (!xse.SchemaTypeName.IsEmpty) //
 922                             {
 923                                 ct.IsMixed=true;
 924                                 xse.SchemaTypeName = XmlQualifiedName.Empty;
 925                             }
 926                         }
 927                         if (ct.ContentModel !=null)
 928                         {   //type was previously identified as simple content extension - we need to convert it to sequence
 929                             XmlSchemaSimpleContentExtension sce = CheckSimpleContentExtension(ct);
 930                             MoveAttributes(sce, ct);
 931                             ct.ContentModel = null;
 932                             ct.IsMixed = true;
 933                             if (ct.Particle != null)
 934                                 throw new XmlSchemaInferenceException(Res.SchInf_particle, 0, 0);
 935                             ct.Particle = new XmlSchemaSequence();
 936                             bCreatingNewSequence = true;
 937                             XmlSchemaElement subelement = AddElement(xtr.LocalName, xtr.Prefix, xtr.NamespaceURI, parentSchema,((XmlSchemaSequence)ct.Particle).Items, -1);
 938                             lastUsedSeqItem = 0;
 939                             if (!bCreatingNewType)
 940                                 ct.Particle.MinOccurs=0;    //previously this was simple type so subelements did not exist
 941                         }
 942                         else if (ct.Particle == null)
 943                         {
 944                             ct.Particle = new XmlSchemaSequence();
 945                             bCreatingNewSequence = true;
 946                             XmlSchemaElement subelement = AddElement(xtr.LocalName, xtr.Prefix, xtr.NamespaceURI, parentSchema,((XmlSchemaSequence)ct.Particle).Items, -1);
 947                             if (!bCreatingNewType)
 948                             {
 949                                 ((XmlSchemaSequence)ct.Particle).MinOccurs = decimal.Zero;
 950                                 //  subelement.MinOccurs = decimal.Zero;
 951                             }
 952
 953                             lastUsedSeqItem = 0;
 954                         }
 955                         else
 956                         {
 957                             bool bParticleChanged = false;
 958                             XmlSchemaElement subelement = FindMatchingElement(bCreatingNewType || bCreatingNewSequence, xtr, ct, ref lastUsedSeqItem, ref bParticleChanged, parentSchema, Maxoccursflag);
 959                         }
 960                     }
 961                     else if (xtr.NodeType == XmlNodeType.Text)
 962                     {
 963                         if (ct==null)
 964                             throw new XmlSchemaInferenceException(Res.SchInf_ct, 0, 0);
 965                         ct.IsMixed = true;
 966                     }
 967                     do
 968                     {
 969                         if (xtr.NodeType == XmlNodeType.EntityReference)
 970                         {
 971                             throw new XmlSchemaInferenceException(Res.SchInf_entity, 0, 0);
 972
 973                         }
 974                         if (!bNextNodeAlreadyRead)
 975                         {
 976                             xtr.Read();
 977                         }
 978                         else
 979                         {
 980                             bNextNodeAlreadyRead = false;
 981                         }
 982                     } while( (!xtr.EOF) && (xtr.NodeType != XmlNodeType.EndElement) && (xtr.NodeType != XmlNodeType.CDATA)&&(xtr.NodeType != XmlNodeType.Element)&&(xtr.NodeType != XmlNodeType.Text));
 983                 }
 984                 if (lastUsedSeqItem != -1)
 985                 {
 986                     //Verify if all elements in a sequence exist, if not set MinOccurs=0
 987                     while (++lastUsedSeqItem < ((XmlSchemaSequence)ct.Particle).Items.Count)
 988                     {
 989                         if (((XmlSchemaSequence)ct.Particle).Items[lastUsedSeqItem].GetType() != typeof (XmlSchemaElement))
 990                             throw new XmlSchemaInferenceException(Res.SchInf_seq, 0 , 0);
 991                         XmlSchemaElement subElement = (XmlSchemaElement) ((XmlSchemaSequence)ct.Particle).Items[lastUsedSeqItem];
 992                         subElement.MinOccurs = 0;
 993                     }
 994                 }
 995
 996             }
 997
 998             private XmlSchemaSimpleContentExtension CheckSimpleContentExtension(XmlSchemaComplexType ct) {
 999                 XmlSchemaSimpleContent sc = ct.ContentModel as XmlSchemaSimpleContent;
1000                 if (sc == null) {
1001                     throw new XmlSchemaInferenceException(Res.SchInf_simplecontent, 0, 0);
1002                 }
1003                 XmlSchemaSimpleContentExtension sce = sc.Content as XmlSchemaSimpleContentExtension;
1004                 if (sce == null) {
1005                     throw new XmlSchemaInferenceException(Res.SchInf_extension, 0, 0);
1006                 }
1007                 return sce;
1008             }
1009
1010             private XmlSchemaType GetEffectiveSchemaType(XmlSchemaElement elem, bool bCreatingNewType) {
1011                 XmlSchemaType effectiveSchemaType = null;
1012                 if (!bCreatingNewType && elem.ElementSchemaType != null) {
1013                     effectiveSchemaType = elem.ElementSchemaType;
1014                 }
1015                 else { //creating new type, hence look up pre-compiled info
1016                     Debug.Assert(elem.ElementDecl == null);
1017                     if (elem.SchemaType != null) {
1018                         effectiveSchemaType = elem.SchemaType;
1019                     }
1020                     else if (elem.SchemaTypeName != XmlQualifiedName.Empty) {
1021                         effectiveSchemaType = schemaSet.GlobalTypes[elem.SchemaTypeName] as XmlSchemaType;
1022                         if (effectiveSchemaType == null) {
1023                             effectiveSchemaType = XmlSchemaType.GetBuiltInSimpleType(elem.SchemaTypeName);
1024                         }
1025                         if (effectiveSchemaType == null) {
1026                             effectiveSchemaType = XmlSchemaType.GetBuiltInComplexType(elem.SchemaTypeName);
1027                         }
1028                     }
1029                 }
1030                 return effectiveSchemaType;
1031             }
1032             /// <summary>
1033             /// Verifies that the current element has its corresponding element in the sequence and order is the same.
1034             /// If the order is not the same, it changes the particle from Sequence to Sequence with Choice.
1035             /// If there is more elements of the same kind in the sequence, sets maxOccurs to unbounded
1036             /// </summary>
1037             /// <param name="bCreatingNewType">True if this is a new type. This is important for setting minOccurs=0 for elements that did not exist in a particle.</param>
1038             /// <param name="xtr">text reader positioned to the current element</param>
1039             /// <param name="ct">complex type with Sequence or Choice Particle</param>
1040             /// <param name="lastUsedSeqItem">ordinal number in the sequence to indicate current sequence position</param>
1041             /// <param name="itemsMadeOptional">hashtable of elements with minOccurs changed to 0 in order to satisfy sequence requirements. These elements will be rolled back if Sequence becomes Sequence of Choice.</param>
1042             /// <param name="bParticleChanged">This indicates to the caller if Sequence was changed to Choice</param>
1043             internal XmlSchemaElement FindMatchingElement(bool bCreatingNewType, XmlReader xtr,XmlSchemaComplexType ct, ref int lastUsedSeqItem, ref bool bParticleChanged, XmlSchema parentSchema, bool setMaxoccurs)
1044             {
1045                 if (xtr.NamespaceURI == XmlSchema.Namespace)
1046                 {
1047                     throw new XmlSchemaInferenceException(Res.SchInf_schema, 0, 0);
1048                 }
1049
1050                 bool bItemNotUsedYet = ((lastUsedSeqItem == -1)? true: false);
1051                 XmlSchemaObjectCollection minOccursCandidates = new XmlSchemaObjectCollection(); //elements that are skipped in the sequence and need minOccurs modified.
1052                 if (ct.Particle.GetType() == typeof (XmlSchemaSequence))
1053                 {
1054                     string childURI = xtr.NamespaceURI;
1055                     if (childURI.Length == 0)
1056                     {
1057                         childURI = null;
1058                     }
1059                     XmlSchemaSequence xss = (XmlSchemaSequence) ct.Particle;
1060                     if (xss.Items.Count < 1 && !bCreatingNewType)
1061                     {
1062                         lastUsedSeqItem = 0;
1063                         XmlSchemaElement e = AddElement(xtr.LocalName, xtr.Prefix, xtr.NamespaceURI, parentSchema, xss.Items,-1);
1064                         e.MinOccurs = 0;
1065                         return e;
1066                     }
1067                     if (xss.Items[0].GetType() == typeof (XmlSchemaChoice))
1068                     {   // <sequence minOccurs="0" maxOccurs="unbounded"><choice><element>...</choice></sequence>
1069                         XmlSchemaChoice xsch = (XmlSchemaChoice) xss.Items[0];
1070                         for (int i = 0; i < xsch.Items.Count; ++i)
1071                         {
1072                             XmlSchemaElement el = xsch.Items[i] as XmlSchemaElement;
1073                             if (el == null)
1074                             {
1075                                 throw new XmlSchemaInferenceException(Res.SchInf_UnknownParticle, 0, 0);
1076                             }
1077                             if ((el.Name == xtr.LocalName) &&( parentSchema.TargetNamespace == childURI))
1078                             {   // element is in the same namespace
1079                                 InferElement(el, false, parentSchema);
1080                                 SetMinMaxOccurs(el, setMaxoccurs);
1081                                 return el;
1082                             }
1083                             else if ((el.RefName.Name == xtr.LocalName) && (el.RefName.Namespace == xtr.NamespaceURI))
1084                             {
1085                                 XmlSchemaElement referencedElement = FindGlobalElement(childURI, xtr.LocalName, out parentSchema);
1086                                 InferElement(referencedElement, false, parentSchema);
1087                                 SetMinMaxOccurs(el, setMaxoccurs);
1088                                 return referencedElement;
1089                             }
1090                         }
1091                         XmlSchemaElement subElement = AddElement(xtr.LocalName, xtr.Prefix, xtr.NamespaceURI, parentSchema, xsch.Items,-1);
1092                         return subElement;
1093                     }
1094                     else
1095                     {   //this should be sequence of elements
1096                         int iSeqItem = 0;   //iterator through schema sequence items
1097                         if (lastUsedSeqItem >= 0)
1098                             iSeqItem = lastUsedSeqItem;
1099                         XmlSchemaParticle particle = xss.Items[iSeqItem] as XmlSchemaParticle;
1100                         XmlSchemaElement el = particle as XmlSchemaElement;
1101                         if (el == null)
1102                         {
1103                             throw new XmlSchemaInferenceException(Res.SchInf_UnknownParticle, 0, 0);
1104                         }
1105                         if (el.Name == xtr.LocalName && parentSchema.TargetNamespace == childURI)
1106                         {
1107                             if (!bItemNotUsedYet)   //read: if item was already used one or more times
1108                                 el.MaxOccurs = decimal.MaxValue;    //set it to unbounded
1109                             lastUsedSeqItem = iSeqItem;
1110                             InferElement(el, false, parentSchema);
1111                             SetMinMaxOccurs(el, false);
1112                             return el;
1113                         }
1114                         else if (el.RefName.Name == xtr.LocalName && el.RefName.Namespace == xtr.NamespaceURI)
1115                         {
1116                             if (!bItemNotUsedYet)   //read: if item was already used one or more times
1117                                 el.MaxOccurs = decimal.MaxValue;    //set it to unbounded
1118                             lastUsedSeqItem = iSeqItem;
1119                             XmlSchemaElement referencedElement = FindGlobalElement(childURI, xtr.LocalName, out parentSchema);
1120                             InferElement(referencedElement, false, parentSchema);
1121                             SetMinMaxOccurs(el, false);
1122                             return el;
1123                         }
1124                         if (bItemNotUsedYet && el.MinOccurs!=decimal.Zero)
1125                             minOccursCandidates.Add(el);
1126                         iSeqItem++;
1127                         while (iSeqItem < xss.Items.Count)
1128                         {
1129                             particle = xss.Items[iSeqItem] as XmlSchemaParticle;
1130                             el = particle as XmlSchemaElement;
1131                             if (el == null)
1132                             {
1133                                 throw new XmlSchemaInferenceException(Res.SchInf_UnknownParticle, 0, 0);
1134                             }
1135                             if (el.Name == xtr.LocalName && parentSchema.TargetNamespace == childURI)
1136                             {
1137                                 lastUsedSeqItem = iSeqItem;
1138                                 for (int i = 0; i < minOccursCandidates.Count; ++i)
1139                                 {
1140                                     ((XmlSchemaElement) minOccursCandidates[i]).MinOccurs = decimal.Zero;
1141                                 }
1142                                 InferElement(el, false, parentSchema);
1143                                 SetMinMaxOccurs(el, setMaxoccurs);
1144                                 return el;
1145                             }
1146                             else if (el.RefName.Name == xtr.LocalName && el.RefName.Namespace == xtr.NamespaceURI)
1147                             {
1148                                 lastUsedSeqItem = iSeqItem;
1149                                 for (int i = 0; i < minOccursCandidates.Count; ++i)
1150                                 {
1151                                     ((XmlSchemaElement) minOccursCandidates[i]).MinOccurs = decimal.Zero;
1152                                 }
1153                                 XmlSchemaElement referencedElement = FindGlobalElement(childURI, xtr.LocalName, out parentSchema);
1154                                 InferElement(referencedElement, false, parentSchema);
1155                                 SetMinMaxOccurs(el, setMaxoccurs);
1156                                 return referencedElement;
1157                             }
1158
1159
1160                             minOccursCandidates.Add(el);
1161                             iSeqItem++;
1162                         }
1163
1164                         //element not found in the sequence order, if it is found out of order change Sequence of elements to Sequence of Choices otherwise insert into sequence as optional
1165                         XmlSchemaElement subElement = null;
1166                         XmlSchemaElement actualElement = null;
1167                         //
1168
1169                         if (parentSchema.TargetNamespace == childURI)
1170                         {
1171                             subElement = FindElement(xss.Items, xtr.LocalName);
1172                             actualElement = subElement;
1173                         }
1174                         else
1175                         {
1176                             subElement = FindElementRef(xss.Items, xtr.LocalName, xtr.NamespaceURI);
1177                             if (subElement != null)
1178                             {
1179                                 actualElement = FindGlobalElement(childURI, xtr.LocalName, out parentSchema);
1180                             }
1181                         }
1182                         if (null != subElement)
1183                         {
1184                             XmlSchemaChoice xsc = new XmlSchemaChoice();
1185                             xsc.MaxOccurs = decimal.MaxValue;
1186                             SetMinMaxOccurs(subElement, setMaxoccurs);
1187                             InferElement(actualElement, false, parentSchema);
1188                             for (int i = 0; i < xss.Items.Count; ++i)
1189                             {
1190                                 xsc.Items.Add(CreateNewElementforChoice((XmlSchemaElement) xss.Items[i]));
1191                             }
1192                             xss.Items.Clear();
1193                             xss.Items.Add(xsc);
1194                             return subElement;
1195                         }
1196                         else
1197                         {
1198                             subElement = AddElement(xtr.LocalName, xtr.Prefix, xtr.NamespaceURI, parentSchema, xss.Items, ++lastUsedSeqItem);
1199                             if (!bCreatingNewType)
1200                                 subElement.MinOccurs = decimal.Zero;
1201                             return subElement;
1202                         }
1203                     }
1204                 }
1205                 else
1206                 {
1207                     throw new XmlSchemaInferenceException(Res.SchInf_noseq, 0, 0);
1208                 }
1209
1210             }
1211             internal void ProcessAttributes(ref XmlSchemaElement xse, XmlSchemaType effectiveSchemaType, bool bCreatingNewType, XmlSchema parentSchema)
1212             {
1213                 XmlSchemaObjectCollection attributesSeen = new XmlSchemaObjectCollection();
1214                 XmlSchemaComplexType ct = effectiveSchemaType as XmlSchemaComplexType;
1215
1216                 Debug.Assert(xtr.NodeType == XmlNodeType.Attribute);
1217                 do
1218                 {
1219                     if (xtr.NamespaceURI == XmlSchema.Namespace)
1220                     {
1221                         throw new XmlSchemaInferenceException(Res.SchInf_schema, 0, 0);
1222                     }
1223
1224                     if (xtr.NamespaceURI == XmlReservedNs.NsXmlNs)
1225                     {
1226                         if (xtr.Prefix=="xmlns")
1227                             NamespaceManager.AddNamespace(xtr.LocalName, xtr.Value);
1228                     }
1229                     else if (xtr.NamespaceURI == XmlReservedNs.NsXsi)
1230                     {
1231                         string localName = xtr.LocalName;
1232                         if (localName == "nil")
1233                         {
1234                             xse.IsNillable = true;
1235                         }
1236                         else if (localName != "type" && localName != "schemaLocation" && localName != "noNamespaceSchemaLocation")
1237                         {
1238                             throw new XmlSchemaInferenceException(Res.Sch_NotXsiAttribute,localName);
1239                         }
1240                     }
1241                     else
1242                     {
1243                         if (ct == null || ct == XmlSchemaComplexType.AnyType)
1244                         {
1245                             ct = new XmlSchemaComplexType();
1246                             xse.SchemaType = ct;
1247                         }
1248
1249                         XmlSchemaAttribute xsa=null;
1250                         //The earlier assumption of checking just schemaTypeName !Empty is not correct for schemas that are not generated by us, schemaTypeName can point to any complex type as well
1251                         //Check that it is a simple type by checking typeCode
1252                         //Switch to complex type simple content extension
1253                         if (effectiveSchemaType != null && effectiveSchemaType.Datatype != null && !xse.SchemaTypeName.IsEmpty)
1254                         {
1255                             //type was previously simple type, now it will become complex with simple type extension
1256                             Debug.Assert(ct != null);
1257                             XmlSchemaSimpleContent sc = new XmlSchemaSimpleContent();
1258                             ct.ContentModel = sc;
1259                             XmlSchemaSimpleContentExtension sce = new XmlSchemaSimpleContentExtension();
1260                             sc.Content = sce;
1261                             sce.BaseTypeName = xse.SchemaTypeName;
1262                             sce.LineNumber = xse.LineNumber;
1263                             xse.LineNumber = 0;
1264                             xse.SchemaTypeName = XmlQualifiedName.Empty; //re-set the name
1265                         }
1266
1267                         Debug.Assert(ct != null); //either the user-defined type itself is a complex type or we switched from a simple type to a complex type
1268                         if (ct.ContentModel != null)
1269                         {
1270                             XmlSchemaSimpleContentExtension sce = CheckSimpleContentExtension(ct);
1271                             Debug.Assert(sce != null);
1272                             xsa = AddAttribute(xtr.LocalName, xtr.Prefix, xtr.NamespaceURI, xtr.Value, bCreatingNewType, parentSchema, sce.Attributes, ct.AttributeUses);
1273                         }
1274                         else //add atributes directly to complex type
1275                         {
1276                             xsa = AddAttribute(xtr.LocalName, xtr.Prefix, xtr.NamespaceURI, xtr.Value, bCreatingNewType, parentSchema, ct.Attributes, ct.AttributeUses);
1277                         }
1278                         if (xsa != null) {
1279                             attributesSeen.Add(xsa);
1280                         }
1281                     }
1282
1283                 } while (xtr.MoveToNextAttribute());
1284                 if (!bCreatingNewType)
1285                 {
1286                     //make attributes that did not appear this time optional
1287                     if (ct!=null) {
1288                         MakeExistingAttributesOptional(ct, attributesSeen);
1289                     }
1290                 }
1291             }
1292
1293             private void MoveAttributes(XmlSchemaSimpleContentExtension scExtension,  XmlSchemaComplexType ct) {
1294                 //copy all attributes from the simple content to the complex type
1295                 //This is ok since when we move from complex type to simple content extension we copy from AttributeUses property
1296                 for (int i = 0; i < scExtension.Attributes.Count; ++i)  //since simpleContent is being cleared
1297                 {
1298                     ct.Attributes.Add(scExtension.Attributes[i]);
1299                 }
1300             }
1301
1302             private void MoveAttributes(XmlSchemaComplexType ct, XmlSchemaSimpleContentExtension simpleContentExtension, bool bCreatingNewType) {
1303                 //copy all attributes from the complex type to the simple content
1304
1305                 ICollection sourceCollection;
1306                 if (!bCreatingNewType && ct.AttributeUses.Count > 0) {
1307                     sourceCollection = ct.AttributeUses.Values;
1308                 }
1309                 else {
1310                     sourceCollection = ct.Attributes;
1311                 }
1312
1313                 foreach (XmlSchemaAttribute attr in sourceCollection) {
1314                     simpleContentExtension.Attributes.Add(attr);
1315                 }
1316                 ct.Attributes.Clear(); //Clear from pre-compiled property, post compiled will be cleared on Re-process and Compile()
1317             }
1318
1319             internal XmlSchemaAttribute FindAttribute(ICollection attributes, string attrName)
1320             {
1321                 foreach(XmlSchemaObject xsa in attributes)
1322                 {
1323                     XmlSchemaAttribute schemaAttribute = xsa as XmlSchemaAttribute;
1324                     if (schemaAttribute != null)
1325                     {
1326                         if (schemaAttribute.Name == attrName)
1327                         {
1328                             return schemaAttribute;
1329                         }
1330
1331                     }
1332                 }
1333                 return null;
1334             }
1335
1336             internal XmlSchemaElement FindGlobalElement(string namespaceURI, string localName, out XmlSchema parentSchema)
1337             {
1338                 ICollection col = this.schemaSet.Schemas(namespaceURI);
1339                 XmlSchemaElement xse = null;
1340                 parentSchema = null;
1341                 foreach(XmlSchema schema in col)
1342                 {
1343                     xse = FindElement(schema.Items, localName);
1344                     if (xse != null)
1345                     {
1346                         parentSchema = schema;
1347                         return xse;
1348                     }
1349                 }
1350                 return null;
1351             }
1352
1353
1354             internal XmlSchemaElement FindElement(XmlSchemaObjectCollection elements, string elementName)
1355             {
1356                 for (int i = 0; i < elements.Count; ++i)
1357                 {
1358                     XmlSchemaElement xse = elements[i] as XmlSchemaElement;
1359                     if (xse != null && xse.RefName != null)
1360                     {
1361                         if (xse.Name == elementName)
1362                         {
1363                             return xse;
1364                         }
1365                     }
1366                 }
1367                 return null;
1368             }
1369
1370             internal XmlSchemaAttribute FindAttributeRef(ICollection attributes, string attributeName, string nsURI)
1371             {
1372                 foreach(XmlSchemaObject xsa in attributes)
1373                 {
1374                     XmlSchemaAttribute schemaAttribute = xsa as XmlSchemaAttribute;
1375                     if (schemaAttribute != null)
1376                     {
1377                         if (schemaAttribute.RefName.Name == attributeName && schemaAttribute.RefName.Namespace == nsURI) {
1378                             return schemaAttribute;
1379                         }
1380
1381                     }
1382                 }
1383                 return null;
1384             }
1385
1386             internal XmlSchemaElement FindElementRef(XmlSchemaObjectCollection elements, string elementName, string nsURI)
1387             {
1388                 for (int i = 0; i < elements.Count; ++i)
1389                 {
1390                     XmlSchemaElement xse = elements[i] as XmlSchemaElement;
1391                     if (xse != null && xse.RefName != null)
1392                     {
1393                         if (xse.RefName.Name == elementName && xse.RefName.Namespace == nsURI)
1394                         {
1395                             return xse;
1396                         }
1397                     }
1398                 }
1399                 return null;
1400             }
1401
1402             internal void MakeExistingAttributesOptional(XmlSchemaComplexType ct, XmlSchemaObjectCollection attributesInInstance) {
1403                 if (ct == null)  {
1404                     throw new XmlSchemaInferenceException(Res.SchInf_noct, 0, 0);
1405                 }
1406                 if (ct.ContentModel != null) {
1407                     XmlSchemaSimpleContentExtension xssce = CheckSimpleContentExtension(ct);
1408                     SwitchUseToOptional(xssce.Attributes, attributesInInstance);
1409                 }
1410                 else { //either <xs:attribute> as child of xs:complexType or the attributes are within the content model
1411                     SwitchUseToOptional(ct.Attributes, attributesInInstance);
1412                 }
1413             }
1414
1415             private void SwitchUseToOptional(XmlSchemaObjectCollection attributes, XmlSchemaObjectCollection attributesInInstance) {
1416                 for (int i = 0; i < attributes.Count; ++i)
1417                 {
1418                     XmlSchemaAttribute attr = attributes[i] as XmlSchemaAttribute;
1419                     if (attr != null) {
1420                         if (attributesInInstance != null) {
1421                             if (attr.RefName.Name.Length == 0) { //If the attribute is not present in this instance, make it optional
1422                                 if (null == FindAttribute(attributesInInstance, attr.Name)) {
1423                                     attr.Use = XmlSchemaUse.Optional;
1424                                 }
1425                             }
1426                             else {
1427                                 if (null == FindAttributeRef(attributesInInstance, attr.RefName.Name, attr.RefName.Namespace)) {
1428                                     attr.Use = XmlSchemaUse.Optional;
1429                                 }
1430                             }
1431                         }
1432                         else {
1433                             attr.Use = XmlSchemaUse.Optional;
1434                         }
1435                     }
1436                 }
1437             }
1438
1439             internal XmlQualifiedName RefineSimpleType(string s, ref int iTypeFlags)
1440             {
1441                 bool bNeedsRangeCheck = false;
1442                 s = s.Trim();
1443                 if (iTypeFlags == TF_string || this.typeInference == InferenceOption.Relaxed)
1444                     return ST_string;
1445                 iTypeFlags &= InferSimpleType(s, ref bNeedsRangeCheck);
1446                 if (iTypeFlags == TF_string)
1447                     return ST_string;
1448                 if (bNeedsRangeCheck)
1449                 {
1450                     if ((iTypeFlags & TF_byte) != 0)
1451                     {
1452                         try
1453                         {
1454                             XmlConvert.ToSByte(s);
1455                             //sbyte.Parse(s);
1456                             if ((iTypeFlags & TF_unsignedByte) != 0)
1457                                 return ST_unsignedByte; //number is positive and fits byte -> it also fits unsignedByte
1458                             else
1459                                 return ST_byte;
1460                         }
1461                         catch (FormatException)
1462                         {}
1463                         catch (OverflowException)
1464                         {}
1465                         iTypeFlags &= (~TF_byte);
1466                     }
1467                     if ((iTypeFlags & TF_unsignedByte) != 0)
1468                     {
1469                         try
1470                         {
1471                             XmlConvert.ToByte(s);
1472                             //byte.Parse(s);
1473                             return ST_unsignedByte;
1474                         }
1475                         catch (FormatException)
1476                         {}
1477                         catch (OverflowException)
1478                         {}
1479                         iTypeFlags &= (~TF_unsignedByte);
1480                     }
1481                     if ((iTypeFlags & TF_short) != 0)
1482                     {
1483                         try
1484                         {
1485                             XmlConvert.ToInt16(s);
1486                             //short.Parse(s);
1487                             if ((iTypeFlags & TF_unsignedShort) != 0)
1488                                 return ST_unsignedShort;    //number is positive and fits short -> it also fits unsignedShort
1489                             else
1490                                 return ST_short;
1491                         }
1492                         catch (FormatException)
1493                         {}
1494                         catch (OverflowException)
1495                         {}
1496                         iTypeFlags &= (~TF_short);
1497                     }
1498                     if ((iTypeFlags & TF_unsignedShort) != 0)
1499                     {
1500                         try
1501                         {
1502                             XmlConvert.ToUInt16(s);
1503                             //ushort.Parse(s);
1504                             return ST_unsignedShort;
1505                         }
1506                         catch (FormatException)
1507                         {}
1508                         catch (OverflowException)
1509                         {}
1510                         iTypeFlags &= (~TF_unsignedShort);
1511                     }
1512                     if ((iTypeFlags & TF_int) != 0)
1513                     {
1514                         try
1515                         {
1516                             XmlConvert.ToInt32(s);
1517                             //int.Parse(s);
1518                             if ((iTypeFlags & TF_unsignedInt) != 0)
1519                                 return ST_unsignedInt;  //number is positive and fits int -> it also fits unsignedInt
1520                             else
1521                                 return ST_int;
1522                         }
1523                         catch (FormatException)
1524                         {}
1525                         catch (OverflowException)
1526                         {}
1527                         iTypeFlags &= (~TF_int);
1528                     }
1529                     if ((iTypeFlags & TF_unsignedInt) != 0)
1530                     {
1531                         try
1532                         {
1533                             XmlConvert.ToUInt32(s);
1534                             //uint.Parse(s);
1535                             return ST_unsignedInt;
1536                         }
1537                         catch (FormatException)
1538                         {}
1539                         catch (OverflowException)
1540                         {}
1541                         iTypeFlags &= (~TF_unsignedInt);
1542                     }
1543                     if ((iTypeFlags & TF_long) != 0)
1544                     {
1545                         try
1546                         {
1547                             XmlConvert.ToInt64(s);
1548                             //long.Parse(s);
1549                             if ((iTypeFlags & TF_unsignedLong) != 0)
1550                                 return ST_unsignedLong; //number is positive and fits long -> it also fits unsignedLong
1551                             else
1552                                 return ST_long;
1553                         }
1554                         catch (FormatException)
1555                         {}
1556                         catch (OverflowException)
1557                         {}
1558                         iTypeFlags &= (~TF_long);
1559                     }
1560                     if ((iTypeFlags & TF_unsignedLong) != 0)
1561                     {
1562                         try
1563                         {
1564                             XmlConvert.ToUInt64(s);
1565                             //ulong.Parse(s);
1566                             return ST_unsignedLong;
1567                         }
1568                         catch (FormatException)
1569                         {}
1570                         catch (OverflowException)
1571                         {}
1572                         iTypeFlags &= (~TF_unsignedLong);
1573                     }
1574                     if ((iTypeFlags & TF_double) != 0)
1575                     {
1576                         try
1577                         {
1578                             double dbValue = XmlConvert.ToDouble(s);
1579                             if ((iTypeFlags & TF_integer) != 0)
1580                                 return ST_integer;
1581                             else if ((iTypeFlags & TF_decimal) != 0)
1582                                 return ST_decimal;
1583                             else {
1584                                 // The value fits into double, but it could be float as well
1585                                 if ((iTypeFlags & TF_float) != 0) {
1586                                     // We used to default to float in this case, so try to fit it into float first
1587                                     try {
1588                                         float flValue = XmlConvert.ToSingle(s);
1589                                         // Compare the float and double values. We can't do simple value comparison
1590                                         //   as conversion from float to double introduces imprecissions which cause problems.
1591                                         // Instead we will convert both back to string and compare the strings.
1592                                         if (string.Compare(XmlConvert.ToString(flValue), XmlConvert.ToString(dbValue),
1593                                             StringComparison.OrdinalIgnoreCase) == 0) {
1594                                             // If we can convert the original string to the exact same value
1595                                             //   and it still fits into float then we treat it as float
1596                                             return ST_float;
1597                                         }
1598                                     }
1599                                     catch (FormatException)
1600                                     {}
1601                                     catch (OverflowException)
1602                                     {}
1603                                 }
1604                                 iTypeFlags &= (~TF_float);
1605                                 return ST_double;
1606                             }
1607                         }
1608                         catch (FormatException)
1609                         {}
1610                         catch (OverflowException)
1611                         {}
1612                         iTypeFlags &= (~TF_double);
1613                     }
1614                     if ((iTypeFlags & TF_float) != 0) {
1615                         try {
1616                             XmlConvert.ToSingle(s);
1617                             if ((iTypeFlags & TF_integer) != 0)
1618                                 return ST_integer;
1619                             else if ((iTypeFlags & TF_decimal) != 0)
1620                                 return ST_decimal;
1621                             else
1622                                 return ST_float;
1623                         }
1624                         catch (FormatException) { }
1625                         catch (OverflowException) { }
1626                         iTypeFlags &= (~TF_float);
1627                     }
1628                     if ((iTypeFlags & TF_integer) != 0)
1629                         return ST_integer;
1630                     else if ((iTypeFlags & TF_decimal) != 0)
1631                         return ST_decimal;
1632                     else if (iTypeFlags == (TF_gYearMonth | TF_string) )
1633                     {
1634                         try
1635                         {
1636                             XmlConvert.ToDateTime(s, XmlDateTimeSerializationMode.RoundtripKind);
1637                             return ST_gYearMonth;
1638                         }
1639                         catch (FormatException)
1640                         {}
1641                         catch (OverflowException)
1642                         {}
1643                         iTypeFlags = TF_string;
1644                         return ST_string;
1645                     }
1646                     else if (iTypeFlags == (TF_duration | TF_string) )
1647                     {
1648                         try
1649                         {
1650                             XmlConvert.ToTimeSpan(s);
1651                             return ST_duration;
1652                         }
1653                         catch (FormatException)
1654                         {}
1655                         catch (OverflowException)
1656                         {}
1657                         iTypeFlags = TF_string;
1658                         return ST_string;
1659                     }
1660                     else if (iTypeFlags == (TF_boolean | TF_string))
1661                     {
1662                         return ST_boolean;
1663                     }
1664
1665                 }
1666
1667                     switch (iTypeFlags)
1668                     {
1669                         case TF_string:
1670                             return ST_string;
1671                         case TF_boolean:
1672                             return ST_boolean;
1673                         case TF_byte:
1674                             return ST_byte;
1675                         case TF_unsignedByte:
1676                             return ST_unsignedByte;
1677                         case TF_short:
1678                             return ST_short;
1679                         case TF_unsignedShort:
1680                             return ST_unsignedShort;
1681                         case TF_int:
1682                             return ST_int;
1683                         case TF_unsignedInt:
1684                             return ST_unsignedInt;
1685                         case TF_long:
1686                             return ST_long;
1687                         case TF_unsignedLong:
1688                             return ST_unsignedLong;
1689                         case TF_integer:
1690                             return ST_integer;
1691                         case TF_decimal:
1692                             return ST_decimal;
1693                         case TF_float:
1694                             return ST_float;
1695                         case TF_double:
1696                             return ST_double;
1697                         case TF_duration:
1698                             return ST_duration;
1699                         case TF_dateTime:
1700                             return ST_dateTime;
1701                         case TF_time:
1702                             return ST_time;
1703                         case TF_date:
1704                             return ST_date;
1705                         case TF_gYearMonth:
1706                             return ST_gYearMonth;
1707
1708                         case TF_boolean | TF_string:
1709                             return ST_boolean;
1710                         case TF_dateTime | TF_string:
1711                             return ST_dateTime;
1712                         case TF_date | TF_string:
1713                             return ST_date;
1714                         case TF_time | TF_string:
1715                             return ST_time;
1716                         case TF_float | TF_double | TF_string:
1717                             return ST_float;
1718                         case TF_double | TF_string:
1719                             return ST_double;
1720
1721                         default:
1722                             Debug.Assert(false, "Expected type not matched");
1723                             return ST_string;
1724                     }
1725                 /*          if (currentType == null)
1726                                 return SimpleTypes[newType];
1727                             else
1728                                 return SimpleTypes[ST_Map[newType,(short) ST_Codes[currentType]]];
1729                                 */
1730             }
1731
1732             internal static int InferSimpleType(string s, ref bool bNeedsRangeCheck)
1733             {
1734                 bool bNegative = false;
1735                 bool bPositive = false;
1736                 bool bDate = false;
1737                 bool bTime = false;
1738                 bool bMissingDay = false;
1739
1740 #if !BOOTSTRAP_BASIC
1741                 if (s.Length==0) return TF_string;
1742                 int i = 0;
1743                 switch (s[i])
1744                 {
1745                     case 't':
1746                     case 'f':
1747                         if (s == "true")
1748                             return TF_boolean | TF_string;
1749                         else if (s == "false")
1750                             return TF_boolean | TF_string;
1751                         else
1752                             return TF_string;
1753                     case 'N':       //try to match "NaN"
1754                         if (s == "NaN")
1755                             return TF_float | TF_double | TF_string;
1756                         else
1757                             return TF_string;
1758                         //else
1759                     case 'I':       //try to match "INF"
1760                         INF:
1761                             if (s.Substring(i) == "INF")
1762                                 return TF_float | TF_double | TF_string;
1763                             else return TF_string;
1764                     case '.':       //try to match ".9999"  decimal/float/double
1765                         FRACTION:
1766                             bNeedsRangeCheck = true;
1767                         i++;
1768                         if (i==s.Length)
1769                         {
1770                             if ((i==1) || (i==2 && (bPositive || bNegative)))   //"." "-." "+."
1771                                 return TF_string;
1772                             else
1773                                 return TF_decimal | TF_float | TF_double | TF_string;
1774                         }
1775                     switch (s[i])
1776                     {
1777                         case 'e':
1778                         case 'E':
1779                             goto EXPONENT;
1780                         default:
1781                             if (s[i]>='0' && s[i]<='9')
1782                                 goto DEC_PART;
1783                             else
1784                                 return TF_string;
1785                     }
1786                         DEC_PART:
1787                             i++; if (i==s.Length) return TF_decimal | TF_float | TF_double | TF_string; //"9999.9" was matched
1788                     switch (s[i])
1789                     {
1790                         case 'e':
1791                         case 'E':
1792                             goto EXPONENT;
1793                         default:
1794                             if (s[i]>='0' && s[i]<='9')
1795                                 goto DEC_PART;
1796                             else
1797                                 return TF_string;
1798                     }
1799                         EXPONENT:
1800                             i++; if (i==s.Length) return TF_string;
1801                     switch (s[i])
1802                     {
1803                         case '+':
1804                         case '-':
1805                             goto E1;
1806                         default:
1807                             if (s[i]>='0' && s[i]<='9')
1808                                 goto EXP_PART;
1809                             else
1810                                 return TF_string;
1811                     }
1812                         E1:
1813                             i++; if (i==s.Length) return TF_string; //".9999e+" was matched
1814                         if (s[i]>='0' && s[i]<='9')
1815                             goto EXP_PART;
1816                         else
1817                             return TF_string;   //".999e+X was matched
1818                         EXP_PART:
1819                             i++; if (i==s.Length) return TF_float | TF_double | TF_string;  //".9999e+99" was matched
1820                         if (s[i]>='0' && s[i]<='9') //".9999e+9
1821                             goto EXP_PART;
1822                         else
1823                             return TF_string;   //".9999e+999X" was matched
1824                     case '-':
1825                         bNegative = true;
1826                         i++; if (i==s.Length) return TF_string;
1827                     switch (s[i])
1828                     {
1829                         case 'I':   //try to match "-INF"
1830                             goto INF;
1831                         case '.':   //try to match "-.9999"
1832                             goto FRACTION;
1833                         case 'P':
1834                             goto DURATION;
1835                         default:
1836                             if (s[i]>='0' && s[i]<='9') //-9
1837                                 goto NUMBER;
1838                             else return TF_string;
1839                     }
1840                     case '+':
1841                         bPositive = true;
1842                         i++; if (i==s.Length) return TF_string;
1843                     switch (s[i])
1844                     {
1845                         case '.':   //try to match "+.9999"
1846                             goto FRACTION;
1847                         case 'P':
1848                             goto DURATION;
1849                         default:
1850                             if (s[i]>='0' && s[i]<='9') //"+9
1851                                 goto NUMBER;
1852                             else return TF_string;
1853                     }
1854                     case 'P':       //try to match duration
1855                         DURATION:
1856                             i++; if (i==s.Length) return TF_string;
1857                     switch (s[i])
1858                     {
1859                         case 'T':
1860                             goto D7;
1861                         default:
1862                             if (s[i]>='0' && s[i]<='9') //"P9"
1863                                 goto D1;
1864                             else return TF_string;
1865                     }
1866                         D1:
1867                             i++; if (i==s.Length) return TF_string; //"P999" was matched
1868                     switch (s[i])
1869                     {
1870                         case 'Y':
1871                             goto D2;
1872                         case 'M':
1873                             goto D4;
1874                         case 'D':
1875                             goto D6;
1876                         default:
1877                             if (s[i]>='0' && s[i]<='9')
1878                                 goto D1;
1879                             else
1880                                 return TF_string;
1881                     }
1882                         D2:
1883                             i++;
1884                         if (i==s.Length)
1885                         {
1886                             bNeedsRangeCheck = true;
1887                             return TF_duration | TF_string; //"P999Y" was matched
1888                         }
1889                     switch (s[i])
1890                     {
1891                         case 'T':
1892                             goto D7;
1893                         default:
1894                             if (s[i]>='0' && s[i]<='9')
1895                                 goto D3;
1896                             else
1897                                 return TF_string;
1898                     }
1899                         D3:
1900                             i++; if (i==s.Length) return TF_string; //"P999Y9" was matched
1901                     switch (s[i])
1902                     {
1903                         case 'M':
1904                             goto D4;
1905                         case 'D':
1906                             goto D6;
1907                         default:
1908                             if (s[i]>='0' && s[i]<='9')
1909                                 goto D3;
1910                             else
1911                                 return TF_string;
1912                     }
1913                         D4:
1914                             i++;
1915                         if (i==s.Length)
1916                         {
1917                             bNeedsRangeCheck = true;
1918                             return TF_duration | TF_string; //"P999Y999M" was matched
1919                         }
1920                     switch (s[i])
1921                     {
1922                         case 'T':
1923                             goto D7;
1924                         default:
1925                             if (s[i]>='0' && s[i]<='9')
1926                                 goto D5;
1927                             else
1928                                 return TF_string;
1929                     }
1930                         D5:
1931                             i++; if (i==s.Length) return TF_string; //"P999Y999M9" was matched
1932                     switch (s[i])
1933                     {
1934                         case 'D':
1935                             goto D6;
1936                         default:
1937                             if (s[i]>='0' && s[i]<='9')
1938                                 goto D5;
1939                             else
1940                                 return TF_string;
1941                     }
1942                         D6:
1943                             i++;
1944                         if (i==s.Length)
1945                         {
1946                             bNeedsRangeCheck = true;
1947                             return TF_duration | TF_string; //"P999Y999M999D" was matched
1948                         }
1949                     switch (s[i])
1950                     {
1951                         case 'T':
1952                             goto D7;
1953                         default:
1954                             return TF_string;
1955                     }
1956                         D7:
1957                             i++; if (i==s.Length) return TF_string; //"P999Y999M9999DT" was matched
1958                         if (s[i]>='0' && s[i]<='9')
1959                             goto D8;
1960                         else
1961                             return TF_string;
1962                         D8:
1963                             i++; if (i==s.Length) return TF_string; //"___T9" was matched
1964                     switch (s[i])
1965                     {
1966                         case 'H':
1967                             goto D9;
1968                         case 'M':
1969                             goto D11;
1970                         case '.':
1971                             goto D13;
1972                         case 'S':
1973                             goto D15;
1974                         default:
1975                             if (s[i]>='0' && s[i]<='9')
1976                                 goto D8;
1977                             else
1978                                 return TF_string;
1979                     }
1980                         D9:
1981                             i++;
1982                         if (i==s.Length)
1983                         {
1984                             bNeedsRangeCheck = true;
1985                             return TF_duration | TF_string; //"___T999H" was matched
1986                         }
1987                         if (s[i]>='0' && s[i]<='9')
1988                             goto D10;
1989                         else
1990                             return TF_string;
1991                         D10:
1992                             i++; if (i==s.Length) return TF_string; //"___T999H9" was matched
1993                     switch (s[i])
1994                     {
1995                         case 'M':
1996                             goto D11;
1997                         case '.':
1998                             goto D13;
1999                         case 'S':
2000                             goto D15;
2001                         default:
2002                             if (s[i]>='0' && s[i]<='9')
2003                                 goto D10;
2004                             else
2005                                 return TF_string;
2006                     }
2007                         D11:
2008                             i++;
2009                         if (i==s.Length)
2010                         {
2011                             bNeedsRangeCheck = true;
2012                             return TF_duration | TF_string; //"___T999H999M" was matched
2013                         }
2014                         if (s[i]>='0' && s[i]<='9')
2015                             goto D12;
2016                         else
2017                             return TF_string;
2018                         D12:
2019                             i++; if (i==s.Length) return TF_string; //"___T999H999M9" was matched
2020                     switch (s[i])
2021                     {
2022                         case '.':
2023                             goto D13;
2024                         case 'S':
2025                             goto D15;
2026                         default:
2027                             if (s[i]>='0' && s[i]<='9')
2028                                 goto D12;
2029                             else
2030                                 return TF_string;
2031                     }
2032                         D13:
2033                             i++;
2034                         if (i==s.Length)
2035                         {
2036                             bNeedsRangeCheck = true;
2037                             return TF_duration | TF_string; //"___T999H999M999." was matched
2038                         }
2039                         if (s[i]>='0' && s[i]<='9')
2040                             goto D14;
2041                         else
2042                             return TF_string;
2043                         D14:
2044                             i++; if (i==s.Length) return TF_string; //"___T999H999M999.9" was matched
2045                     switch (s[i])
2046                     {
2047                         case 'S':
2048                             goto D15;
2049                         default:
2050                             if (s[i]>='0' && s[i]<='9')
2051                                 goto D14;
2052                             else
2053                                 return TF_string;
2054                     }
2055                         D15:
2056                             i++;
2057                         if (i==s.Length)
2058                         {
2059                             bNeedsRangeCheck = true;
2060                             return TF_duration | TF_string; //"___T999H999M999.999S" was matched
2061                         }
2062                         else return TF_string;
2063                     case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
2064                         NUMBER:
2065                             i++;
2066                         if (i==s.Length)
2067                         {
2068                             bNeedsRangeCheck = true;
2069                             if (bNegative || bPositive)
2070                                 return TF_byte | TF_short | TF_int | TF_long | TF_integer | TF_decimal | TF_float | TF_double | TF_string;  //"-9"
2071                             else
2072                             {
2073                                 if (s=="0" || s=="1")
2074                                     return TF_boolean | TF_byte | TF_short | TF_int | TF_long | TF_integer | TF_decimal | TF_float | TF_double |
2075                                         TF_unsignedByte | TF_unsignedShort | TF_unsignedInt | TF_unsignedLong | TF_string;
2076                                 else
2077                                     return TF_byte | TF_short | TF_int | TF_long | TF_integer | TF_decimal | TF_float | TF_double |
2078                                         TF_unsignedByte | TF_unsignedShort | TF_unsignedInt | TF_unsignedLong | TF_string;
2079                             }
2080                         }
2081                     switch (s[i])
2082                     {
2083                         case '.':
2084                             goto FRACTION;
2085                         case 'e':
2086                         case 'E':
2087                             bNeedsRangeCheck = true;
2088                             return TF_float | TF_double | TF_string;
2089                         default:
2090                             if (s[i]>='0' && s[i]<='9')
2091                                 goto N2;
2092                             else
2093                                 return TF_string;
2094                     }
2095                         N2:
2096                             i++;
2097                         if (i==s.Length)
2098                         {
2099                             bNeedsRangeCheck = true;
2100                             if (bNegative || bPositive)
2101                                 return TF_byte | TF_short | TF_int | TF_long | TF_integer | TF_decimal | TF_float | TF_double | TF_string;  //"-9"
2102                             else
2103                                 return TF_byte | TF_short | TF_int | TF_long | TF_integer | TF_decimal | TF_float | TF_double |
2104                                     TF_unsignedByte | TF_unsignedShort | TF_unsignedInt | TF_unsignedLong | TF_string;
2105                         }
2106                     switch (s[i])
2107                     {
2108                         case '.':
2109                             goto FRACTION;
2110                         case ':':
2111                             bTime = true;
2112                             goto MINUTE;
2113                         case 'e':
2114                         case 'E':
2115                             bNeedsRangeCheck = true;
2116                             return TF_float | TF_double | TF_string;
2117                         default:
2118                             if (s[i]>='0' && s[i]<='9')
2119                                 goto N3;
2120                             else
2121                                 return TF_string;
2122                     }
2123
2124                         N3:
2125                             i++;
2126                         if (i==s.Length)
2127                         {
2128                             bNeedsRangeCheck = true; //three digits may not fit byte and unsignedByte
2129                             if (bNegative || bPositive)
2130                                 return TF_byte | TF_short | TF_int | TF_long | TF_integer | TF_decimal | TF_float | TF_double | TF_string;  //"-9"
2131                             else
2132                                 return TF_byte | TF_short | TF_int | TF_long | TF_integer | TF_decimal | TF_float | TF_double |
2133                                     TF_unsignedByte | TF_unsignedShort | TF_unsignedInt | TF_unsignedLong | TF_string;
2134                         }
2135                     switch (s[i])
2136                     {
2137                         case '.':
2138                             goto FRACTION;
2139                         case 'e':
2140                         case 'E':
2141                             bNeedsRangeCheck = true;
2142                             return TF_float | TF_double | TF_string;
2143                         default:
2144                             if (s[i]>='0' && s[i]<='9')
2145                                 goto N4;
2146                             else
2147                                 return TF_string;
2148                     }
2149                         N4:
2150                             i++;
2151                         if (i==s.Length)
2152                         {
2153                             bNeedsRangeCheck = true;
2154                             if (bNegative || bPositive)
2155                                 return TF_byte | TF_short | TF_int | TF_long | TF_integer | TF_decimal | TF_float | TF_double | TF_string;  //"-9"
2156                             else
2157                                 return TF_byte | TF_short | TF_int | TF_long | TF_integer | TF_decimal | TF_float | TF_double |
2158                                     TF_unsignedByte | TF_unsignedShort | TF_unsignedInt | TF_unsignedLong | TF_string;
2159                         }
2160
2161                     switch (s[i])
2162                     {
2163                         case '-':
2164                             bDate = true;
2165                             goto DATE;
2166                         case '.':
2167                             goto FRACTION;
2168                         case 'e':
2169                         case 'E':
2170                             bNeedsRangeCheck = true;
2171                             return TF_float | TF_double | TF_string;
2172                         default:
2173                             if (s[i]>='0' && s[i]<='9')
2174                                 goto N4;
2175                             else
2176                                 return TF_string;
2177                     }
2178                         DATE:
2179                             i++; if (i==s.Length) return TF_string; //"9999-"
2180                         if (s[i]<'0' || s[i]>'9')
2181                             return TF_string;
2182                         i++; if (i==s.Length) return TF_string; //"9999-9"
2183                         if (s[i]<'0' || s[i]>'9')
2184                             return TF_string;
2185                         i++;
2186                         if (i==s.Length)
2187                         {
2188                             bNeedsRangeCheck = true;
2189                             return TF_gYearMonth | TF_string;   //"9999-99"
2190                         }
2191                     switch (s[i])
2192                     {
2193                         case '-':
2194                             goto DAY;
2195                         case 'Z':
2196                         case 'z':
2197                             bMissingDay = true;
2198                             goto ZULU;
2199                         case '+':
2200                             bMissingDay = true;
2201                             goto ZONE_SHIFT;
2202                         default:
2203                             return TF_string;
2204                     }
2205                         DAY:
2206                             i++; if (i==s.Length) return TF_string; //"9999-99-"
2207                         if (s[i]<'0' || s[i]>'9')
2208                             return TF_string;
2209                         i++; if (i==s.Length) return TF_string; //"9999-99-9"
2210                         if (s[i]<'0' || s[i]>'9')
2211                             return TF_string;
2212                         i++; if (i==s.Length) return DateTime(s, bDate, bTime); //"9999-99-99"
2213                     switch (s[i])
2214                     {
2215                         case 'Z':
2216                         case 'z':
2217                             goto ZULU;
2218                         case '+':
2219                         case '-':
2220                             goto ZONE_SHIFT;
2221                         case 'T':
2222                             bTime=true;
2223                             goto TIME;
2224                         case ':':
2225                             bMissingDay = true;
2226                             goto ZONE_SHIFT_MINUTE;
2227                         default:
2228                             return TF_string;
2229                     }
2230                         ZULU:
2231                             i++;
2232                         if (i==s.Length)
2233                         {
2234                             if (bMissingDay)
2235                             {
2236                                 bNeedsRangeCheck=true;
2237                                 return TF_gYearMonth | TF_string;
2238                             }
2239                             else
2240                             {
2241                                 return DateTime(s, bDate, bTime);
2242                             }
2243                         }
2244                         else
2245                             return TF_string;
2246                         ZONE_SHIFT:
2247                             i++; if (i==s.Length) return TF_string;
2248                         if (s[i]<'0' || s[i]>'9')
2249                             return TF_string;
2250                         i++; if (i==s.Length) return TF_string;
2251                         if (s[i]<'0' || s[i]>'9')
2252                             return TF_string;
2253                         i++; if (i==s.Length) return TF_string;
2254                         if (s[i] != ':')
2255                             return TF_string;
2256                         ZONE_SHIFT_MINUTE:
2257                             i++; if (i==s.Length) return TF_string;
2258                         if (s[i]<'0' || s[i]>'9')
2259                             return TF_string;
2260                         i++; if (i==s.Length) return TF_string;
2261                         if (s[i]<'0' || s[i]>'9')
2262                             return TF_string;
2263                         i++;
2264                         if (i==s.Length)
2265                         {
2266                             if (bMissingDay)
2267                             {
2268                                 bNeedsRangeCheck=true;
2269                                 return TF_gYearMonth | TF_string;
2270                             }
2271                             else
2272                             {
2273                                 return DateTime(s, bDate, bTime);
2274                             }
2275                         }
2276                         else return TF_string;
2277                         TIME:
2278                             i++; if (i==s.Length) return TF_string;
2279                         if (s[i]<'0' || s[i]>'9')
2280                             return TF_string;
2281                         i++; if (i==s.Length) return TF_string;
2282                         if (s[i]<'0' || s[i]>'9')
2283                             return TF_string;
2284                         i++; if (i==s.Length) return TF_string;
2285                         if (s[i] != ':')
2286                             return TF_string;
2287                         MINUTE:
2288                             i++; if (i==s.Length) return TF_string;
2289                         if (s[i]<'0' || s[i]>'9')
2290                             return TF_string;
2291                         i++; if (i==s.Length) return TF_string;
2292                         if (s[i]<'0' || s[i]>'9')
2293                             return TF_string;
2294                         i++; if (i==s.Length) return TF_string;
2295                         if (s[i] != ':')
2296                             return TF_string;
2297                         i++; if (i==s.Length) return TF_string;
2298                         if (s[i]<'0' || s[i]>'9')
2299                             return TF_string;
2300                         i++; if (i==s.Length) return TF_string;
2301                         if (s[i]<'0' || s[i]>'9')
2302                             return TF_string;
2303                         i++; if (i==s.Length) return DateTime(s, bDate, bTime);
2304                     switch (s[i])
2305                     {
2306                         case 'Z':
2307                         case 'z':
2308                             goto ZULU;
2309                         case '+':
2310                         case '-':
2311                             goto ZONE_SHIFT;
2312                         case '.':
2313                             goto SECOND_FRACTION;
2314                         default:
2315                             return TF_string;
2316                     }
2317                         SECOND_FRACTION:
2318                             i++; if (i==s.Length) return TF_string;
2319                         if (s[i]<'0' || s[i]>'9')
2320                             return TF_string;
2321                         FRACT_DIGITS:
2322                             i++; if (i==s.Length) return DateTime(s, bDate, bTime);
2323                     switch (s[i])
2324                     {
2325                         case 'Z':
2326                         case 'z':
2327                             goto ZULU;
2328                         case '+':
2329                         case '-':
2330                             goto ZONE_SHIFT;
2331                         default:
2332                             if (s[i]>='0' && s[i]<='9')
2333                                 goto FRACT_DIGITS;
2334                             else
2335                                 return TF_string;
2336
2337                     }
2338                     default:
2339                         return TF_string;
2340                 }
2341 #else // BOOTSTRAP_BASIC
2342                 return TF_string;
2343 #endif
2344             }
2345
2346             internal static int DateTime(string s, bool bDate, bool bTime)
2347             {
2348                 try
2349                 {
2350                     XmlConvert.ToDateTime(s, XmlDateTimeSerializationMode.RoundtripKind);
2351                 }
2352                 catch (FormatException)
2353                 {
2354                     return TF_string;
2355                 }
2356                 if (bDate && bTime)
2357                     return TF_dateTime | TF_string;
2358                 else if (bDate)
2359                     return TF_date | TF_string;
2360                 else if (bTime)
2361                     return TF_time | TF_string;
2362                 else
2363                 {
2364                     Debug.Assert(false, "Expected date, time or dateTime");
2365                     return TF_string;
2366                 }
2367             }
2368             XmlSchemaElement CreateNewElementforChoice(XmlSchemaElement copyElement)
2369             {
2370                 XmlSchemaElement newElement = new XmlSchemaElement();
2371                 newElement.Annotation = copyElement.Annotation;
2372                 newElement.Block = copyElement.Block;
2373                 newElement.DefaultValue = copyElement.DefaultValue;
2374                 newElement.Final = copyElement.Final;
2375                 newElement.FixedValue = copyElement.FixedValue;
2376                 newElement.Form = copyElement.Form;
2377                 newElement.Id = copyElement.Id;
2378                 //                newElement.IsAbstract = copyElement.IsAbstract;
2379                 if (copyElement.IsNillable)
2380                 {
2381                     newElement.IsNillable = copyElement.IsNillable;
2382                 }
2383                 newElement.LineNumber = copyElement.LineNumber;
2384                 newElement.LinePosition = copyElement.LinePosition;
2385                 newElement.Name = copyElement.Name;
2386                 newElement.Namespaces = copyElement.Namespaces;
2387                 newElement.RefName = copyElement.RefName;
2388                 newElement.SchemaType = copyElement.SchemaType;
2389                 newElement.SchemaTypeName = copyElement.SchemaTypeName;
2390                 newElement.SourceUri = copyElement.SourceUri;
2391                 newElement.SubstitutionGroup = copyElement.SubstitutionGroup;
2392                 newElement.UnhandledAttributes = copyElement.UnhandledAttributes;
2393                 if (copyElement.MinOccurs != Decimal.One && this.Occurrence == InferenceOption.Relaxed)
2394                 {
2395                     newElement.MinOccurs = copyElement.MinOccurs;
2396                 }
2397                 if (copyElement.MaxOccurs != Decimal.One) {
2398                     newElement.MaxOccurs = copyElement.MaxOccurs;
2399                 }
2400                 return newElement;
2401             }
2402
2403             private static int GetSchemaType(XmlQualifiedName qname)
2404             {
2405                 if (qname == SimpleTypes[HC_ST_boolean])
2406                 {
2407                     return TF_boolean | TF_string;
2408                 }
2409                 if (qname == SimpleTypes[HC_ST_byte])
2410                 {
2411                     return TF_byte | TF_short | TF_int | TF_long | TF_integer | TF_decimal | TF_float | TF_double | TF_string;
2412                 }
2413                 if (qname == SimpleTypes[HC_ST_unsignedByte])
2414                 {
2415                     return TF_byte | TF_short | TF_int | TF_long | TF_integer | TF_decimal | TF_float | TF_double |
2416                                         TF_unsignedByte | TF_unsignedShort | TF_unsignedInt | TF_unsignedLong | TF_string;
2417                 }
2418                 if (qname == SimpleTypes[HC_ST_short])
2419                 {
2420                     return TF_short | TF_int | TF_long | TF_integer | TF_decimal | TF_float | TF_double | TF_string;
2421                 }
2422                 if (qname == SimpleTypes[HC_ST_unsignedShort])
2423                 {
2424                     return TF_short | TF_int | TF_long | TF_integer | TF_decimal | TF_float | TF_double |
2425                                          TF_unsignedShort | TF_unsignedInt | TF_unsignedLong | TF_string;
2426                 }
2427                 if (qname == SimpleTypes[HC_ST_int])
2428                 {
2429                     return TF_int | TF_long | TF_integer | TF_decimal | TF_float | TF_double | TF_string;
2430                 }
2431                 if (qname == SimpleTypes[HC_ST_unsignedInt])
2432                 {
2433                     return  TF_int | TF_long | TF_integer | TF_decimal | TF_float | TF_double |
2434                                           TF_unsignedInt | TF_unsignedLong | TF_string;
2435                 }
2436                 if (qname == SimpleTypes[HC_ST_long])
2437                 {
2438                     return TF_long | TF_integer | TF_decimal | TF_float | TF_double | TF_string;
2439                 }
2440                 if (qname == SimpleTypes[HC_ST_unsignedLong])
2441                 {
2442                     return TF_long | TF_integer | TF_decimal | TF_float | TF_double |
2443                                           TF_unsignedLong | TF_string;
2444                 }
2445                 if (qname == SimpleTypes[HC_ST_integer])
2446                 {
2447                     return TF_integer |TF_decimal | TF_float | TF_double | TF_string;
2448                 }
2449                 if (qname == SimpleTypes[HC_ST_decimal])
2450                 {
2451                     return TF_decimal | TF_float | TF_double | TF_string;
2452                 }
2453                 if (qname == SimpleTypes[HC_ST_float])
2454                 {
2455                     return TF_float | TF_double | TF_string;
2456                 }
2457                 if (qname == SimpleTypes[HC_ST_double])
2458                 {
2459                     return TF_double | TF_string;
2460                 }
2461                 if (qname == SimpleTypes[HC_ST_duration])
2462                 {
2463                     return TF_duration | TF_string;
2464                 }
2465                 if (qname == SimpleTypes[HC_ST_dateTime])
2466                 {
2467                     return TF_dateTime | TF_string;
2468                 }
2469                 if (qname == SimpleTypes[HC_ST_time])
2470                 {
2471                     return TF_time | TF_string;
2472                 }
2473                 if (qname == SimpleTypes[HC_ST_date])
2474                 {
2475                     return TF_date;
2476                 }
2477                 if (qname == SimpleTypes[HC_ST_gYearMonth])
2478                 {
2479                     return TF_gYearMonth;
2480                 }
2481                 if (qname == SimpleTypes[HC_ST_string])
2482                 {
2483                     return TF_string;
2484                 }
2485                 if (qname == null || qname.IsEmpty) {
2486                     return -1;
2487                 }
2488                 throw new XmlSchemaInferenceException(Res.SchInf_schematype, 0, 0);
2489             }
2490
2491             internal void SetMinMaxOccurs(XmlSchemaElement el, bool setMaxOccurs)
2492             {
2493                 if (this.Occurrence == InferenceOption.Relaxed)
2494                 {
2495                     if (setMaxOccurs || el.MaxOccurs > 1)
2496                     {
2497                         el.MaxOccurs = decimal.MaxValue;    //set it to unbounded
2498                     }
2499                     el.MinOccurs = 0;
2500                 }
2501                 else if (el.MinOccurs > 1)
2502                 {
2503                     el.MinOccurs = 1;
2504                 }
2505             }
2506
2507
2508         }
2509     }