开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
SgmlParser.cs
资源名称：SgmlReader.zip　[点击查看]
上传用户：jingke1993
上传日期：2022-06-08
资源大小：140k
文件大小：73k
源码类别：

xml/soap/webservice

开发平台：

Visual C++

SgmlParser.cs：源码内容
  1. using System;
  2. using System.IO;
  3. using System.Collections;
  4. using System.Text;
  5. using System.Net;
  6. using System.Xml;
  7. using System.Globalization;
  9. namespace Sgml {
  10.     public enum LiteralType {
  11.         CDATA, SDATA, PI
  12.     };
  14.     public class Entity {
  15.         public const Char EOF = (char)65535;
  16.         public string Proxy;
  17.         public string Name;
  18.         public bool Internal;
  19.         public string PublicId;
  20.         public string Uri;
  21.         public string Literal;
  22.         public LiteralType LiteralType;
  23.         public Entity Parent;
  24.         public bool Html;
  25.         public int Line;
  26.         public char Lastchar;
  27.         public bool IsWhitespace;
  29.         Encoding encoding;
  30.         Uri resolvedUri;
  31.         TextReader stm;
  32.         bool weOwnTheStream;
  33.         int lineStart;
  34.         int absolutePos;
  36.         public Entity(string name, string pubid, string uri, string proxy) {
  37.             Name = name;
  38.             PublicId = pubid;
  39.             Uri = uri;
  40.             Proxy = proxy;
  41.             Html = (name != null && StringUtilities.EqualsIgnoreCase(name, "html"));
  42.         }
  44.         public Entity(string name, string literal) {
  45.             Name = name;
  46.             Literal = literal;
  47.             Internal = true;
  48.         }
  50.         public Entity(string name, Uri baseUri, TextReader stm, string proxy) {
  51.             Name = name;
  52.             Internal = true;
  53.             this.stm = stm;
  54.             this.resolvedUri = baseUri;
  55.             Proxy = proxy;
  56.             Html = (string.Compare(name, "html", true, CultureInfo.InvariantCulture) == 0);
  57.         }
  59.         public Uri ResolvedUri {
  60.             get {
  61.                 if (this.resolvedUri != null) return this.resolvedUri;
  62.                 else if (Parent != null) return Parent.ResolvedUri;
  63.                 return null;
  64.             }
  65.         }
  67.         public int LinePosition {
  68.             get { return this.absolutePos - this.lineStart + 1; }
  69.         }
  71.         public char ReadChar() {
  72.             char ch = (char)this.stm.Read();
  73.             if (ch == 0) {
  74.                 // convert nulls to whitespace, since they are not valid in XML anyway.
  75.                 ch = ' ';
  76.             }
  77.             this.absolutePos++;
  78.             if (ch == 0xa) {
  79.                 IsWhitespace = true;
  80.                 this.lineStart = this.absolutePos+1;
  81.                 Line++;
  82.             } 
  83.             else if (ch == ' ' || ch == 't') {
  84.                 IsWhitespace = true;
  85.                 if (Lastchar == 0xd) {
  86.                     this.lineStart = this.absolutePos;
  87.                     Line++;
  88.                 }
  89.             }
  90.             else if (ch == 0xd) {
  91.                 IsWhitespace = true;
  92.             }
  93.             else {
  94.                 IsWhitespace = false;
  95.                 if (Lastchar == 0xd) {
  96.                     Line++;
  97.                     this.lineStart = this.absolutePos;
  98.                 }
  99.             } 
  100.             Lastchar = ch;
  101.             return ch;
  102.         }
  104.         public void Open(Entity parent, Uri baseUri) {
  105.             Parent = parent;
  106.             if (parent != null) this.Html = parent.Html;
  107.             this.Line = 1;
  108.             if (Internal) {
  109.                 if (this.Literal != null)
  110.                     this.stm = new StringReader(this.Literal);
  111.             } 
  112.             else if (this.Uri == null) {
  113.                 this.Error("Unresolvable entity '{0}'", this.Name);
  114.             }
  115.             else {
  116.                 if (baseUri != null) {
  117.                     this.resolvedUri = new Uri(baseUri, this.Uri);
  118.                 }
  119.                 else {
  120.                     this.resolvedUri = new Uri(this.Uri);
  121.                 }
  123.                 Stream stream = null;
  124.                 Encoding e = Encoding.Default;
  125.                 switch (this.resolvedUri.Scheme) {
  126.                     case "file": {
  127.                             string path = this.resolvedUri.LocalPath;
  128.                             stream = new FileStream(path, FileMode.Open, FileAccess.Read);
  129.                         }
  130.                         break;
  131.                     default:
  132.                         //Console.WriteLine("Fetching:" + ResolvedUri.AbsoluteUri);
  133.                         HttpWebRequest wr = (HttpWebRequest)WebRequest.Create(ResolvedUri);
  134.                         wr.UserAgent = "Mozilla/4.0 (compatible;);";
  135.                         wr.Timeout = 10000; // in case this is running in an ASPX page.
  136.                         if (Proxy != null) wr.Proxy = new WebProxy(Proxy);
  137.                         wr.PreAuthenticate = false; 
  138.                         // Pass the credentials of the process. 
  139.                         wr.Credentials = CredentialCache.DefaultCredentials; 
  141.                         WebResponse resp = wr.GetResponse();
  142.                         Uri actual = resp.ResponseUri;
  143.                         if (actual.AbsoluteUri != this.resolvedUri.AbsoluteUri) {
  144.                             this.resolvedUri = actual;
  145.                         }                       
  146.                         string contentType = resp.ContentType.ToLower();
  147.                         string mimeType = contentType;
  148.                         int i = contentType.IndexOf(';');
  149.                         if (i >= 0) {
  150.                             mimeType = contentType.Substring(0, i);
  151.                         }
  152.                         if (StringUtilities.EqualsIgnoreCase(mimeType, "text/html")){
  153.                             this.Html = true;
  154.                         }
  156.                         i = contentType.IndexOf("charset");
  157.                         e = Encoding.Default;
  158.                         if (i >= 0) {                                
  159.                             int j = contentType.IndexOf("=", i);
  160.                             int k = contentType.IndexOf(";", j);
  161.                             if (k<0) k = contentType.Length;
  162.                             if (j > 0) {
  163.                                 j++;
  164.                                 string charset = contentType.Substring(j, k - j).Trim();
  165.                                 try {
  166.                                     e = Encoding.GetEncoding(charset);
  167.                                 } catch (Exception) {
  168.                                 }
  169.                             }
  170.                         }
  171.                         stream = resp.GetResponseStream();
  172.                         break;
  174.                 }
  175.                 this.weOwnTheStream = true;
  176.                 HtmlStream html = new HtmlStream(stream, e);
  177.                 this.encoding = html.Encoding;
  178.                 this.stm = html;
  179.             }
  180.         }
  182.         public Encoding GetEncoding(){
  183.             return this.encoding;
  184.         }
  185.         
  186.         public void Close() {
  187.             if (this.weOwnTheStream) 
  188.                 this.stm.Close();
  189.         }
  191.         public char SkipWhitespace() {
  192.             char ch = Lastchar;
  193.             while (ch != Entity.EOF && (ch == ' ' || ch == 'r' || ch == 'n' || ch == 't')) {
  194.                 ch = ReadChar();
  195.             }
  196.             return ch;
  197.         }
  199.         public string ScanToken(StringBuilder sb, string term, bool nmtoken) {
  200.             sb.Length = 0;
  201.             char ch = Lastchar;
  202.             if (nmtoken && ch != '_' && !Char.IsLetter(ch)) {
  203.                 throw new Exception(
  204.                     String.Format("Invalid name start character '{0}'", ch));
  205.             }
  206.             while (ch != Entity.EOF && term.IndexOf(ch)<0) {
  207.                 if (!nmtoken || ch == '_' || ch == '.' || ch == '-' || ch == ':' || Char.IsLetterOrDigit(ch)) {
  208.                     sb.Append(ch);
  209.                 } 
  210.                 else {
  211.                     throw new Exception(
  212.                         String.Format("Invalid name character '{0}'", ch));
  213.                 }
  214.                 ch = ReadChar();
  215.             }
  216.             return sb.ToString();
  217.         }
  219.         public string ScanLiteral(StringBuilder sb, char quote) {
  220.             sb.Length = 0;
  221.             char ch = ReadChar();
  222.             while (ch != Entity.EOF && ch != quote ) {
  223.                 if (ch == '&') {
  224.                     ch = ReadChar();
  225.                     if (ch == '#') {
  226.                         string charent = ExpandCharEntity();
  227.                         sb.Append(charent);
  228.                         ch = this.Lastchar;
  229.                     } 
  230.                     else {
  231.                         sb.Append('&');
  232.                         sb.Append(ch);
  233.                         ch = ReadChar();
  234.                     }
  235.                 }               
  236.                 else {
  237.                     sb.Append(ch);
  238.                     ch = ReadChar();
  239.                 }
  240.             }
  241.             ReadChar(); // consume end quote.           
  242.             return sb.ToString();
  243.         }
  245.         public string ScanToEnd(StringBuilder sb, string type, string terminators) {
  246.             if (sb != null) sb.Length = 0;
  247.             int start = Line;
  248.             // This method scans over a chunk of text looking for the
  249.             // termination sequence specified by the 'terminators' parameter.
  250.             char ch = ReadChar();            
  251.             int state = 0;
  252.             char next = terminators[state];
  253.             while (ch != Entity.EOF) {
  254.                 if (ch == next) {
  255.                     state++;
  256.                     if (state >= terminators.Length) {
  257.                         // found it!
  258.                         break;
  259.                     }
  260.                     next = terminators[state];
  261.                 } 
  262.                 else if (state > 0) {
  263.                     // char didn't match, so go back and see how much does still match.
  264.                     int i = state - 1;
  265.                     int newstate = 0;
  266.                     while (i>=0 && newstate==0) {
  267.                         if (terminators[i] == ch) {
  268.                             // character is part of the terminators pattern, ok, so see if we can
  269.                             // match all the way back to the beginning of the pattern.
  270.                             int j = 1;
  271.                             while( i-j>=0) {
  272.                                 if (terminators[i-j] != terminators[state-j])
  273.                                     break;
  274.                                 j++;
  275.                             }
  276.                             if (j>i) {
  277.                                 newstate = i+1;
  278.                             }
  279.                         } 
  280.                         else {
  281.                             i--;
  282.                         }
  283.                     }
  284.                     if (sb != null) {
  285.                         i = (i<0) ? 1 : 0;
  286.                         for (int k = 0; k <= state-newstate-i; k++) {
  287.                             sb.Append(terminators[k]); 
  288.                         }
  289.                         if (i>0) // see if we've matched this char or not
  290.                             sb.Append(ch); // if not then append it to buffer.
  291.                     }
  292.                     state = newstate;
  293.                     next = terminators[newstate];
  294.                 }
  295.                 else {
  296.                     if (sb != null) sb.Append(ch);
  297.                 }
  298.                 ch = ReadChar();
  299.             }
  300.             if (ch == 0) Error(type + " starting on line {0} was never closed", start);
  301.             ReadChar(); // consume last char in termination sequence.
  302.             if (sb != null) return sb.ToString();
  303.             return "";
  304.         }
  306.         public string ExpandCharEntity() {
  307.             char ch = ReadChar();
  308.             int v = 0;
  309.             if (ch == 'x') {
  310.                 ch = ReadChar();
  311.                 for (; ch != Entity.EOF && ch != ';'; ch = ReadChar()) {
  312.                     int p = 0;
  313.                     if (ch >= '0' && ch <= '9') {
  314.                         p = (int)(ch-'0');
  315.                     } 
  316.                     else if (ch >= 'a' && ch <= 'f') {
  317.                         p = (int)(ch-'a')+10;
  318.                     } 
  319.                     else if (ch >= 'A' && ch <= 'F') {
  320.                         p = (int)(ch-'A')+10;
  321.                     }
  322.                     else {
  323.                         break;//we must be done!
  324.                         //Error("Hex digit out of range '{0}'", (int)ch);
  325.                     }
  326.                     v = (v*16)+p;
  327.                 }
  328.             } 
  329.             else {                   
  330.                 for (; ch != Entity.EOF && ch != ';'; ch = ReadChar()) {
  331.                     if (ch >= '0' && ch <= '9') {
  332.                         v = (v*10)+(int)(ch-'0');
  333.                     } 
  334.                     else {
  335.                         break; // we must be done!
  336.                         //Error("Decimal digit out of range '{0}'", (int)ch);
  337.                     }
  338.                 }
  339.             }
  340.             if (ch == 0) {
  341.                 Error("Premature {0} parsing entity reference", ch);
  342.             } else if (ch == ';') {
  343.                 ReadChar(); 
  344.             }
  345.             // HACK ALERT: IE and Netscape map the unicode characters 
  346.             if (this.Html && v >= 0x80 & v <= 0x9F) {
  347.                 // This range of control characters is mapped to Windows-1252!
  348.                 int size = CtrlMap.Length;
  349.                 int i = v-0x80;
  350.                 int unicode = CtrlMap[i];
  351.                 return Convert.ToChar(unicode).ToString();
  352.             }
  353.             return Convert.ToChar(v).ToString();
  354.         }
  356.         static int[] CtrlMap = new int[] {
  357.                                              // This is the windows-1252 mapping of the code points 0x80 through 0x9f.
  358.                                              8364, 129, 8218, 402, 8222, 8230, 8224, 8225, 710, 8240, 352, 8249, 338, 141,
  359.                                              381, 143, 144, 8216, 8217, 8220, 8221, 8226, 8211, 8212, 732, 8482, 353, 8250, 
  360.                                              339, 157, 382, 376
  361.                                          };
  363.         public void Error(string msg) {
  364.             throw new Exception(msg);
  365.         }
  367.         public void Error(string msg, char ch) {
  368.             string str = (ch == Entity.EOF) ? "EOF" : Char.ToString(ch);            
  369.             throw new Exception(String.Format(msg, str));
  370.         }
  372.         public void Error(string msg, int x) {
  373.             throw new Exception(String.Format(msg, x));
  374.         }
  376.         public void Error(string msg, string arg) {
  377.             throw new Exception(String.Format(msg, arg));
  378.         }
  380.         public string Context() {
  381.             Entity p = this;
  382.             StringBuilder sb = new StringBuilder();
  383.             while (p != null) {
  384.                 string msg;
  385.                 if (p.Internal) {
  386.                     msg = String.Format("nReferenced on line {0}, position {1} of internal entity '{2}'", p.Line, p.LinePosition, p.Name);
  387.                 } 
  388.                 else {
  389.                     msg = String.Format("nReferenced on line {0}, position {1} of '{2}' entity at [{3}]", p.Line, p.LinePosition, p.Name, p.ResolvedUri.AbsolutePath);
  390.                 }
  391.                 sb.Append(msg);
  392.                 p = p.Parent;
  393.             }
  394.             return sb.ToString();
  395.         }
  397.         public static bool IsLiteralType(string token) {
  398.             return (token == "CDATA" || token == "SDATA" || token == "PI");
  399.         }
  401.         public void SetLiteralType(string token) {
  402.             switch (token) {
  403.                 case "CDATA":
  404.                     LiteralType = LiteralType.CDATA;
  405.                     break;
  406.                 case "SDATA":
  407.                     LiteralType = LiteralType.SDATA;
  408.                     break;
  409.                 case "PI":
  410.                     LiteralType = LiteralType.PI;
  411.                     break;
  412.             }
  413.         }
  414.     }
  416.     // This class decodes an HTML/XML stream correctly.
  417.     internal class HtmlStream : TextReader {
  418.         Stream stm;
  419.         byte[] rawBuffer;
  420.         int rawPos;
  421.         int rawUsed;
  422.         Encoding encoding;
  423.         Decoder decoder;
  424.         char[] buffer;
  425.         int used;
  426.         int pos;
  427.         private const int BUFSIZE = 16384;
  428.         private const int EOF = -1;
  430.         public HtmlStream(Stream stm, Encoding defaultEncoding) {            
  431.             if (defaultEncoding == null) defaultEncoding = Encoding.UTF8; // default is UTF8
  432.             if (!stm.CanSeek){
  433.                 // Need to be able to seek to sniff correctly.
  434.                 stm = CopyToMemoryStream(stm);
  435.             }
  436.             this.stm = stm;
  437.             rawBuffer = new Byte[BUFSIZE];
  438.             rawUsed = stm.Read(rawBuffer, 0, 4); // maximum byte order mark
  439.             this.buffer = new char[BUFSIZE];
  441.             // Check byte order marks
  442.             this.decoder = AutoDetectEncoding(rawBuffer, ref rawPos, rawUsed);
  443.             int bom = rawPos;
  444.             if (this.decoder == null) {
  445.                 this.decoder = defaultEncoding.GetDecoder();
  446.                 rawUsed += stm.Read(rawBuffer, 4, BUFSIZE-4);                
  447.                 DecodeBlock();
  448.                 // Now sniff to see if there is an XML declaration or HTML <META> tag.
  449.                 Decoder sd = SniffEncoding();
  450.                 if (sd != null) {
  451.                     this.decoder = sd;
  452.                 }
  453.             }            
  455.             // Reset to get ready for Read()
  456.             this.stm.Seek(0, SeekOrigin.Begin);
  457.             this.pos = this.used = 0;
  458.             // skip bom
  459.             if (bom>0){
  460.                 stm.Read(this.rawBuffer, 0, bom);
  461.             }
  462.             this.rawPos = this.rawUsed = 0;
  463.             
  464.         }
  466.         public Encoding Encoding {
  467.             get {
  468.                 return this.encoding;
  469.             }
  470.         }
  472.         Stream CopyToMemoryStream(Stream s){
  473.             int size = 100000; // large heap is more efficient
  474.             byte[] buffer = new byte[size];
  475.             int len;
  476.             MemoryStream r = new MemoryStream();
  477.             while ((len = s.Read(buffer, 0, size))>0){
  478.                 r.Write(buffer, 0, len);
  479.             }
  480.             r.Seek(0, SeekOrigin.Begin);                            
  481.             s.Close();
  482.             return r;
  483.         }
  485.         internal void DecodeBlock() {
  486.             // shift current chars to beginning.
  487.             if (pos > 0) {
  488.                 if (pos < used) {
  489.                     System.Array.Copy(buffer, pos, buffer, 0, used - pos);
  490.                 }
  491.                 used -= pos;
  492.                 pos = 0;
  493.             }
  494.             int len = decoder.GetCharCount(rawBuffer, rawPos, rawUsed - rawPos);
  495.             int available = buffer.Length - used;
  496.             if (available < len) {
  497.                 char[] newbuf = new char[buffer.Length + len];
  498.                 System.Array.Copy(buffer, pos, newbuf, 0, used - pos);
  499.                 buffer = newbuf;
  500.             }
  501.             used = pos + decoder.GetChars(rawBuffer, rawPos, rawUsed - rawPos, buffer, pos);
  502.             rawPos = rawUsed; // consumed the whole buffer!
  503.         }
  504.         internal static Decoder AutoDetectEncoding(byte[] buffer, ref int index, int length) {
  505.             if (4 <= (length - index)) {
  506.                 uint w = (uint)buffer[index + 0] << 24 | (uint)buffer[index + 1] << 16 | (uint)buffer[index + 2] << 8 | (uint)buffer[index + 3];
  507.                 // see if it's a 4-byte encoding
  508.                 switch (w) {
  509.                     case 0xfefffeff: 
  510.                         index += 4; 
  511.                         return new Ucs4DecoderBigEngian();
  513.                     case 0xfffefffe: 
  514.                         index += 4; 
  515.                         return new Ucs4DecoderLittleEndian();
  517.                     case 0x3c000000: 
  518.                         goto case 0xfefffeff;
  520.                     case 0x0000003c: 
  521.                         goto case 0xfffefffe;
  522.                 }
  523.                 w >>= 8;
  524.                 if (w == 0xefbbbf) {
  525.                     index += 3;
  526.                     return Encoding.UTF8.GetDecoder();
  527.                 }
  528.                 w >>= 8;
  529.                 switch (w) {
  530.                     case 0xfeff: 
  531.                         index += 2; 
  532.                         return UnicodeEncoding.BigEndianUnicode.GetDecoder();
  534.                     case 0xfffe: 
  535.                         index += 2; 
  536.                         return new UnicodeEncoding(false, false).GetDecoder();
  538.                     case 0x3c00: 
  539.                         goto case 0xfeff;
  541.                     case 0x003c: 
  542.                         goto case 0xfffe;
  543.                 }
  544.             }
  545.             return null;
  546.         }
  547.         private int ReadChar() {
  548.             // Read only up to end of current buffer then stop.
  549.             if (pos < used) return buffer[pos++];
  550.             return EOF;
  551.         }
  552.         private int PeekChar() {
  553.             int ch = ReadChar();
  554.             if (ch != EOF) {
  555.                 pos--;
  556.             }
  557.             return ch;
  558.         }
  559.         private bool SniffPattern(string pattern) {
  560.             int ch = PeekChar();
  561.             if (ch != pattern[0]) return false;
  562.             for (int i = 0, n = pattern.Length; ch != EOF && i < n; i++) {
  563.                 ch = ReadChar();
  564.                 char m = pattern[i];
  565.                 if (ch != m) {
  566.                     return false;
  567.                 }
  568.             }
  569.             return true;
  570.         }
  571.         private void SniffWhitespace() {
  572.             char ch = (char)PeekChar();
  573.             while (ch == ' ' || ch == 't' || ch == 'r' || ch == 'n') {
  574.                 int i = pos;
  575.                 ch = (char)ReadChar();
  576.                 if (ch != ' ' && ch != 't' && ch != 'r' && ch != 'n')
  577.                     pos = i;
  578.             }
  579.         }
  581.         private string SniffLiteral() {
  582.             int quoteChar = PeekChar();
  583.             if (quoteChar == ''' || quoteChar == '"') {
  584.                 ReadChar();// consume quote char
  585.                 int i = this.pos;
  586.                 int ch = ReadChar();
  587.                 while (ch != EOF && ch != quoteChar) {
  588.                     ch = ReadChar();
  589.                 }
  590.                 return (pos>i) ? new string(buffer, i, pos - i - 1) : "";
  591.             }
  592.             return null;
  593.         }
  594.         private string SniffAttribute(string name) {
  595.             SniffWhitespace();
  596.             string id = SniffName();
  597.             if (name == id){
  598.                 SniffWhitespace();
  599.                 if (SniffPattern("=")) {
  600.                     SniffWhitespace();
  601.                     return SniffLiteral();
  602.                 }
  603.             }
  604.             return null;
  605.         }
  606.         private string SniffAttribute(out string name) {
  607.             SniffWhitespace();
  608.             name = SniffName();
  609.             if (name != null){
  610.                 SniffWhitespace();
  611.                 if (SniffPattern("=")) {
  612.                     SniffWhitespace();
  613.                     return SniffLiteral();
  614.                 }
  615.             }
  616.             return null;
  617.         }
  618.         private void SniffTerminator(string term) {
  619.             int ch = ReadChar();
  620.             int i = 0;
  621.             int n = term.Length;
  622.             while (i < n && ch != EOF) {
  623.                 if (term[i] == ch) {
  624.                     i++;
  625.                     if (i == n) break;
  626.                 } else {
  627.                     i = 0; // reset.
  628.                 }
  629.                 ch = ReadChar();
  630.             }
  631.         }
  632.         internal Decoder  SniffEncoding() {
  633.             Decoder decoder = null;
  634.             if (SniffPattern("<?xml")) {
  635.                 string version = SniffAttribute("version");
  636.                 if (version != null) {
  637.                     string encoding = SniffAttribute("encoding");
  638.                     if (encoding != null) {
  639.                         try {
  640.                             Encoding enc = Encoding.GetEncoding(encoding);
  641.                             if (enc != null) {
  642.                                 this.encoding = enc;
  643.                                 return enc.GetDecoder();
  644.                             }
  645.                         } catch (Exception) {
  646.                             // oh well then.
  647.                         }
  648.                     }
  649.                     SniffTerminator(">");
  650.                 }
  651.             } 
  652.             if (decoder == null) {
  653.                 return SniffMeta();
  654.             }
  655.             return null;
  656.         }
  658.         internal Decoder SniffMeta(){
  659.             int i = ReadChar();            
  660.             while (i != EOF){
  661.                 char ch = (char)i;
  662.                 if (ch == '<') {
  663.                     string name = SniffName();
  664.                     if (name != null && StringUtilities.EqualsIgnoreCase(name, "meta")){
  665.                         string httpequiv = null;
  666.                         string content = null;
  667.                         while (true) {
  668.                             string value = SniffAttribute(out name);
  669.                             if (name == null) {
  670.                                 break;
  671.                             }
  672.                             if (StringUtilities.EqualsIgnoreCase(name, "http-equiv")){
  673.                                 httpequiv = value;
  674.                             } else if (StringUtilities.EqualsIgnoreCase(name, "content")){
  675.                                 content = value;
  676.                             }
  677.                         }
  678.                         if (httpequiv != null && StringUtilities.EqualsIgnoreCase(httpequiv, "content-type") && content != null){
  679.                             int j = content.IndexOf("charset");
  680.                             if (j>=0){
  681.                                 //charset=utf-8
  682.                                 j = content.IndexOf("=", j);
  683.                                 if (j>=0) {
  684.                                     j++;
  685.                                     int k = content.IndexOf(";", j);
  686.                                     if (k<0) k = content.Length;
  687.                                     string charset = content.Substring(j, k-j).Trim();
  688.                                     try {
  689.                                         Encoding e = Encoding.GetEncoding(charset);
  690.                                         this.encoding = e;
  691.                                         return e.GetDecoder();
  692.                                     } catch {
  693.                                     }
  694.                                 }                                
  695.                             }
  696.                         }
  697.                     }
  698.                 }
  699.                 i = ReadChar();
  701.             }
  702.             return null;
  703.         }
  705.         internal string SniffName(){
  706.             int c = PeekChar();
  707.             if (c == EOF)
  708.                 return null;
  709.             char ch = (char)c;
  710.             int start = pos;
  711.             while (pos < used - 1 && ( Char.IsLetterOrDigit(ch) || ch == '-' || ch == '_' || ch == ':')) {
  712.                 ch = buffer[++pos];
  713.             }
  714.             if (start == pos) return null;
  715.             return new string(buffer, start, pos-start);
  716.         }
  718.         internal void SkipWhitespace() {
  719.             char ch = (char)PeekChar();
  720.             while (pos < used - 1 && (ch == ' ' || ch == 'r' || ch == 'n')) {
  721.                 ch = buffer[++pos];
  722.             }
  723.         }
  724.         internal void SkipTo(char what) {
  725.             char ch = (char)PeekChar();
  726.             while (pos < used - 1 && (ch != what)) {
  727.                 ch = buffer[++pos];
  728.             }
  729.         }
  730.         internal string ParseAttribute() {
  731.             SkipTo('=');
  732.             if (pos < used) {
  733.                 pos++;
  734.                 SkipWhitespace();
  735.                 if (pos < used) {
  736.                     char quote = buffer[pos];
  737.                     pos++;
  738.                     int start = pos;
  739.                     SkipTo(quote);
  740.                     if (pos < used) {
  741.                         string result = new string(buffer, start, pos - start);
  742.                         pos++;
  743.                         return result;
  744.                     }
  745.                 }
  746.             }
  747.             return null;
  748.         }
  749.         public override int Peek() {
  750.             int result = Read();
  751.             if (result != EOF) {
  752.                 pos--;
  753.             }
  754.             return result;
  755.         }
  756.         public override int Read() {
  757.             if (pos == used) {
  758.                 rawUsed = stm.Read(rawBuffer, 0, rawBuffer.Length);
  759.                 rawPos = 0;
  760.                 if (rawUsed == 0) return EOF;
  761.                 DecodeBlock();
  762.             }
  763.             if (pos < used) return buffer[pos++];
  764.             return -1;
  765.         }
  766.         public override int Read(char[] buffer, int start, int length) {
  767.             if (pos == used) {
  768.                 rawUsed = stm.Read(rawBuffer, 0, rawBuffer.Length);
  769.                 rawPos = 0;
  770.                 if (rawUsed == 0) return -1;
  771.                 DecodeBlock();
  772.             }
  773.             if (pos < used) {
  774.                 length = Math.Min(used - pos, length);
  775.                 Array.Copy(this.buffer, pos, buffer, start, length);
  776.                 pos += length;
  777.                 return length;
  778.             }
  779.             return 0;
  780.         }
  782.         public override int ReadBlock(char[] buffer, int index, int count) {
  783.             return Read(buffer, index, count);
  784.         }
  785.         // Read up to end of line, or full buffer, whichever comes first.
  786.         public int ReadLine(char[] buffer, int start, int length) {
  787.             int i = 0;
  788.             int ch = ReadChar();
  789.             while (ch != EOF) {
  790.                 buffer[i+start] = (char)ch;
  791.                 i++;
  792.                 if (i+start == length) 
  793.                     break; // buffer is full
  795.                 if (ch == 'r' ) {
  796.                     if (PeekChar() == 'n') {
  797.                         ch = ReadChar();
  798.                         buffer[i + start] = (char)ch;
  799.                         i++;
  800.                     }
  801.                     break;
  802.                 } else if (ch == 'n') {
  803.                     break;
  804.                 }
  805.                 ch = ReadChar();
  806.             }
  807.             return i;
  808.         }
  810.         public override string ReadToEnd() {
  811.             char[] buffer = new char[100000]; // large block heap is more efficient
  812.             int len = 0;
  813.             StringBuilder sb = new StringBuilder();
  814.             while ((len = Read(buffer, 0, buffer.Length)) > 0) {
  815.                 sb.Append(buffer, 0, len);
  816.             }
  817.             return sb.ToString();
  818.         }
  819.         public override void Close() {
  820.             stm.Close();
  821.         }
  822.     }
  823.     internal abstract class Ucs4Decoder : Decoder {
  824.         internal byte[] temp = new byte[4];
  825.         internal int tempBytes = 0;
  826.         public override int GetCharCount(byte[] bytes, int index, int count) {
  827.             return (count + tempBytes) / 4;
  828.         }
  829.         internal abstract int GetFullChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex);
  830.         public override int GetChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex) {
  831.             int i = tempBytes;
  833.             if (tempBytes > 0) {
  834.                 for (; i < 4; i++) {
  835.                     temp[i] = bytes[byteIndex];
  836.                     byteIndex++;
  837.                     byteCount--;
  838.                 }
  839.                 i = 1;
  840.                 GetFullChars(temp, 0, 4, chars, charIndex);
  841.                 charIndex++;
  842.             } else
  843.                 i = 0;
  844.             i = GetFullChars(bytes, byteIndex, byteCount, chars, charIndex) + i;
  846.             int j = (tempBytes + byteCount) % 4;
  847.             byteCount += byteIndex;
  848.             byteIndex = byteCount - j;
  849.             tempBytes = 0;
  851.             if (byteIndex >= 0)
  852.                 for (; byteIndex < byteCount; byteIndex++) {
  853.                     temp[tempBytes] = bytes[byteIndex];
  854.                     tempBytes++;
  855.                 }
  856.             return i;
  857.         }
  858.         internal char UnicodeToUTF16(UInt32 code) {
  859.             byte lowerByte, higherByte;
  860.             lowerByte = (byte)(0xD7C0 + (code >> 10));
  861.             higherByte = (byte)(0xDC00 | code & 0x3ff);
  862.             return ((char)((higherByte << 8) | lowerByte));
  863.         }
  864.     }
  865.     internal class Ucs4DecoderBigEngian : Ucs4Decoder {
  866.         internal override int GetFullChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex) {
  867.             UInt32 code;
  868.             int i, j;
  869.             byteCount += byteIndex;
  870.             for (i = byteIndex, j = charIndex; i + 3 < byteCount; ) {
  871.                 code = (UInt32)(((bytes[i + 3]) << 24) | (bytes[i + 2] << 16) | (bytes[i + 1] << 8) | (bytes[i]));
  872.                 if (code > 0x10FFFF) {
  873.                     throw new Exception("Invalid character 0x" + code.ToString("x") + " in encoding");
  874.                 } else if (code > 0xFFFF) {
  875.                     chars[j] = UnicodeToUTF16(code);
  876.                     j++;
  877.                 } else {
  878.                     if (code >= 0xD800 && code <= 0xDFFF) {
  879.                         throw new Exception("Invalid character 0x" + code.ToString("x") + " in encoding");
  880.                     } else {
  881.                         chars[j] = (char)code;
  882.                     }
  883.                 }
  884.                 j++;
  885.                 i += 4;
  886.             }
  887.             return j - charIndex;
  888.         }
  889.     };
  890.     internal class Ucs4DecoderLittleEndian : Ucs4Decoder {
  891.         internal override int GetFullChars(byte[] bytes, int byteIndex, int byteCount, char[] chars, int charIndex) {
  892.             UInt32 code;
  893.             int i, j;
  894.             byteCount += byteIndex;
  895.             for (i = byteIndex, j = charIndex; i + 3 < byteCount; ) {
  896.                 code = (UInt32)(((bytes[i]) << 24) | (bytes[i + 1] << 16) | (bytes[i + 2] << 8) | (bytes[i + 3]));
  897.                 if (code > 0x10FFFF) {
  898.                     throw new Exception("Invalid character 0x" + code.ToString("x") + " in encoding");
  899.                 } else if (code > 0xFFFF) {
  900.                     chars[j] = UnicodeToUTF16(code);
  901.                     j++;
  902.                 } else {
  903.                     if (code >= 0xD800 && code <= 0xDFFF) {
  904.                         throw new Exception("Invalid character 0x" + code.ToString("x") + " in encoding");
  905.                     } else {
  906.                         chars[j] = (char)code;
  907.                     }
  908.                 }
  909.                 j++;
  910.                 i += 4;
  911.             }
  912.             return j - charIndex;
  913.         }
  914.     }
  916.     public class ElementDecl
  917.     {
  918.         public ElementDecl(string name, bool sto, bool eto, ContentModel cm, string[] inclusions, string[] exclusions)
  919.         {
  920.             Name = name;
  921.             StartTagOptional = sto;
  922.             EndTagOptional = eto;
  923.             ContentModel = cm;
  924.             Inclusions = inclusions;
  925.             Exclusions = exclusions;
  926.         }
  927.         public string Name;
  928.         public bool StartTagOptional;
  929.         public bool EndTagOptional;
  930.         public ContentModel ContentModel;
  931.         public string[] Inclusions;
  932.         public string[] Exclusions;
  933.         public AttList AttList;
  935.         public AttDef FindAttribute(string name){
  936.             return AttList[name.ToUpper()];
  937.         }
  939.         public void AddAttDefs(AttList list)
  940.         {
  941.             if (AttList == null) 
  942.             {
  943.                 AttList = list;
  944.             } 
  945.             else 
  946.             {               
  947.                 foreach (AttDef a in list) 
  948.                 {
  949.                     if (AttList[a.Name] == null) 
  950.                     {
  951.                         AttList.Add(a);
  952.                     }
  953.                 }
  954.             }
  955.         }
  957.         public bool CanContain(string name, SgmlDtd dtd)
  958.         {            
  959.             // return true if this element is allowed to contain the given element.
  960.             if (Exclusions != null) 
  961.             {
  962.                 foreach (string s in Exclusions) 
  963.                 {
  964.                     if ((object)s == (object)name) // XmlNameTable optimization
  965.                         return false;
  966.                 }
  967.             }
  968.             if (Inclusions != null) 
  969.             {
  970.                 foreach (string s in Inclusions) 
  971.                 {
  972.                     if ((object)s == (object)name) // XmlNameTable optimization
  973.                         return true;
  974.                 }
  975.             }
  976.             return ContentModel.CanContain(name, dtd);
  977.         }
  978.     }
  980.     public enum DeclaredContent
  981.     {
  982.         Default, CDATA, RCDATA, EMPTY
  983.     }
  985.     public class ContentModel
  986.     {
  987.         public DeclaredContent DeclaredContent;
  988.         public int CurrentDepth;
  989.         public Group Model;
  991.         public ContentModel()
  992.         {
  993.             Model = new Group(null);
  994.         }
  996.         public void PushGroup()
  997.         {
  998.             Model = new Group(Model);
  999.             CurrentDepth++;
  1000.         }
  1002.         public int PopGroup()
  1003.         {
  1004.             if (CurrentDepth == 0) return -1;
  1005.             CurrentDepth--;
  1006.             Model.Parent.AddGroup(Model);
  1007.             Model = Model.Parent;
  1008.             return CurrentDepth;
  1009.         }
  1011.         public void AddSymbol(string sym)
  1012.         {
  1013.             Model.AddSymbol(sym);
  1014.         }
  1016.         public void AddConnector(char c)
  1017.         {
  1018.             Model.AddConnector(c);
  1019.         }
  1021.         public void AddOccurrence(char c)
  1022.         {
  1023.             Model.AddOccurrence(c);
  1024.         }
  1026.         public void SetDeclaredContent(string dc)
  1027.         {
  1028.             switch (dc) {
  1029.                 case "EMPTY":
  1030.                     this.DeclaredContent = DeclaredContent.EMPTY;
  1031.                     break;
  1032.                 case "RCDATA":
  1033.                     this.DeclaredContent = DeclaredContent.RCDATA;
  1034.                     break;
  1035.                 case "CDATA":
  1036.                     this.DeclaredContent = DeclaredContent.CDATA;
  1037.                     break;
  1038.                 default:
  1039.                     throw new Exception(
  1040.                         String.Format("Declared content type '{0}' is not supported", dc));
  1041.             }
  1042.         }
  1044.         public bool CanContain(string name, SgmlDtd dtd)
  1045.         {
  1046.             if (DeclaredContent != DeclaredContent.Default)
  1047.                 return false; // empty or text only node.
  1048.             return Model.CanContain(name, dtd);
  1049.         }
  1050.     }
  1052.     public enum GroupType 
  1053.     {
  1054.         None, And, Or, Sequence 
  1055.     };
  1057.     public enum Occurrence
  1058.     {
  1059.         Required, Optional, ZeroOrMore, OneOrMore
  1060.     }
  1062.     public class Group
  1063.     {
  1064.         public Group Parent;
  1065.         public ArrayList Members;
  1066.         public GroupType GroupType;
  1067.         public Occurrence Occurrence;
  1068.         public bool Mixed;
  1070.         public bool TextOnly {
  1071.             get { return this.Mixed && Members.Count == 0; }
  1072.         }
  1074.         public Group(Group parent)
  1075.         {
  1076.             Parent = parent;
  1077.             Members = new ArrayList();
  1078.             this.GroupType = GroupType.None;
  1079.             Occurrence = Occurrence.Required;
  1080.         }
  1081.         public void AddGroup(Group g)
  1082.         {
  1083.             Members.Add(g);
  1084.         }
  1085.         public void AddSymbol(string sym)
  1086.         {
  1087.             if (sym == "#PCDATA") 
  1088.             {               
  1089.                 Mixed = true;
  1090.             } 
  1091.             else 
  1092.             {
  1093.                 Members.Add(sym);
  1094.             }
  1095.         }
  1096.         public void AddConnector(char c)
  1097.         {
  1098.             if (!Mixed && Members.Count == 0) 
  1099.             {
  1100.                 throw new Exception(
  1101.                     String.Format("Missing token before connector '{0}'.", c)
  1102.                     );
  1103.             }
  1104.             GroupType gt = GroupType.None;
  1105.             switch (c) 
  1106.             {
  1107.                 case ',': 
  1108.                     gt = GroupType.Sequence;
  1109.                     break;
  1110.                 case '|':
  1111.                     gt = GroupType.Or;
  1112.                     break;
  1113.                 case '&':
  1114.                     gt = GroupType.And;
  1115.                     break;
  1116.             }
  1117.             if (GroupType != GroupType.None && GroupType != gt) 
  1118.             {
  1119.                 throw new Exception(
  1120.                     String.Format("Connector '{0}' is inconsistent with {1} group.", c, GroupType.ToString())
  1121.                     );
  1122.             }
  1123.             GroupType = gt;
  1124.         }
  1126.         public void AddOccurrence(char c)
  1127.         {
  1128.             Occurrence o = Occurrence.Required;
  1129.             switch (c) 
  1130.             {
  1131.                 case '?': 
  1132.                     o = Occurrence.Optional;
  1133.                     break;
  1134.                 case '+':
  1135.                     o = Occurrence.OneOrMore;
  1136.                     break;
  1137.                 case '*':
  1138.                     o = Occurrence.ZeroOrMore;
  1139.                     break;
  1140.             }
  1141.             Occurrence = o;
  1142.         }
  1144.         // Rough approximation - this is really assuming an "Or" group
  1145.         public bool CanContain(string name, SgmlDtd dtd)
  1146.         {
  1147.             // Do a simple search of members.
  1148.             foreach (object obj in Members) 
  1149.             {
  1150.                 if (obj is String) 
  1151.                 {
  1152.                     if (obj == (object)name) // XmlNameTable optimization
  1153.                         return true;
  1154.                 } 
  1155.             }
  1156.             // didn't find it, so do a more expensive search over child elements
  1157.             // that have optional start tags and over child groups.
  1158.             foreach (object obj in Members) 
  1159.             {
  1160.                 if (obj is String) 
  1161.                 {
  1162.                     string s = (string)obj;
  1163.                     ElementDecl e = dtd.FindElement(s);
  1164.                     if (e != null) 
  1165.                     {
  1166.                         if (e.StartTagOptional) 
  1167.                         {
  1168.                             // tricky case, the start tag is optional so element may be
  1169.                             // allowed inside this guy!
  1170.                             if (e.CanContain(name, dtd))
  1171.                                 return true;
  1172.                         }
  1173.                     }
  1174.                 } 
  1175.                 else 
  1176.                 {
  1177.                     Group m = (Group)obj;
  1178.                     if (m.CanContain(name, dtd)) 
  1179.                         return true;
  1180.                 }
  1181.             }
  1182.             return false;
  1183.         }
  1184.     }
  1186.     public enum AttributeType
  1187.     {
  1188.         DEFAULT, CDATA, ENTITY, ENTITIES, ID, IDREF, IDREFS, NAME, NAMES, NMTOKEN, NMTOKENS, 
  1189.         NUMBER, NUMBERS, NUTOKEN, NUTOKENS, NOTATION, ENUMERATION
  1190.     }
  1192.     public enum AttributePresence
  1193.     {
  1194.         DEFAULT, FIXED, REQUIRED, IMPLIED
  1195.     }
  1197.     public class AttDef
  1198.     {
  1199.         public string Name;
  1200.         public AttributeType Type;
  1201.         public string[] EnumValues;
  1202.         public string Default;
  1203.         public AttributePresence Presence;
  1205.         public AttDef(string name)
  1206.         {
  1207.             Name = name;
  1208.         }
  1211.         public void SetType(string type)
  1212.         {
  1213.             switch (type) 
  1214.             {
  1215.                 case "CDATA":
  1216.                     Type = AttributeType.CDATA;
  1217.                     break;
  1218.                 case "ENTITY":
  1219.                     Type = AttributeType.ENTITY;
  1220.                     break;
  1221.                 case "ENTITIES":
  1222.                     Type = AttributeType.ENTITIES;
  1223.                     break;
  1224.                 case "ID":
  1225.                     Type = AttributeType.ID;
  1226.                     break;
  1227.                 case "IDREF":
  1228.                     Type = AttributeType.IDREF;
  1229.                     break;
  1230.                 case "IDREFS":
  1231.                     Type = AttributeType.IDREFS;
  1232.                     break;
  1233.                 case "NAME":
  1234.                     Type = AttributeType.NAME;
  1235.                     break;
  1236.                 case "NAMES":
  1237.                     Type = AttributeType.NAMES;
  1238.                     break;
  1239.                 case "NMTOKEN":
  1240.                     Type = AttributeType.NMTOKEN;
  1241.                     break;
  1242.                 case "NMTOKENS":
  1243.                     Type = AttributeType.NMTOKENS;
  1244.                     break;
  1245.                 case "NUMBER":
  1246.                     Type = AttributeType.NUMBER;
  1247.                     break;
  1248.                 case "NUMBERS":
  1249.                     Type = AttributeType.NUMBERS;
  1250.                     break;
  1251.                 case "NUTOKEN":
  1252.                     Type = AttributeType.NUTOKEN;
  1253.                     break;
  1254.                 case "NUTOKENS":
  1255.                     Type = AttributeType.NUTOKENS;
  1256.                     break;
  1257.                 default:
  1258.                     throw new Exception("Attribute type '"+type+"' is not supported");
  1259.             }
  1260.         }
  1262.         public bool SetPresence (string token)
  1263.         {
  1264.             bool hasDefault = true;
  1265.             if (token == "FIXED") 
  1266.             {
  1267.                 Presence = AttributePresence.FIXED;             
  1268.             } 
  1269.             else if (token == "REQUIRED") 
  1270.             {
  1271.                 Presence = AttributePresence.REQUIRED;
  1272.                 hasDefault = false;
  1273.             }
  1274.             else if (token == "IMPLIED") 
  1275.             {
  1276.                 Presence = AttributePresence.IMPLIED;
  1277.                 hasDefault = false;
  1278.             }
  1279.             else 
  1280.             {
  1281.                 throw new Exception(String.Format("Attribute value '{0}' not supported", token));
  1282.             }
  1283.             return hasDefault;
  1284.         }
  1285.     }
  1287.     public class AttList : IEnumerable
  1288.     {
  1289.         Hashtable AttDefs;
  1290.         
  1291.         public AttList()
  1292.         {
  1293.             AttDefs = new Hashtable();
  1294.         }
  1296.         public void Add(AttDef a)
  1297.         {
  1298.             AttDefs.Add(a.Name, a);
  1299.         }
  1301.         public AttDef this[string name]
  1302.         {
  1303.             get 
  1304.             {
  1305.                 return (AttDef)AttDefs[name];
  1306.             }
  1307.         }
  1309.         public IEnumerator GetEnumerator()
  1310.         {
  1311.             return AttDefs.Values.GetEnumerator();
  1312.         }
  1313.     }
  1315.     public class SgmlDtd
  1316.     {
  1317.         public string Name;
  1319.         Hashtable elements;
  1320.         Hashtable pentities;
  1321.         Hashtable entities;
  1322.         StringBuilder sb;      
  1323.         Entity current;
  1324.         XmlNameTable nameTable;
  1326.         public SgmlDtd(string name, XmlNameTable nt)
  1327.         {
  1328.             this.nameTable = nt;
  1329.             this.Name = name;
  1330.             this.elements = new Hashtable();
  1331.             this.pentities = new Hashtable();
  1332.             this.entities = new Hashtable();
  1333.             this.sb = new StringBuilder();
  1334.         }
  1336.         public XmlNameTable NameTable { get { return this.nameTable; } }
  1338.         public static SgmlDtd Parse(Uri baseUri, string name, string pubid, string url, string subset, string proxy, XmlNameTable nt)
  1339.         {
  1340.             SgmlDtd dtd = new SgmlDtd(name, nt);
  1341.             if (url != null && url != "") 
  1342.             {
  1343.                 dtd.PushEntity(baseUri, new Entity(dtd.Name, pubid, url, proxy));
  1344.             }
  1345.             if (subset != null && subset != "") 
  1346.             {
  1347.                 dtd.PushEntity(baseUri, new Entity(name, subset));
  1348.             }
  1349.             try 
  1350.             {
  1351.                 dtd.Parse();
  1352.             } 
  1353.             catch (Exception e)
  1354.             {
  1355.                 throw new Exception(e.Message + dtd.current.Context());
  1356.             }           
  1357.             return dtd;
  1358.         }
  1359.         public static SgmlDtd Parse(Uri baseUri, string name, string pubid, TextReader input, string subset, string proxy, XmlNameTable nt) {
  1360.             SgmlDtd dtd = new SgmlDtd(name, nt);
  1361.             dtd.PushEntity(baseUri, new Entity(dtd.Name, baseUri, input, proxy));
  1362.             if (subset != null && subset != "") {
  1363.                 dtd.PushEntity(baseUri, new Entity(name, subset));
  1364.             }
  1365.             try {
  1366.                 dtd.Parse();
  1367.             } 
  1368.             catch (Exception e) {
  1369.                 throw new Exception(e.Message + dtd.current.Context());
  1370.             }           
  1371.             return dtd;
  1372.         }
  1374.         public Entity FindEntity(string name)
  1375.         {
  1376.             return (Entity)this.entities[name];
  1377.         }
  1379.         public ElementDecl FindElement(string name)
  1380.         {
  1381.             return (ElementDecl)this.elements[name.ToUpper()];
  1382.         }
  1384.         //-------------------------------- Parser -------------------------
  1385.         void PushEntity(Uri baseUri, Entity e)
  1386.         {
  1387.             e.Open(this.current, baseUri);
  1388.             this.current = e;
  1389.             this.current.ReadChar();
  1390.         }
  1392.         void PopEntity()
  1393.         {
  1394.             if (this.current != null) this.current.Close();
  1395.             if (this.current.Parent != null) 
  1396.             {
  1397.                 this.current = this.current.Parent;
  1398.             } 
  1399.             else 
  1400.             {
  1401.                 this.current = null;
  1402.             }
  1403.         }
  1405.         void Parse()
  1406.         {
  1407.             char ch = this.current.Lastchar;
  1408.             while (true) 
  1409.             {
  1410.                 switch (ch) 
  1411.                 {
  1412.                     case Entity.EOF:
  1413.                         PopEntity();
  1414.                         if (this.current == null)
  1415.                             return;
  1416.                         ch = this.current.Lastchar;
  1417.                         break;
  1418.                     case ' ':
  1419.                     case 'n':
  1420.                     case 'r':
  1421.                     case 't':
  1422.                         ch = this.current.ReadChar();
  1423.                         break;
  1424.                     case '<':
  1425.                         ParseMarkup();
  1426.                         ch = this.current.ReadChar();
  1427.                         break;
  1428.                     case '%':
  1429.                         Entity e = ParseParameterEntity(SgmlDtd.WhiteSpace);
  1430.                         try 
  1431.                         {
  1432.                             PushEntity(this.current.ResolvedUri, e);
  1433.                         } 
  1434.                         catch (Exception ex) 
  1435.                         {
  1436.                             // bugbug - need an error log.
  1437.                             Console.WriteLine(ex.Message + this.current.Context());
  1438.                         }
  1439.                         ch = this.current.Lastchar;
  1440.                         break;
  1441.                     default:
  1442.                         this.current.Error("Unexpected character '{0}'", ch);
  1443.                         break;
  1444.                 }               
  1445.             }
  1446.         }
  1448.         void ParseMarkup()
  1449.         {
  1450.             char ch = this.current.ReadChar();
  1451.             if (ch != '!') 
  1452.             {
  1453.                 this.current.Error("Found '{0}', but expecing declaration starting with '<!'");
  1454.                 return;
  1455.             }
  1456.             ch = this.current.ReadChar();
  1457.             if (ch == '-') 
  1458.             {
  1459.                 ch = this.current.ReadChar();
  1460.                 if (ch != '-') this.current.Error("Expecting comment '<!--' but found {0}", ch);
  1461.                 this.current.ScanToEnd(this.sb, "Comment", "-->");
  1462.             } 
  1463.             else if (ch == '[') 
  1464.             {
  1465.                 ParseMarkedSection();
  1466.             }
  1467.             else 
  1468.             {
  1469.                 string token = this.current.ScanToken(this.sb, SgmlDtd.WhiteSpace, true);
  1470.                 switch (token) 
  1471.                 {
  1472.                     case "ENTITY":
  1473.                         ParseEntity();
  1474.                         break;
  1475.                     case "ELEMENT":
  1476.                         ParseElementDecl();
  1477.                         break;
  1478.                     case "ATTLIST":
  1479.                         ParseAttList();
  1480.                         break;
  1481.                     default:
  1482.                         this.current.Error("Invalid declaration '<!{0}'.  Expecting 'ENTITY', 'ELEMENT' or 'ATTLIST'.", token);
  1483.                         break;
  1484.                 }
  1485.             }
  1486.         }
  1488.         char ParseDeclComments()
  1489.         {
  1490.             char ch = this.current.Lastchar;
  1491.             while (ch == '-') 
  1492.             {
  1493.                 ch = ParseDeclComment(true);
  1494.             }
  1495.             return ch;
  1496.         }
  1498.         char ParseDeclComment(bool full)
  1499.         {
  1500.             int start = this.current.Line;
  1501.             // -^-...--
  1502.             // This method scans over a comment inside a markup declaration.
  1503.             char ch = this.current.ReadChar();
  1504.             if (full && ch != '-') this.current.Error("Expecting comment delimiter '--' but found {0}", ch);
  1505.             this.current.ScanToEnd(this.sb, "Markup Comment", "--");
  1506.             return this.current.SkipWhitespace();
  1507.         }
  1509.         void ParseMarkedSection()
  1510.         {
  1511.             // <![^ name [ ... ]]>
  1512.             this.current.ReadChar(); // move to next char.
  1513.             string name = ScanName("[");
  1514.             if (name == "INCLUDE") 
  1515.             {
  1516.                 ParseIncludeSection();
  1517.             } 
  1518.             else if (name == "IGNORE") 
  1519.             {
  1520.                 ParseIgnoreSection();
  1521.             }
  1522.             else 
  1523.             {
  1524.                 this.current.Error("Unsupported marked section type '{0}'", name);
  1525.             }
  1526.         }
  1528.         void ParseIncludeSection()
  1529.         {
  1530.             throw new NotImplementedException("Include Section");
  1531.         }
  1533.         void ParseIgnoreSection()
  1534.         {
  1535.             int start = this.current.Line;
  1536.             // <!-^-...-->
  1537.             char ch = this.current.SkipWhitespace();
  1538.             if (ch != '[') this.current.Error("Expecting '[' but found {0}", ch);
  1539.             this.current.ScanToEnd(this.sb, "Conditional Section", "]]>");
  1540.         }
  1542.         string ScanName(string term)
  1543.         {
  1544.             // skip whitespace, scan name (which may be parameter entity reference
  1545.             // which is then expanded to a name)
  1546.             char ch = this.current.SkipWhitespace();
  1547.             if (ch == '%') 
  1548.             {
  1549.                 Entity e = ParseParameterEntity(term);
  1550.                 ch = this.current.Lastchar;
  1551.                 // bugbug - need to support external and nested parameter entities
  1552.                 if (!e.Internal) throw new NotSupportedException("External parameter entity resolution");
  1553.                 return e.Literal.Trim();
  1554.             } 
  1555.             else 
  1556.             {
  1557.                 return this.current.ScanToken(this.sb, term, true);
  1558.             }
  1559.         }
  1561.         Entity ParseParameterEntity(string term)
  1562.         {
  1563.             // almost the same as this.current.ScanToken, except we also terminate on ';'
  1564.             char ch = this.current.ReadChar();
  1565.             string name =  this.current.ScanToken(this.sb, ";"+term, false);
  1566.             name = this.nameTable.Add(name);
  1567.             if (this.current.Lastchar == ';') 
  1568.                 this.current.ReadChar();
  1569.             Entity e = GetParameterEntity(name);
  1570.             return e;
  1571.         }
  1573.         Entity GetParameterEntity(string name)
  1574.         {
  1575.             Entity e = (Entity)this.pentities[name];
  1576.             if (e == null) this.current.Error("Reference to undefined parameter entity '{0}'", name);
  1577.             return e;
  1578.         }
  1579.         
  1580.         static string WhiteSpace = " rnt";
  1582.         void ParseEntity()
  1583.         {
  1584.             char ch = this.current.SkipWhitespace();
  1585.             bool pe = (ch == '%');
  1586.             if (pe)
  1587.             {
  1588.                 // parameter entity.
  1589.                 this.current.ReadChar(); // move to next char
  1590.                 ch = this.current.SkipWhitespace();
  1591.             }
  1592.             string name = this.current.ScanToken(this.sb, SgmlDtd.WhiteSpace, true);
  1593.             name = this.nameTable.Add(name);
  1594.             ch = this.current.SkipWhitespace();
  1595.             Entity e = null;
  1596.             if (ch == '"' || ch == ''') 
  1597.             {
  1598.                 string literal = this.current.ScanLiteral(this.sb, ch);
  1599.                 e = new Entity(name, literal);                
  1600.             } 
  1601.             else 
  1602.             {
  1603.                 string pubid = null;
  1604.                 string extid = null;
  1605.                 string tok = this.current.ScanToken(this.sb, SgmlDtd.WhiteSpace, true);
  1606.                 if (Entity.IsLiteralType(tok) )
  1607.                 {
  1608.                     ch = this.current.SkipWhitespace();
  1609.                     string literal = this.current.ScanLiteral(this.sb, ch);
  1610.                     e = new Entity(name, literal);
  1611.                     e.SetLiteralType(tok);
  1612.                 }
  1613.                 else 
  1614.                 {
  1615.                     extid = tok;
  1616.                     if (extid == "PUBLIC") 
  1617.                     {
  1618.                         ch = this.current.SkipWhitespace();
  1619.                         if (ch == '"' || ch == ''') 
  1620.                         {
  1621.                             pubid = this.current.ScanLiteral(this.sb, ch);
  1622.                         } 
  1623.                         else 
  1624.                         {
  1625.                             this.current.Error("Expecting public identifier literal but found '{0}'",ch);
  1626.                         }
  1627.                     } 
  1628.                     else if (extid != "SYSTEM") 
  1629.                     {
  1630.                         this.current.Error("Invalid external identifier '{0}'.  Expecing 'PUBLIC' or 'SYSTEM'.", extid);
  1631.                     }
  1632.                     string uri = null;
  1633.                     ch = this.current.SkipWhitespace();
  1634.                     if (ch == '"' || ch == ''') 
  1635.                     {
  1636.                         uri = this.current.ScanLiteral(this.sb, ch);
  1637.                     } 
  1638.                     else if (ch != '>')
  1639.                     {
  1640.                         this.current.Error("Expecting system identifier literal but found '{0}'",ch);
  1641.                     }
  1642.                     e = new Entity(name, pubid, uri, this.current.Proxy);
  1643.                 }
  1644.             }
  1645.             ch = this.current.SkipWhitespace();
  1646.             if (ch == '-') 
  1647.                 ch = ParseDeclComments();
  1648.             if (ch != '>') 
  1649.             {
  1650.                 this.current.Error("Expecting end of entity declaration '>' but found '{0}'", ch);  
  1651.             }           
  1652.             if (pe) this.pentities.Add(e.Name, e);
  1653.             else this.entities.Add(e.Name, e);
  1654.         }
  1656.         void ParseElementDecl()
  1657.         {
  1658.             char ch = this.current.SkipWhitespace();
  1659.             string[] names = ParseNameGroup(ch, true);
  1660.             ch = Char.ToUpper(this.current.SkipWhitespace());
  1661.             bool sto = false;
  1662.             bool eto = false;
  1663.             if (ch == 'O' || ch == '-') {
  1664.                 sto = (ch == 'O'); // start tag optional?   
  1665.                 this.current.ReadChar();
  1666.                 ch = Char.ToUpper(this.current.SkipWhitespace());
  1667.                 if (ch == 'O' || ch == '-'){
  1668.                     eto = (ch == 'O'); // end tag optional? 
  1669.                     ch = this.current.ReadChar();
  1670.                 }
  1671.             }
  1672.             ch = this.current.SkipWhitespace();
  1673.             ContentModel cm = ParseContentModel(ch);
  1674.             ch = this.current.SkipWhitespace();
  1676.             string [] exclusions = null;
  1677.             string [] inclusions = null;
  1679.             if (ch == '-') 
  1680.             {
  1681.                 ch = this.current.ReadChar();
  1682.                 if (ch == '(') 
  1683.                 {
  1684.                     exclusions = ParseNameGroup(ch, true);
  1685.                     ch = this.current.SkipWhitespace();
  1686.                 }
  1687.                 else if (ch == '-') 
  1688.                 {
  1689.                     ch = ParseDeclComment(false);
  1690.                 } 
  1691.                 else 
  1692.                 {
  1693.                     this.current.Error("Invalid syntax at '{0}'", ch);  
  1694.                 }
  1695.             }
  1697.             if (ch == '-') 
  1698.                 ch = ParseDeclComments();
  1700.             if (ch == '+') 
  1701.             {
  1702.                 ch = this.current.ReadChar();
  1703.                 if (ch != '(') 
  1704.                 {
  1705.                     this.current.Error("Expecting inclusions name group", ch);  
  1706.                 }
  1707.                 inclusions = ParseNameGroup(ch, true);
  1708.                 ch = this.current.SkipWhitespace();
  1709.             }
  1711.             if (ch == '-') 
  1712.                 ch = ParseDeclComments();
  1715.             if (ch != '>') 
  1716.             {
  1717.                 this.current.Error("Expecting end of ELEMENT declaration '>' but found '{0}'", ch); 
  1718.             }
  1720.             foreach (string name in names) 
  1721.             {
  1722.                 string atom = name.ToUpper();
  1723.                 atom = this.nameTable.Add(name); 
  1724.                 this.elements.Add(atom, new ElementDecl(atom, sto, eto, cm, inclusions, exclusions));
  1725.             }
  1726.         }
  1728.         static string ngterm = " rnt|,)";
  1729.         string[] ParseNameGroup(char ch, bool nmtokens)
  1730.         {
  1731.             ArrayList names = new ArrayList();
  1732.             if (ch == '(') 
  1733.             {
  1734.                 ch = this.current.ReadChar();
  1735.                 ch = this.current.SkipWhitespace();
  1736.                 while (ch != ')') 
  1737.                 {
  1738.                     // skip whitespace, scan name (which may be parameter entity reference
  1739.                     // which is then expanded to a name)                    
  1740.                     ch = this.current.SkipWhitespace();
  1741.                     if (ch == '%') 
  1742.                     {
  1743.                         Entity e = ParseParameterEntity(SgmlDtd.ngterm);
  1744.                         PushEntity(this.current.ResolvedUri, e);
  1745.                         ParseNameList(names, nmtokens);
  1746.                         PopEntity();
  1747.                         ch = this.current.Lastchar;
  1748.                     }
  1749.                     else 
  1750.                     {
  1751.                         string token = this.current.ScanToken(this.sb, SgmlDtd.ngterm, nmtokens);
  1752.                         token = token.ToUpper();
  1753.                         string atom = this.nameTable.Add(token);
  1754.                         names.Add(atom);
  1755.                     }
  1756.                     ch = this.current.SkipWhitespace();
  1757.                     if (ch == '|' || ch == ',') ch = this.current.ReadChar();
  1758.                 }
  1759.                 this.current.ReadChar(); // consume ')'
  1760.             } 
  1761.             else 
  1762.             {
  1763.                 string name = this.current.ScanToken(this.sb, SgmlDtd.WhiteSpace, nmtokens);
  1764.                 name = name.ToUpper();
  1765.                 name = this.nameTable.Add(name);
  1766.                 names.Add(name);
  1767.             }
  1768.             return (string[])names.ToArray(typeof(String));
  1769.         }
  1771.         void ParseNameList(ArrayList names, bool nmtokens)
  1772.         {
  1773.             char ch = this.current.Lastchar;
  1774.             ch = this.current.SkipWhitespace();
  1775.             while (ch != Entity.EOF) 
  1776.             {
  1777.                 string name;
  1778.                 if (ch == '%') 
  1779.                 {
  1780.                     Entity e = ParseParameterEntity(SgmlDtd.ngterm);
  1781.                     PushEntity(this.current.ResolvedUri, e);
  1782.                     ParseNameList(names, nmtokens);
  1783.                     PopEntity();
  1784.                     ch = this.current.Lastchar;
  1785.                 } 
  1786.                 else 
  1787.                 {
  1788.                     name = this.current.ScanToken(this.sb, SgmlDtd.ngterm, true);
  1789.                     name = name.ToUpper();
  1790.                     name = this.nameTable.Add(name);
  1791.                     names.Add(name);
  1792.                 }
  1793.                 ch = this.current.SkipWhitespace();
  1794.                 if (ch == '|') 
  1795.                 {
  1796.                     ch = this.current.ReadChar();
  1797.                     ch = this.current.SkipWhitespace();
  1798.                 }
  1799.             }
  1800.         }
  1802.         static string dcterm = " rnt>";
  1803.         ContentModel ParseContentModel(char ch)
  1804.         {
  1805.             ContentModel cm = new ContentModel();
  1806.             if (ch == '(') 
  1807.             {
  1808.                 this.current.ReadChar();
  1809.                 ParseModel(')', cm);
  1810.                 ch = this.current.ReadChar();
  1811.                 if (ch == '?' || ch == '+' || ch == '*') 
  1812.                 {
  1813.                     cm.AddOccurrence(ch);
  1814.                     this.current.ReadChar();
  1815.                 }
  1816.             } 
  1817.             else if (ch == '%') 
  1818.             {
  1819.                 Entity e = ParseParameterEntity(SgmlDtd.dcterm);
  1820.                 PushEntity(this.current.ResolvedUri, e);
  1821.                 cm = ParseContentModel(this.current.Lastchar);
  1822.                 PopEntity(); // bugbug should be at EOF.
  1823.             }
  1824.             else
  1825.             {
  1826.                 string dc = ScanName(SgmlDtd.dcterm);
  1827.                 cm.SetDeclaredContent(dc);
  1828.             }
  1829.             return cm;
  1830.         }
  1832.         static string cmterm = " rnt,&|()?+*";
  1833.         void ParseModel(char cmt, ContentModel cm)
  1834.         {
  1835.             // Called when part of the model is made up of the contents of a parameter entity
  1836.             int depth = cm.CurrentDepth;
  1837.             char ch = this.current.Lastchar;
  1838.             ch = this.current.SkipWhitespace();
  1839.             while (ch != cmt || cm.CurrentDepth > depth) // the entity must terminate while inside the content model.
  1840.             {
  1841.                 if (ch == Entity.EOF) 
  1842.                 {
  1843.                     this.current.Error("Content Model was not closed");
  1844.                 }
  1845.                 if (ch == '%') 
  1846.                 {
  1847.                     Entity e = ParseParameterEntity(SgmlDtd.cmterm);
  1848.                     PushEntity(this.current.ResolvedUri, e);
  1849.                     ParseModel(Entity.EOF, cm);
  1850.                     PopEntity();                    
  1851.                     ch = this.current.SkipWhitespace();
  1852.                 } 
  1853.                 else if (ch == '(') 
  1854.                 {
  1855.                     cm.PushGroup();
  1856.                     this.current.ReadChar();// consume '('
  1857.                     ch = this.current.SkipWhitespace();
  1858.                 }
  1859.                 else if (ch == ')') 
  1860.                 {
  1861.                     ch = this.current.ReadChar();// consume ')'
  1862.                     if (ch == '*' || ch == '+' || ch == '?') 
  1863.                     {
  1864.                         cm.AddOccurrence(ch);
  1865.                         ch = this.current.ReadChar();
  1866.                     }
  1867.                     if (cm.PopGroup() < depth)
  1868.                     {
  1869.                         this.current.Error("Parameter entity cannot close a paren outside it's own scope");
  1870.                     }
  1871.                     ch = this.current.SkipWhitespace();
  1872.                 }
  1873.                 else if (ch == ',' || ch == '|' || ch == '&') 
  1874.                 {
  1875.                     cm.AddConnector(ch);
  1876.                     this.current.ReadChar(); // skip connector
  1877.                     ch = this.current.SkipWhitespace();
  1878.                 }
  1879.                 else
  1880.                 {
  1881.                     string token;
  1882.                     if (ch == '#') 
  1883.                     {
  1884.                         ch = this.current.ReadChar();
  1885.                         token = "#" + this.current.ScanToken(this.sb, SgmlDtd.cmterm, true); // since '#' is not a valid name character.
  1886.                     } 
  1887.                     else 
  1888.                     {
  1889.                         token = this.current.ScanToken(this.sb, SgmlDtd.cmterm, true);
  1890.                     }
  1891.                     token = token.ToUpper();
  1892.                     token = this.nameTable.Add(token);// atomize it.
  1893.                     ch = this.current.Lastchar;
  1894.                     if (ch == '?' || ch == '+' || ch == '*') 
  1895.                     {
  1896.                         cm.PushGroup();
  1897.                         cm.AddSymbol(token);
  1898.                         cm.AddOccurrence(ch);
  1899.                         cm.PopGroup();
  1900.                         this.current.ReadChar(); // skip connector
  1901.                         ch = this.current.SkipWhitespace();
  1902.                     } 
  1903.                     else 
  1904.                     {
  1905.                         cm.AddSymbol(token);
  1906.                         ch = this.current.SkipWhitespace();
  1907.                     }                   
  1908.                 }
  1909.             }
  1910.         }
  1912.         void ParseAttList()
  1913.         {
  1914.             char ch = this.current.SkipWhitespace();
  1915.             string[] names = ParseNameGroup(ch, true);          
  1916.             AttList attlist = new AttList();
  1917.             ParseAttList(attlist, '>');
  1918.             foreach (string name in names) 
  1919.             {
  1920.                 ElementDecl e = (ElementDecl)this.elements[name];
  1921.                 if (e == null) 
  1922.                 {
  1923.                     this.current.Error("ATTLIST references undefined ELEMENT {0}", name);
  1924.                 }
  1925.                 e.AddAttDefs(attlist);
  1926.             }
  1927.         }
  1929.         static string peterm = " trn>";
  1930.         void ParseAttList(AttList list, char term)
  1931.         {
  1932.             char ch = this.current.SkipWhitespace();
  1933.             while (ch != term) 
  1934.             {
  1935.                 if (ch == '%') 
  1936.                 {
  1937.                     Entity e = ParseParameterEntity(SgmlDtd.peterm);
  1938.                     PushEntity(this.current.ResolvedUri, e);
  1939.                     ParseAttList(list, Entity.EOF);
  1940.                     PopEntity();                    
  1941.                     ch = this.current.SkipWhitespace();
  1942.                 } 
  1943.                 else if (ch == '-') 
  1944.                 {
  1945.                     ch = ParseDeclComments();
  1946.                 }
  1947.                 else
  1948.                 {
  1949.                     AttDef a = ParseAttDef(ch);
  1950.                     list.Add(a);
  1951.                 }
  1952.                 ch = this.current.SkipWhitespace();
  1953.             }
  1954.         }
  1956.         AttDef ParseAttDef(char ch)
  1957.         {
  1958.             ch = this.current.SkipWhitespace();
  1959.             string name = ScanName(SgmlDtd.WhiteSpace);
  1960.             name = name.ToUpper();
  1961.             name = this.nameTable.Add(name);
  1962.             AttDef attdef = new AttDef(name);
  1964.             ch = this.current.SkipWhitespace();
  1965.             if (ch == '-') 
  1966.                 ch = ParseDeclComments();               
  1968.             ParseAttType(ch, attdef);
  1970.             ch = this.current.SkipWhitespace();
  1971.             if (ch == '-') 
  1972.                 ch = ParseDeclComments();               
  1974.             ParseAttDefault(ch, attdef);
  1976.             ch = this.current.SkipWhitespace();
  1977.             if (ch == '-') 
  1978.                 ch = ParseDeclComments();               
  1980.             return attdef;
  1982.         }
  1984.         void ParseAttType(char ch, AttDef attdef)
  1985.         {
  1986.             if (ch == '%')
  1987.             {
  1988.                 Entity e = ParseParameterEntity(SgmlDtd.WhiteSpace);
  1989.                 PushEntity(this.current.ResolvedUri, e);
  1990.                 ParseAttType(this.current.Lastchar, attdef);
  1991.                 PopEntity(); // bugbug - are we at the end of the entity?
  1992.                 ch = this.current.Lastchar;
  1993.                 return;
  1994.             }
  1996.             if (ch == '(') 
  1997.             {
  1998.                 attdef.EnumValues = ParseNameGroup(ch, false);  
  1999.                 attdef.Type = AttributeType.ENUMERATION;
  2000.             } 
  2001.             else 
  2002.             {
  2003.                 string token = ScanName(SgmlDtd.WhiteSpace);
  2004.                 if (token == "NOTATION") 
  2005.                 {
  2006.                     ch = this.current.SkipWhitespace();
  2007.                     if (ch != '(') 
  2008.                     {
  2009.                         this.current.Error("Expecting name group '(', but found '{0}'", ch);
  2010.                     }
  2011.                     attdef.Type = AttributeType.NOTATION;
  2012.                     attdef.EnumValues = ParseNameGroup(ch, true);
  2013.                 } 
  2014.                 else 
  2015.                 {
  2016.                     attdef.SetType(token);
  2017.                 }
  2018.             }
  2019.         }
  2021.         void ParseAttDefault(char ch, AttDef attdef)
  2022.         {
  2023.             if (ch == '%')
  2024.             {
  2025.                 Entity e = ParseParameterEntity(SgmlDtd.WhiteSpace);
  2026.                 PushEntity(this.current.ResolvedUri, e);
  2027.                 ParseAttDefault(this.current.Lastchar, attdef);
  2028.                 PopEntity(); // bugbug - are we at the end of the entity?
  2029.                 ch = this.current.Lastchar;
  2030.                 return;
  2031.             }
  2033.             bool hasdef = true;
  2034.             if (ch == '#') 
  2035.             {
  2036.                 this.current.ReadChar();
  2037.                 string token = this.current.ScanToken(this.sb, SgmlDtd.WhiteSpace, true);
  2038.                 hasdef = attdef.SetPresence(token);
  2039.                 ch = this.current.SkipWhitespace();
  2040.             } 
  2041.             if (hasdef) 
  2042.             {
  2043.                 if (ch == ''' || ch == '"') 
  2044.                 {
  2045.                     string lit = this.current.ScanLiteral(this.sb, ch);
  2046.                     attdef.Default = lit;
  2047.                     ch = this.current.SkipWhitespace();
  2048.                 }
  2049.                 else
  2050.                 {
  2051.                     string name = this.current.ScanToken(this.sb, SgmlDtd.WhiteSpace, false);
  2052.                     name = name.ToUpper();
  2053.                     name = this.nameTable.Add(name);
  2054.                     attdef.Default = name; // bugbug - must be one of the enumerated names.
  2055.                     ch = this.current.SkipWhitespace();
  2056.                 }
  2057.             }
  2058.         }
  2059.     }   
  2061.     class StringUtilities {
  2062.         public static bool EqualsIgnoreCase(string a, string b){
  2063.             return string.Compare(a, b, true, CultureInfo.InvariantCulture) == 0;
  2064.         }
  2065.     }
  2066. }