mcs/class/System.XML/System.Xml/DTDObjectModel.cs

   1 //
   2 // Mono.Xml.DTDObjectModel
   3 //
   4 // Author:
   5 //      Atsushi Enomoto (ginga@kit.hi-ho.ne.jp)
   6 //
   7 //      (C)2003 Atsushi Enomoto
   8 //
   9
  10 //
  11 // Permission is hereby granted, free of charge, to any person obtaining
  12 // a copy of this software and associated documentation files (the
  13 // "Software"), to deal in the Software without restriction, including
  14 // without limitation the rights to use, copy, modify, merge, publish,
  15 // distribute, sublicense, and/or sell copies of the Software, and to
  16 // permit persons to whom the Software is furnished to do so, subject to
  17 // the following conditions:
  18 //
  19 // The above copyright notice and this permission notice shall be
  20 // included in all copies or substantial portions of the Software.
  21 //
  22 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  25 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  26 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  27 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  28 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29 //
  30 using System;
  31 using System.Collections;
  32 using System.Globalization;
  33 using System.IO;
  34 using System.Text;
  35 using System.Xml;
  36 using System.Xml.Schema;
  37 #if NET_2_0
  38 using System.Collections.Generic;
  39 #endif
  40 #if NET_2_1
  41 using XmlSchemaException = System.Xml.XmlException;
  42 #else
  43 using Mono.Xml.Schema;
  44 #endif
  45
  46 #if NET_2_0
  47 using XmlTextReaderImpl = Mono.Xml2.XmlTextReader;
  48 #else
  49 using XmlTextReaderImpl = System.Xml.XmlTextReader;
  50 #endif
  51
  52 namespace Mono.Xml
  53 {
  54         internal class DTDObjectModel
  55         {
  56                 // This specifies the max number of dependent external entities
  57                 // per a DTD can consume. A malicious external document server
  58                 // might send users' document processing server a large number
  59                 // of external entities.
  60                 public const int AllowedExternalEntitiesMax = 256;
  61
  62                 DTDAutomataFactory factory;
  63                 DTDElementAutomata rootAutomata;
  64                 DTDEmptyAutomata emptyAutomata;
  65                 DTDAnyAutomata anyAutomata;
  66                 DTDInvalidAutomata invalidAutomata;
  67
  68                 DTDElementDeclarationCollection elementDecls;
  69                 DTDAttListDeclarationCollection attListDecls;
  70                 DTDParameterEntityDeclarationCollection peDecls;
  71                 DTDEntityDeclarationCollection entityDecls;
  72                 DTDNotationDeclarationCollection notationDecls;
  73                 ArrayList validationErrors;
  74                 XmlResolver resolver;
  75                 XmlNameTable nameTable;
  76
  77                 Hashtable externalResources;
  78
  79                 string baseURI;
  80                 string name;
  81                 string publicId;
  82                 string systemId;
  83                 string intSubset;
  84                 bool intSubsetHasPERef;
  85                 bool isStandalone;
  86                 int lineNumber;
  87                 int linePosition;
  88
  89                 public DTDObjectModel (XmlNameTable nameTable)
  90                 {
  91                         this.nameTable = nameTable;
  92                         elementDecls = new DTDElementDeclarationCollection (this);
  93                         attListDecls = new DTDAttListDeclarationCollection (this);
  94                         entityDecls = new DTDEntityDeclarationCollection (this);
  95                         peDecls = new DTDParameterEntityDeclarationCollection (this);
  96                         notationDecls = new DTDNotationDeclarationCollection (this);
  97                         factory = new DTDAutomataFactory (this);
  98                         validationErrors = new ArrayList ();
  99                         externalResources = new Hashtable ();
 100                 }
 101
 102                 public string BaseURI {
 103                         get { return baseURI; }
 104                         set { baseURI = value; }
 105                 }
 106
 107                 public bool IsStandalone {
 108                         get { return isStandalone; }
 109                         set { isStandalone = value; }
 110                 }
 111
 112                 public string Name {
 113                         get { return name; }
 114                         set { name = value; }
 115                 }
 116
 117                 public XmlNameTable NameTable {
 118                         get { return nameTable; }
 119                 }
 120
 121                 public string PublicId {
 122                         get { return publicId; }
 123                         set { publicId = value; }
 124                 }
 125
 126                 public string SystemId {
 127                         get { return systemId; }
 128                         set { systemId = value; }
 129                 }
 130
 131                 public string InternalSubset {
 132                         get { return intSubset; }
 133                         set { intSubset = value; }
 134                 }
 135
 136                 public bool InternalSubsetHasPEReference {
 137                         get { return intSubsetHasPERef; }
 138                         set { intSubsetHasPERef = value; }
 139                 }
 140
 141                 public int LineNumber {
 142                         get { return lineNumber; }
 143                         set { lineNumber = value; }
 144                 }
 145
 146                 public int LinePosition {
 147                         get { return linePosition; }
 148                         set { linePosition = value; }
 149                 }
 150
 151 #if !NET_2_1
 152                 internal XmlSchema CreateXsdSchema ()
 153                 {
 154                         XmlSchema s = new XmlSchema ();
 155                         s.SourceUri = BaseURI;
 156                         s.LineNumber = LineNumber;
 157                         s.LinePosition = LinePosition;
 158                         foreach (DTDElementDeclaration el in ElementDecls.Values)
 159                                 s.Items.Add (el.CreateXsdElement ());
 160                         return s;
 161                 }
 162 #endif
 163
 164                 public string ResolveEntity (string name)
 165                 {
 166                         DTDEntityDeclaration decl = EntityDecls [name]
 167                                 as DTDEntityDeclaration;
 168                         if (decl == null) {
 169 #if NET_2_1
 170                                 AddError (new XmlSchemaException (String.Format ("Required entity was not found: {0}", name), null, this.LineNumber, this.LinePosition));
 171 #else
 172                                 AddError (new XmlSchemaException ("Required entity was not found.",
 173                                         this.LineNumber, this.LinePosition, null, this.BaseURI, null));
 174 #endif
 175                                 return " ";
 176                         }
 177                         else
 178                                 return decl.EntityValue;
 179                 }
 180
 181                 internal XmlResolver Resolver {
 182                         get { return resolver; }
 183                 }
 184
 185                 public XmlResolver XmlResolver {
 186                         set { resolver = value; }
 187                 }
 188
 189                 internal Hashtable ExternalResources {
 190                         get { return externalResources; }
 191                 }
 192
 193                 public DTDAutomataFactory Factory {
 194                         get { return factory; }
 195                 }
 196
 197                 public DTDElementDeclaration RootElement {
 198                         get { return ElementDecls [Name]; }
 199                 }
 200
 201                 public DTDElementDeclarationCollection ElementDecls {
 202                         get { return elementDecls; }
 203                 }
 204
 205                 public DTDAttListDeclarationCollection AttListDecls {
 206                         get { return attListDecls; }
 207                 }
 208
 209                 public DTDEntityDeclarationCollection EntityDecls {
 210                         get { return entityDecls; }
 211                 }
 212
 213                 public DTDParameterEntityDeclarationCollection PEDecls {
 214                         get { return peDecls; }
 215                 }
 216
 217                 public DTDNotationDeclarationCollection NotationDecls {
 218                         get { return notationDecls; }
 219                 }
 220
 221                 public DTDAutomata RootAutomata {
 222                         get {
 223                                 if (rootAutomata == null)
 224                                         rootAutomata = new DTDElementAutomata (this, this.Name);
 225                                 return rootAutomata;
 226                         }
 227                 }
 228
 229                 public DTDEmptyAutomata Empty {
 230                         get {
 231                                 if (emptyAutomata == null)
 232                                         emptyAutomata = new DTDEmptyAutomata (this);
 233                                 return emptyAutomata;
 234                         }
 235                 }
 236
 237                 public DTDAnyAutomata Any {
 238                         get {
 239                                 if (anyAutomata == null)
 240                                         anyAutomata = new DTDAnyAutomata (this);
 241                                 return anyAutomata;
 242                         }
 243                 }
 244
 245                 public DTDInvalidAutomata Invalid {
 246                         get {
 247                                 if (invalidAutomata == null)
 248                                         invalidAutomata = new DTDInvalidAutomata (this);
 249                                 return invalidAutomata;
 250                         }
 251                 }
 252
 253                 public XmlSchemaException [] Errors {
 254                         get { return validationErrors.ToArray (typeof (XmlSchemaException)) as XmlSchemaException []; }
 255                 }
 256
 257                 public void AddError (XmlSchemaException ex)
 258                 {
 259                         validationErrors.Add (ex);
 260                 }
 261
 262                 internal string GenerateEntityAttributeText (string entityName)
 263                 {
 264                         DTDEntityDeclaration entity = EntityDecls [entityName] as DTDEntityDeclaration;
 265                         if (entity == null)
 266                                 return null;
 267                         return entity.EntityValue;
 268                 }
 269
 270                 internal XmlTextReaderImpl GenerateEntityContentReader (string entityName, XmlParserContext context)
 271                 {
 272                         DTDEntityDeclaration entity = EntityDecls [entityName] as DTDEntityDeclaration;
 273                         if (entity == null)
 274                                 return null;
 275
 276                         if (entity.SystemId != null) {
 277                                 Uri baseUri = entity.BaseURI == String.Empty ? null : new Uri (entity.BaseURI);
 278                                 Stream stream = resolver.GetEntity (resolver.ResolveUri (baseUri, entity.SystemId), null, typeof (Stream)) as Stream;
 279                                 return new XmlTextReaderImpl (stream, XmlNodeType.Element, context);
 280                         }
 281                         else
 282                                 return new XmlTextReaderImpl (entity.EntityValue, XmlNodeType.Element, context);
 283                 }
 284         }
 285
 286 #if NET_2_0
 287         class DictionaryBase : List<KeyValuePair<string,DTDNode>>
 288         {
 289                 public IEnumerable<DTDNode> Values {
 290                         get {
 291                                 foreach (KeyValuePair<string,DTDNode> p in this)
 292                                         yield return p.Value;
 293                         }
 294                 }
 295         }
 296 #endif
 297         internal class DTDCollectionBase : DictionaryBase
 298         {
 299                 DTDObjectModel root;
 300
 301                 protected DTDCollectionBase (DTDObjectModel root)
 302                 {
 303                         this.root = root;
 304                 }
 305
 306                 protected DTDObjectModel Root {
 307                         get { return root; }
 308                 }
 309
 310 #if NET_2_0
 311                 public DictionaryBase InnerHashtable {
 312                         get { return this; }
 313                 }
 314
 315                 protected void BaseAdd (string name, DTDNode value)
 316                 {
 317                         base.Add (new KeyValuePair<string,DTDNode> (name, value));
 318                 }
 319
 320                 public bool Contains (string key)
 321                 {
 322                         foreach (KeyValuePair<string,DTDNode> p in this)
 323                                 if (p.Key == key)
 324                                         return true;
 325                         return false;
 326                 }
 327
 328                 protected object BaseGet (string name)
 329                 {
 330                         foreach (KeyValuePair<string,DTDNode> p in this)
 331                                 if (p.Key == name)
 332                                         return p.Value;
 333                         return null;
 334                 }
 335 #else
 336                 public ICollection Keys {
 337                         get { return InnerHashtable.Keys; }
 338                 }
 339
 340                 public ICollection Values {
 341                         get { return InnerHashtable.Values; }
 342                 }
 343
 344                 protected void BaseAdd (string name, object value)
 345                 {
 346                         InnerHashtable.Add (name, value);
 347                 }
 348
 349                 public bool Contains (string key)
 350                 {
 351                         return InnerHashtable.Contains (key);
 352                 }
 353
 354                 protected object BaseGet (string name)
 355                 {
 356                         return InnerHashtable [name];
 357                 }
 358 #endif
 359         }
 360
 361         internal class DTDElementDeclarationCollection : DTDCollectionBase
 362         {
 363
 364                 public DTDElementDeclarationCollection (DTDObjectModel root) : base (root) {}
 365
 366                 public DTDElementDeclaration this [string name] {
 367                         get { return Get (name); }
 368                 }
 369
 370                 public DTDElementDeclaration Get (string name)
 371                 {
 372                         return BaseGet (name) as DTDElementDeclaration;
 373                 }
 374
 375                 public void Add (string name, DTDElementDeclaration decl)
 376                 {
 377                         if (Contains (name)) {
 378                                 Root.AddError (new XmlSchemaException (String.Format (
 379                                         "Element declaration for {0} was already added.",
 380                                         name), null));
 381                                 return;
 382                         }
 383                         decl.SetRoot (Root);
 384                         BaseAdd (name, decl);
 385                 }
 386         }
 387
 388         internal class DTDAttListDeclarationCollection : DTDCollectionBase
 389         {
 390                 public DTDAttListDeclarationCollection (DTDObjectModel root) : base (root) {}
 391
 392                 public DTDAttListDeclaration this [string name] {
 393                         get { return BaseGet (name) as DTDAttListDeclaration; }
 394                 }
 395
 396                 public void Add (string name, DTDAttListDeclaration decl)
 397                 {
 398                         DTDAttListDeclaration existing = this [name];
 399                         if (existing != null) {
 400                                 // It is valid, that is additive declaration.
 401                                 foreach (DTDAttributeDefinition def in decl.Definitions)
 402                                         if (decl.Get (def.Name) == null)
 403                                                 existing.Add (def);
 404                         } else {
 405                                 decl.SetRoot (Root);
 406                                 BaseAdd (name, decl);
 407                         }
 408                 }
 409         }
 410
 411         internal class DTDEntityDeclarationCollection : DTDCollectionBase
 412         {
 413                 public DTDEntityDeclarationCollection (DTDObjectModel root) : base (root) {}
 414
 415                 public DTDEntityDeclaration this [string name] {
 416                         get { return BaseGet (name) as DTDEntityDeclaration; }
 417                 }
 418
 419                 public void Add (string name, DTDEntityDeclaration decl)
 420                 {
 421                         if (Contains (name))
 422                                 throw new InvalidOperationException (String.Format (
 423                                         "Entity declaration for {0} was already added.",
 424                                         name));
 425                         decl.SetRoot (Root);
 426                         BaseAdd (name, decl);
 427                 }
 428         }
 429
 430         internal class DTDNotationDeclarationCollection : DTDCollectionBase
 431         {
 432                 public DTDNotationDeclarationCollection (DTDObjectModel root) : base (root) {}
 433
 434                 public DTDNotationDeclaration this [string name] {
 435                         get { return BaseGet (name) as DTDNotationDeclaration; }
 436                 }
 437
 438                 public void Add (string name, DTDNotationDeclaration decl)
 439                 {
 440                         if (Contains (name))
 441                                 throw new InvalidOperationException (String.Format (
 442                                         "Notation declaration for {0} was already added.",
 443                                         name));
 444                         decl.SetRoot (Root);
 445                         BaseAdd (name, decl);
 446                 }
 447         }
 448
 449         // This class contains either ElementName or ChildModels.
 450         internal class DTDContentModel : DTDNode
 451         {
 452                 DTDObjectModel root;
 453                 DTDAutomata compiledAutomata;
 454
 455                 string ownerElementName;
 456                 string elementName;
 457                 DTDContentOrderType orderType = DTDContentOrderType.None;
 458                 DTDContentModelCollection childModels = new DTDContentModelCollection ();
 459                 DTDOccurence occurence = DTDOccurence.One;
 460
 461                 internal DTDContentModel (DTDObjectModel root, string ownerElementName)
 462                 {
 463                         this.root = root;
 464                         this.ownerElementName = ownerElementName;
 465                 }
 466
 467                 public DTDContentModelCollection ChildModels {
 468                         get { return childModels; }
 469                         set { childModels = value; }
 470                 }
 471
 472                 public DTDElementDeclaration ElementDecl {
 473                         get { return root.ElementDecls [ownerElementName]; }
 474                 }
 475
 476                 public string ElementName {
 477                         get { return elementName; }
 478                         set { elementName = value; }
 479                 }
 480
 481                 public DTDOccurence Occurence {
 482                         get { return occurence; }
 483                         set { occurence = value; }
 484                 }
 485
 486                 public DTDContentOrderType OrderType {
 487                         get { return orderType; }
 488                         set { orderType = value; }
 489                 }
 490
 491                 public DTDAutomata GetAutomata ()
 492                 {
 493                         if (compiledAutomata == null)
 494                                 Compile ();
 495                         return compiledAutomata;
 496                 }
 497
 498                 public DTDAutomata Compile ()
 499                 {
 500                         compiledAutomata = CompileInternal ();
 501                         return compiledAutomata;
 502                 }
 503
 504 #if !NET_2_1
 505                 internal XmlSchemaParticle CreateXsdParticle ()
 506                 {
 507                         XmlSchemaParticle p = CreateXsdParticleCore ();
 508                         if (p == null)
 509                                 return null;
 510
 511                         switch (Occurence) {
 512                         case DTDOccurence.Optional:
 513                                 p.MinOccurs = 0;
 514                                 break;
 515                         case DTDOccurence.OneOrMore:
 516                                 p.MaxOccursString = "unbounded";
 517                                 break;
 518                         case DTDOccurence.ZeroOrMore:
 519                                 p.MinOccurs = 0;
 520                                 p.MaxOccursString = "unbounded";
 521                                 break;
 522                         }
 523                         return p;
 524                 }
 525
 526                 XmlSchemaParticle CreateXsdParticleCore ()
 527                 {
 528                         XmlSchemaParticle p = null;
 529                         if (ElementName != null) {
 530                                 XmlSchemaElement el = new XmlSchemaElement ();
 531                                 SetLineInfo (el);
 532                                 el.RefName = new XmlQualifiedName (ElementName);
 533                                 return el;
 534                         }
 535                         else if (ChildModels.Count == 0)
 536                                 return null;
 537                         else {
 538                                 XmlSchemaGroupBase gb =
 539                                         (OrderType == DTDContentOrderType.Seq) ?
 540                                                 (XmlSchemaGroupBase)
 541                                                 new XmlSchemaSequence () :
 542                                                 new XmlSchemaChoice ();
 543                                 SetLineInfo (gb);
 544                                 foreach (DTDContentModel cm in ChildModels.Items) {
 545                                         XmlSchemaParticle c = cm.CreateXsdParticle ();
 546                                         if (c != null)
 547                                                 gb.Items.Add (c);
 548                                 }
 549                                 p = gb;
 550                         }
 551                         return p;
 552                 }
 553 #endif
 554
 555                 private DTDAutomata CompileInternal ()
 556                 {
 557                         if (ElementDecl.IsAny)
 558                                 return root.Any;
 559                         if (ElementDecl.IsEmpty)
 560                                 return root.Empty;
 561
 562                         DTDAutomata basis = GetBasicContentAutomata ();
 563                         switch (Occurence) {
 564                         case DTDOccurence.One:
 565                                 return basis;
 566                         case DTDOccurence.Optional:
 567                                 return Choice (root.Empty, basis);
 568                         case DTDOccurence.OneOrMore:
 569                                 return new DTDOneOrMoreAutomata (root, basis);
 570                         case DTDOccurence.ZeroOrMore:
 571                                 return Choice (root.Empty, new DTDOneOrMoreAutomata (root, basis));
 572                         }
 573                         throw new InvalidOperationException ();
 574                 }
 575
 576                 private DTDAutomata GetBasicContentAutomata ()
 577                 {
 578                         if (ElementName != null)
 579                                 return new DTDElementAutomata (root, ElementName);
 580                         switch (ChildModels.Count) {
 581                         case 0:
 582                                 return root.Empty;
 583                         case 1:
 584                                 return ChildModels [0].GetAutomata ();
 585                         }
 586
 587                         DTDAutomata current = null;
 588                         int childCount = ChildModels.Count;
 589                         switch (OrderType) {
 590                         case DTDContentOrderType.Seq:
 591                                 current = Sequence (
 592                                         ChildModels [childCount - 2].GetAutomata (),
 593                                         ChildModels [childCount - 1].GetAutomata ());
 594                                 for (int i = childCount - 2; i > 0; i--)
 595                                         current = Sequence (
 596                                                 ChildModels [i - 1].GetAutomata (), current);
 597                                 return current;
 598                         case DTDContentOrderType.Or:
 599                                 current = Choice (
 600                                         ChildModels [childCount - 2].GetAutomata (),
 601                                         ChildModels [childCount - 1].GetAutomata ());
 602                                 for (int i = childCount - 2; i > 0; i--)
 603                                         current = Choice (
 604                                                 ChildModels [i - 1].GetAutomata (), current);
 605                                 return current;
 606                         default:
 607                                 throw new InvalidOperationException ("Invalid pattern specification");
 608                         }
 609                 }
 610
 611                 private DTDAutomata Sequence (DTDAutomata l, DTDAutomata r)
 612                 {
 613                         return root.Factory.Sequence (l, r);
 614                 }
 615
 616                 private DTDAutomata Choice (DTDAutomata l, DTDAutomata r)
 617                 {
 618                         return l.MakeChoice (r);
 619                 }
 620         }
 621
 622         internal class DTDContentModelCollection
 623         {
 624                 ArrayList contentModel = new ArrayList ();
 625
 626                 public DTDContentModelCollection ()
 627                 {
 628                 }
 629
 630                 public IList Items {
 631                         get { return contentModel; }
 632                 }
 633
 634                 public DTDContentModel this [int i] {
 635                         get { return contentModel [i] as DTDContentModel; }
 636                 }
 637
 638                 public int Count {
 639                         get { return contentModel.Count; }
 640                 }
 641
 642                 public void Add (DTDContentModel model)
 643                 {
 644                         contentModel.Add (model);
 645                 }
 646         }
 647
 648         internal abstract class DTDNode : IXmlLineInfo
 649         {
 650                 DTDObjectModel root;
 651                 bool isInternalSubset;
 652                 string baseURI;
 653                 int lineNumber;
 654                 int linePosition;
 655
 656                 public virtual string BaseURI {
 657                         get { return baseURI; }
 658                         set { baseURI = value; }
 659                 }
 660
 661                 public bool IsInternalSubset {
 662                         get { return isInternalSubset; }
 663                         set { isInternalSubset = value; }
 664                 }
 665
 666                 public int LineNumber {
 667                         get { return lineNumber; }
 668                         set { lineNumber = value; }
 669                 }
 670
 671                 public int LinePosition {
 672                         get { return linePosition; }
 673                         set { linePosition = value; }
 674                 }
 675
 676                 public bool HasLineInfo ()
 677                 {
 678                         return lineNumber != 0;
 679                 }
 680
 681                 internal void SetRoot (DTDObjectModel root)
 682                 {
 683                         this.root = root;
 684                         if (baseURI == null)
 685                                 this.BaseURI = root.BaseURI;
 686                 }
 687
 688                 protected DTDObjectModel Root {
 689                         get { return root; }
 690                 }
 691
 692                 internal XmlException NotWFError (string message)
 693                 {
 694                         return new XmlException (this as IXmlLineInfo, BaseURI, message);
 695                 }
 696
 697 #if !NET_2_1
 698                 public void SetLineInfo (XmlSchemaObject obj)
 699                 {
 700                         obj.SourceUri = BaseURI;
 701                         obj.LineNumber = LineNumber;
 702                         obj.LinePosition = LinePosition;
 703                 }
 704 #endif
 705         }
 706
 707         internal class DTDElementDeclaration : DTDNode
 708         {
 709                 DTDObjectModel root;
 710                 DTDContentModel contentModel;
 711                 string name;
 712                 bool isEmpty;
 713                 bool isAny;
 714                 bool isMixedContent;
 715
 716                 internal DTDElementDeclaration (DTDObjectModel root)
 717                 {
 718                         this.root = root;
 719                 }
 720
 721                 public string Name {
 722                         get { return name; }
 723                         set { name = value; }
 724                 }
 725                 public bool IsEmpty {
 726                         get { return isEmpty; }
 727                         set { isEmpty = value; }
 728                 }
 729
 730                 public bool IsAny {
 731                         get { return isAny; }
 732                         set { isAny = value; }
 733                 }
 734
 735                 public bool IsMixedContent {
 736                         get { return isMixedContent; }
 737                         set { isMixedContent = value; }
 738                 }
 739
 740                 public DTDContentModel ContentModel {
 741                         get {
 742                                 if (contentModel == null)
 743                                         contentModel = new DTDContentModel (root, Name);
 744                                 return contentModel;
 745                         }
 746                 }
 747
 748                 public DTDAttListDeclaration Attributes {
 749                         get {
 750                                 return Root.AttListDecls [Name];
 751                         }
 752                 }
 753
 754 #if !NET_2_1
 755                 internal XmlSchemaElement CreateXsdElement ()
 756                 {
 757                         XmlSchemaElement el = new XmlSchemaElement ();
 758                         SetLineInfo (el);
 759                         el.Name = Name;
 760
 761                         XmlSchemaComplexType ct = new XmlSchemaComplexType ();
 762                         el.SchemaType = ct;
 763                         if (Attributes != null) {
 764                                 SetLineInfo (ct);
 765                                 foreach (DTDAttributeDefinition a in
 766                                         Attributes.Definitions)
 767                                         ct.Attributes.Add (a.CreateXsdAttribute ());
 768                         }
 769                         if (IsEmpty)
 770                                 ; // nothing to do
 771                         else if (IsAny) {
 772                                 XmlSchemaAny any = new XmlSchemaAny ();
 773                                 any.MinOccurs = 0;
 774                                 any.MaxOccursString = "unbounded";
 775                                 ct.Particle = any;
 776                         }
 777                         else {
 778                                 if (IsMixedContent)
 779                                         ct.IsMixed = true;
 780                                 ct.Particle = ContentModel.CreateXsdParticle ();
 781                         }
 782
 783                         /*
 784                         if (IsEmpty) {
 785                                 el.SchemaType = new XmlSchemaComplexType ();
 786                                 SetLineInfo (el.SchemaType);
 787                         }
 788                         else if (IsAny)
 789                                 el.SchemaTypeName = new XmlQualifiedName (
 790                                         "anyType", XmlSchema.Namespace);
 791                         else {
 792                                 XmlSchemaComplexType ct = new XmlSchemaComplexType ();
 793                                 SetLineInfo (ct);
 794                                 if (Attributes != null)
 795                                         foreach (DTDAttributeDefinition a in
 796                                                 Attributes.Definitions)
 797                                                 ct.Attributes.Add (a.CreateXsdAttribute ());
 798                                 if (IsMixedContent)
 799                                         ct.IsMixed = true;
 800                                 ct.Particle = ContentModel.CreateXsdParticle ();
 801                                 el.SchemaType = ct;
 802                         }
 803                         */
 804                         return el;
 805                 }
 806 #endif
 807         }
 808
 809         internal class DTDAttributeDefinition : DTDNode
 810         {
 811                 string name;
 812                 XmlSchemaDatatype datatype;
 813                 ArrayList enumeratedLiterals;
 814                 string unresolvedDefault;
 815                 ArrayList enumeratedNotations;
 816                 DTDAttributeOccurenceType occurenceType = DTDAttributeOccurenceType.None;
 817                 string resolvedDefaultValue;
 818                 string resolvedNormalizedDefaultValue;
 819
 820                 internal DTDAttributeDefinition (DTDObjectModel root)
 821                 {
 822                         this.SetRoot (root);
 823                 }
 824
 825                 public string Name {
 826                         get { return name; }
 827                         set { name =value; }
 828                 }
 829
 830                 public XmlSchemaDatatype Datatype {
 831                         get { return datatype; }
 832                         set { datatype = value; }
 833                 }
 834
 835                 public DTDAttributeOccurenceType OccurenceType {
 836                         get { return this.occurenceType; }
 837                         set { this.occurenceType = value; }
 838                 }
 839
 840                 // entity reference inside enumerated values are not allowed,
 841                 // but on the other hand, they are allowed inside default value.
 842                 // Then I decided to use string ArrayList for enumerated values,
 843                 // and unresolved string value for DefaultValue.
 844                 public ArrayList EnumeratedAttributeDeclaration {
 845                         get {
 846                                 if (enumeratedLiterals == null)
 847                                         enumeratedLiterals = new ArrayList ();
 848                                 return this.enumeratedLiterals;
 849                         }
 850                 }
 851
 852                 public ArrayList EnumeratedNotations {
 853                         get {
 854                                 if (enumeratedNotations == null)
 855                                         enumeratedNotations = new ArrayList ();
 856                                 return this.enumeratedNotations;
 857                         }
 858                 }
 859
 860                 public string DefaultValue {
 861                         get {
 862                                 if (resolvedDefaultValue == null)
 863                                         resolvedDefaultValue = ComputeDefaultValue ();
 864                                 return resolvedDefaultValue;
 865                         }
 866                 }
 867
 868                 public string NormalizedDefaultValue {
 869                         get {
 870                                 if (resolvedNormalizedDefaultValue == null) {
 871                                         string s = ComputeDefaultValue ();
 872                                         try {
 873                                                 object o = Datatype.ParseValue (s, null, null);
 874                                                 resolvedNormalizedDefaultValue =
 875                                                         (o is string []) ?
 876                                                         String.Join (" ", (string []) o) :
 877                                                         o is IFormattable ? ((IFormattable) o).ToString (null, CultureInfo.InvariantCulture) : o.ToString ();
 878                                         } catch (Exception) {
 879                                                 // This is for non-error-reporting reader
 880                                                 resolvedNormalizedDefaultValue = Datatype.Normalize (s);
 881                                         }
 882                                 }
 883                                 return resolvedNormalizedDefaultValue;
 884                         }
 885                 }
 886
 887                 public string UnresolvedDefaultValue {
 888                         get { return this.unresolvedDefault; }
 889                         set { this.unresolvedDefault = value; }
 890                 }
 891
 892                 public char QuoteChar {
 893                         get {
 894                                 return UnresolvedDefaultValue.Length > 0 ?
 895                                         this.UnresolvedDefaultValue [0] :
 896                                         '"';
 897                         }
 898                 }
 899
 900 #if !NET_2_1
 901                 internal XmlSchemaAttribute CreateXsdAttribute ()
 902                 {
 903                         XmlSchemaAttribute a = new XmlSchemaAttribute ();
 904                         SetLineInfo (a);
 905                         a.Name = Name;
 906                         a.DefaultValue = resolvedNormalizedDefaultValue;
 907                         if (OccurenceType != DTDAttributeOccurenceType.Required)
 908                                 a.Use = XmlSchemaUse.Optional;
 909
 910                         XmlQualifiedName qname = XmlQualifiedName.Empty;
 911                         ArrayList enumeration = null;
 912                         if (enumeratedNotations != null && enumeratedNotations.Count > 0) {
 913                                 qname = new XmlQualifiedName ("NOTATION", XmlSchema.Namespace);
 914                                 enumeration = enumeratedNotations;
 915                         }
 916                         else if (enumeratedLiterals != null)
 917                                 enumeration = enumeratedLiterals;
 918                         else {
 919                                 switch (Datatype.TokenizedType) {
 920                                 case XmlTokenizedType.ID:
 921                                         qname = new XmlQualifiedName ("ID", XmlSchema.Namespace); break;
 922                                 case XmlTokenizedType.IDREF:
 923                                         qname = new XmlQualifiedName ("IDREF", XmlSchema.Namespace); break;
 924                                 case XmlTokenizedType.IDREFS:
 925                                         qname = new XmlQualifiedName ("IDREFS", XmlSchema.Namespace); break;
 926                                 case XmlTokenizedType.ENTITY:
 927                                         qname = new XmlQualifiedName ("ENTITY", XmlSchema.Namespace); break;
 928                                 case XmlTokenizedType.ENTITIES:
 929                                         qname = new XmlQualifiedName ("ENTITIES", XmlSchema.Namespace); break;
 930                                 case XmlTokenizedType.NMTOKEN:
 931                                         qname = new XmlQualifiedName ("NMTOKEN", XmlSchema.Namespace); break;
 932                                 case XmlTokenizedType.NMTOKENS:
 933                                         qname = new XmlQualifiedName ("NMTOKENS", XmlSchema.Namespace); break;
 934                                 case XmlTokenizedType.NOTATION:
 935                                         qname = new XmlQualifiedName ("NOTATION", XmlSchema.Namespace); break;
 936                                 }
 937                         }
 938
 939                         if (enumeration != null) {
 940                                 XmlSchemaSimpleType st = new XmlSchemaSimpleType ();
 941                                 SetLineInfo (st);
 942                                 XmlSchemaSimpleTypeRestriction r =
 943                                         new XmlSchemaSimpleTypeRestriction ();
 944                                 SetLineInfo (r);
 945                                 r.BaseTypeName = qname;
 946                                 if (enumeratedNotations != null) {
 947                                         foreach (string name in enumeratedNotations) {
 948                                                 XmlSchemaEnumerationFacet f =
 949                                                         new XmlSchemaEnumerationFacet ();
 950                                                 SetLineInfo (f);
 951                                                 r.Facets.Add (f);
 952                                                 f.Value = name;
 953                                         }
 954                                 }
 955                                 st.Content = r;
 956                         }
 957                         else if (qname != XmlQualifiedName.Empty)
 958                                 a.SchemaTypeName = qname;
 959                         return a;
 960                 }
 961 #endif
 962
 963                 internal string ComputeDefaultValue ()
 964                 {
 965                         if (UnresolvedDefaultValue == null)
 966                                 return null;
 967
 968                         StringBuilder sb = new StringBuilder ();
 969                         int pos = 0;
 970                         int next = 0;
 971                         string value = this.UnresolvedDefaultValue;
 972                         while ((next = value.IndexOf ('&', pos)) >= 0) {
 973                                 int semicolon = value.IndexOf (';', next);
 974                                 if (value [next + 1] == '#') {
 975                                         // character reference.
 976                                         char c = value [next + 2];
 977                                         NumberStyles style = NumberStyles.Integer;
 978                                         string spec;
 979                                         if (c == 'x' || c == 'X') {
 980                                                 spec = value.Substring (next + 3, semicolon - next - 3);
 981                                                 style |= NumberStyles.HexNumber;
 982                                         }
 983                                         else
 984                                                 spec = value.Substring (next + 2, semicolon - next - 2);
 985                                         sb.Append ((char) int.Parse (spec, style, CultureInfo.InvariantCulture));
 986                                 } else {
 987                                         sb.Append (value.Substring (pos, next - 1));
 988                                         string name = value.Substring (next + 1, semicolon - 2);
 989                                         int predefined = XmlChar.GetPredefinedEntity (name);
 990                                         if (predefined >= 0)
 991                                                 sb.Append (predefined);
 992                                         else
 993                                                 sb.Append (Root.ResolveEntity (name));
 994                                 }
 995                                 pos = semicolon + 1;
 996                         }
 997                         sb.Append (value.Substring (pos));
 998                         // strip quote chars
 999                         string ret = sb.ToString (1, sb.Length - 2);
1000                         sb.Length = 0;
1001                         return ret;
1002                 }
1003
1004         }
1005
1006         internal class DTDAttListDeclaration : DTDNode
1007         {
1008                 string name;
1009                 Hashtable attributeOrders = new Hashtable ();
1010                 ArrayList attributes = new ArrayList ();
1011
1012                 internal DTDAttListDeclaration (DTDObjectModel root)
1013                 {
1014                         SetRoot (root);
1015                 }
1016
1017                 public string Name {
1018                         get { return name; }
1019                         set { name = value; }
1020                 }
1021
1022                 public DTDAttributeDefinition this [int i] {
1023                         get { return Get (i); }
1024                 }
1025
1026                 public DTDAttributeDefinition this [string name] {
1027                         get { return Get (name); }
1028                 }
1029
1030                 public DTDAttributeDefinition Get (int i)
1031                 {
1032                         return attributes [i] as DTDAttributeDefinition;
1033                 }
1034
1035                 public DTDAttributeDefinition Get (string name)
1036                 {
1037                         object o = attributeOrders [name];
1038                         if (o != null)
1039                                 return attributes [(int) o] as DTDAttributeDefinition;
1040                         else
1041                                 return null;
1042                 }
1043
1044                 public IList Definitions {
1045                         get { return attributes; }
1046                 }
1047
1048                 public void Add (DTDAttributeDefinition def)
1049                 {
1050                         if (attributeOrders [def.Name] != null)
1051                                 throw new InvalidOperationException (String.Format (
1052                                         "Attribute definition for {0} was already added at element {1}.",
1053                                         def.Name, this.Name));
1054                         def.SetRoot (Root);
1055                         attributeOrders.Add (def.Name, attributes.Count);
1056                         attributes.Add (def);
1057                 }
1058
1059                 public int Count {
1060                         get { return attributeOrders.Count; }
1061                 }
1062         }
1063
1064         internal class DTDEntityBase : DTDNode
1065         {
1066                 string name;
1067                 string publicId;
1068                 string systemId;
1069                 string literalValue;
1070                 string replacementText;
1071                 string uriString;
1072                 Uri absUri;
1073                 bool isInvalid;
1074 //              Exception loadException;
1075                 bool loadFailed;
1076                 XmlResolver resolver;
1077
1078                 protected DTDEntityBase (DTDObjectModel root)
1079                 {
1080                         SetRoot (root);
1081                 }
1082
1083                 internal bool IsInvalid {
1084                         get { return isInvalid; }
1085                         set { isInvalid = value; }
1086                 }
1087
1088                 public bool LoadFailed {
1089                         get { return loadFailed; }
1090                         set { loadFailed = value; }
1091                 }
1092
1093                 public string Name {
1094                         get { return name; }
1095                         set { name = value; }
1096                 }
1097
1098                 public string PublicId {
1099                         get { return publicId; }
1100                         set { publicId = value; }
1101                 }
1102
1103                 public string SystemId {
1104                         get { return systemId; }
1105                         set { systemId = value; }
1106                 }
1107
1108                 public string LiteralEntityValue {
1109                         get { return literalValue; }
1110                         set { literalValue = value; }
1111                 }
1112
1113                 public string ReplacementText {
1114                         get { return replacementText; }
1115                         set { replacementText = value; }
1116                 }
1117
1118                 public XmlResolver XmlResolver {
1119                         set { resolver = value; }
1120                 }
1121
1122                 public string ActualUri {
1123                         get {
1124                                 if (uriString == null) {
1125                                         if (resolver == null || SystemId == null || SystemId.Length == 0)
1126                                                 uriString = BaseURI;
1127                                         else {
1128                                                 Uri baseUri = null;
1129                                                 try {
1130                                                         if (BaseURI != null && BaseURI.Length > 0)
1131                                                                 baseUri = new Uri (BaseURI);
1132                                                 } catch (UriFormatException) {
1133                                                 }
1134
1135                                                 absUri = resolver.ResolveUri (baseUri, SystemId);
1136                                                 uriString = absUri != null ? absUri.ToString () : String.Empty;
1137                                         }
1138                                 }
1139                                 return uriString;
1140                         }
1141                 }
1142
1143                 public void Resolve ()
1144                 {
1145                         if (ActualUri == String.Empty) {
1146                                 LoadFailed = true;
1147                                 LiteralEntityValue = String.Empty;
1148                                 return;
1149                         }
1150
1151                         if (Root.ExternalResources.ContainsKey (ActualUri))
1152                                 LiteralEntityValue = (string) Root.ExternalResources [ActualUri];
1153                         Stream s = null;
1154                         try {
1155                                 s = resolver.GetEntity (absUri, null, typeof (Stream)) as Stream;
1156                                 XmlTextReaderImpl xtr = new XmlTextReaderImpl (ActualUri, s, Root.NameTable);
1157                                 // Don't skip Text declaration here. LiteralEntityValue contains it. See spec 4.5
1158                                 LiteralEntityValue = xtr.GetRemainder ().ReadToEnd ();
1159
1160                                 Root.ExternalResources.Add (ActualUri, LiteralEntityValue);
1161                                 if (Root.ExternalResources.Count > DTDObjectModel.AllowedExternalEntitiesMax)
1162                                         throw new InvalidOperationException ("The total amount of external entities exceeded the allowed number.");
1163
1164                         } catch (Exception ex) {
1165 //                              loadException = ex;
1166                                 LiteralEntityValue = String.Empty;
1167                                 LoadFailed = true;
1168 //                              throw NotWFError ("Cannot resolve external entity. URI is " + ActualUri + " .");
1169                         } finally {
1170                                 if (s != null)
1171                                         s.Close ();
1172                         }
1173                 }
1174         }
1175
1176         internal class DTDEntityDeclaration : DTDEntityBase
1177         {
1178                 string entityValue;
1179                 string notationName;
1180
1181                 ArrayList ReferencingEntities = new ArrayList ();
1182
1183                 bool scanned;
1184                 bool recursed;
1185                 bool hasExternalReference;
1186
1187                 internal DTDEntityDeclaration (DTDObjectModel root) : base (root)
1188                 {
1189                 }
1190
1191                 public string NotationName {
1192                         get { return notationName; }
1193                         set { notationName = value; }
1194                 }
1195
1196                 public bool HasExternalReference {
1197                         get {
1198                                 if (!scanned)
1199                                         ScanEntityValue (new ArrayList ());
1200                                 return hasExternalReference;
1201                         }
1202                 }
1203
1204                 public string EntityValue {
1205                         get {
1206                                 if (this.IsInvalid)
1207                                         return String.Empty;
1208
1209                                 if (PublicId == null && SystemId == null && LiteralEntityValue == null)
1210                                         return String.Empty;
1211
1212                                 if (entityValue == null) {
1213                                         if (NotationName != null)
1214                                                 entityValue = "";
1215                                         else if (SystemId == null || SystemId == String.Empty) {
1216                                                 entityValue = ReplacementText;
1217                                                 if (entityValue == null)
1218                                                         entityValue = String.Empty;
1219                                         } else {
1220                                                 entityValue = ReplacementText;
1221                                         }
1222                                         // Check illegal recursion.
1223                                         ScanEntityValue (new ArrayList ());
1224                                 }
1225                                 return entityValue;
1226                         }
1227                 }
1228
1229                 // It returns whether the entity contains references to external entities.
1230                 public void ScanEntityValue (ArrayList refs)
1231                 {
1232                         // To modify this code, beware nesting between this and EntityValue.
1233                         string value = EntityValue;
1234                         if (this.SystemId != null)
1235                                 hasExternalReference = true;
1236
1237                         if (recursed)
1238                                 throw NotWFError ("Entity recursion was found.");
1239                         recursed = true;
1240
1241                         if (scanned) {
1242                                 foreach (string referenced in refs)
1243                                         if (this.ReferencingEntities.Contains (referenced))
1244                                                 throw NotWFError (String.Format (
1245                                                         "Nested entity was found between {0} and {1}",
1246                                                         referenced, Name));
1247                                 recursed = false;
1248                                 return;
1249                         }
1250
1251                         int len = value.Length;
1252                         int start = 0;
1253                         for (int i=0; i<len; i++) {
1254                                 switch (value [i]) {
1255                                 case '&':
1256                                         start = i+1;
1257                                         break;
1258                                 case ';':
1259                                         if (start == 0)
1260                                                 break;
1261                                         string name = value.Substring (start, i - start);
1262                                         if (name.Length == 0)
1263                                                 throw NotWFError ("Entity reference name is missing.");
1264                                         if (name [0] == '#')
1265                                                 break;  // character reference
1266                                         if (XmlChar.GetPredefinedEntity (name) >= 0)
1267                                                 break;  // predefined reference
1268
1269                                         this.ReferencingEntities.Add (name);
1270                                         DTDEntityDeclaration decl = Root.EntityDecls [name];
1271                                         if (decl != null) {
1272                                                 if (decl.SystemId != null)
1273                                                         hasExternalReference = true;
1274                                                 refs.Add (Name);
1275                                                 decl.ScanEntityValue (refs);
1276                                                 foreach (string str in decl.ReferencingEntities)
1277                                                         ReferencingEntities.Add (str);
1278                                                 refs.Remove (Name);
1279                                                 value = value.Remove (start - 1, name.Length + 2);
1280                                                 value = value.Insert (start - 1, decl.EntityValue);
1281                                                 i -= name.Length + 1; // not +2, because of immediate i++ .
1282                                                 len = value.Length;
1283                                         }
1284                                         start = 0;
1285                                         break;
1286                                 }
1287                         }
1288                         if (start != 0)
1289 #if NET_2_1
1290                                 Root.AddError (new XmlSchemaException (this, this.BaseURI, "Invalid reference character '&' is specified."));
1291 #else
1292                                 Root.AddError (new XmlSchemaException ("Invalid reference character '&' is specified.",
1293                                         this.LineNumber, this.LinePosition, null, this.BaseURI, null));
1294 #endif
1295                         scanned = true;
1296                         recursed = false;
1297                 }
1298         }
1299
1300         internal class DTDNotationDeclaration : DTDNode
1301         {
1302                 string name;
1303                 string localName;
1304                 string prefix;
1305                 string publicId;
1306                 string systemId;
1307
1308                 public string Name {
1309                         get { return name; }
1310                         set { name = value; }
1311                 }
1312
1313                 public string PublicId {
1314                         get { return publicId; }
1315                         set { publicId = value; }
1316                 }
1317
1318                 public string SystemId {
1319                         get { return systemId; }
1320                         set { systemId = value; }
1321                 }
1322
1323                 public string LocalName {
1324                         get { return localName; }
1325                         set { localName = value; }
1326                 }
1327
1328                 public string Prefix {
1329                         get { return prefix; }
1330                         set { prefix = value; }
1331                 }
1332
1333                 internal DTDNotationDeclaration (DTDObjectModel root)
1334                 {
1335                         SetRoot (root);
1336                 }
1337         }
1338
1339         internal class DTDParameterEntityDeclarationCollection
1340         {
1341                 Hashtable peDecls = new Hashtable ();
1342                 DTDObjectModel root;
1343
1344                 public DTDParameterEntityDeclarationCollection (DTDObjectModel root)
1345                 {
1346                         this.root = root;
1347                 }
1348
1349                 public DTDParameterEntityDeclaration this [string name] {
1350                         get { return peDecls [name] as DTDParameterEntityDeclaration; }
1351                 }
1352
1353                 public void Add (string name, DTDParameterEntityDeclaration decl)
1354                 {
1355                         // PEDecl can be overriden.
1356                         if (peDecls [name] != null)
1357                                 return;
1358                         decl.SetRoot (root);
1359                         peDecls.Add (name, decl);
1360                 }
1361
1362                 public ICollection Keys {
1363                         get { return peDecls.Keys; }
1364                 }
1365
1366                 public ICollection Values {
1367                         get { return peDecls.Values; }
1368                 }
1369         }
1370
1371         internal class DTDParameterEntityDeclaration : DTDEntityBase
1372         {
1373                 internal DTDParameterEntityDeclaration (DTDObjectModel root) : base (root)
1374                 {
1375                 }
1376         }
1377
1378         internal enum DTDContentOrderType
1379         {
1380                 None,
1381                 Seq,
1382                 Or
1383         }
1384
1385         internal enum DTDAttributeOccurenceType
1386         {
1387                 None,
1388                 Required,
1389                 Optional,
1390                 Fixed
1391         }
1392
1393         internal enum DTDOccurence
1394         {
1395                 One,
1396                 Optional,
1397                 ZeroOrMore,
1398                 OneOrMore
1399         }
1400 }