?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rename net_2_1 to moonlight
[mcs.git] / class / System.Security / Mono.Xml / XmlCanonicalizer.cs
blobae267a93856c6fac3fe75814a225d151a4216aee
1 //
2 // XmlCanonicalizer.cs - C14N implementation for XML Signature
3 // http://www.w3.org/TR/xml-c14n
4 //
5 // Author:
6 // Aleksey Sanin (aleksey@aleksey.com)
7 //
8 // (C) 2003 Aleksey Sanin (aleksey@aleksey.com)
9 //
10
11 //
12 // Permission is hereby granted, free of charge, to any person obtaining
13 // a copy of this software and associated documentation files (the
14 // "Software"), to deal in the Software without restriction, including
15 // without limitation the rights to use, copy, modify, merge, publish,
16 // distribute, sublicense, and/or sell copies of the Software, and to
17 // permit persons to whom the Software is furnished to do so, subject to
18 // the following conditions:
19 //
20 // The above copyright notice and this permission notice shall be
21 // included in all copies or substantial portions of the Software.
22 //
23 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
27 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
28 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
29 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
30 //
31 using System;
32 using System.Collections;
33 using System.IO;
34 using System.Text;
35 using System.Xml;
36
37 namespace Mono.Xml {
38
39 internal class XmlCanonicalizer {
40
41 private enum XmlCanonicalizerState
42 {
43 BeforeDocElement,
44 InsideDocElement,
45 AfterDocElement
46 }
47
48 // c14n parameters
49 private bool comments;
50 private bool exclusive;
51 string inclusiveNamespacesPrefixList;
52
53 // input/output
54 private XmlNodeList xnl;
55 private StringBuilder res;
56
57 // namespaces rendering stack
58 private XmlCanonicalizerState state;
59 private ArrayList visibleNamespaces;
60 private int prevVisibleNamespacesStart;
61 private int prevVisibleNamespacesEnd;
62 private Hashtable propagatedNss;
63
64 public XmlCanonicalizer (bool withComments, bool excC14N, Hashtable propagatedNamespaces)
65 {
66 res = new StringBuilder ();
67 comments = withComments;
68 exclusive = excC14N;
69 propagatedNss = propagatedNamespaces;
70 }
71
72 void Initialize ()
73 {
74 state = XmlCanonicalizerState.BeforeDocElement;
75 visibleNamespaces = new ArrayList ();
76 prevVisibleNamespacesStart = 0;
77 prevVisibleNamespacesEnd = 0;
78 res.Length = 0;
79 }
80
81 public Stream Canonicalize (XmlDocument doc)
82 {
83 if (doc == null)
84 throw new ArgumentNullException ("doc");
85 Initialize ();
86
87 FillMissingPrefixes (doc, new XmlNamespaceManager (doc.NameTable), new ArrayList ());
88 WriteDocumentNode (doc);
89
90 UTF8Encoding utf8 = new UTF8Encoding ();
91 byte[] data = utf8.GetBytes (res.ToString ());
92 return new MemoryStream (data);
93 }
94
95 public Stream Canonicalize (XmlNodeList nodes)
96 {
97 xnl = nodes;
98 if (nodes == null || nodes.Count < 1)
99 return new MemoryStream ();
100 XmlNode n = nodes [0];
101 return Canonicalize (n.NodeType == XmlNodeType.Document ? n as XmlDocument : n.OwnerDocument);
102 }
103
104 // See xml-enc-c14n specification
105 public string InclusiveNamespacesPrefixList {
106 get { return inclusiveNamespacesPrefixList; }
107 set { inclusiveNamespacesPrefixList = value; }
108 }
109
110 XmlAttribute CreateXmlns (XmlNode n)
111 {
112 XmlAttribute a = n.Prefix.Length == 0 ?
113 n.OwnerDocument.CreateAttribute ("xmlns", "http://www.w3.org/2000/xmlns/") :
114 n.OwnerDocument.CreateAttribute ("xmlns", n.Prefix, "http://www.w3.org/2000/xmlns/");
115 a.Value = n.NamespaceURI;
116 return a;
117 }
118
119 // Note that this must be done *before* filtering nodes out
120 // by context node list.
121 private void FillMissingPrefixes (XmlNode n, XmlNamespaceManager nsmgr, ArrayList tmpList)
122 {
123 if (n.Prefix.Length == 0 && propagatedNss != null) {
124 foreach (DictionaryEntry de in propagatedNss)
125 if ((string) de.Value == n.NamespaceURI) {
126 n.Prefix = (string) de.Key;
127 break;
128 }
129 }
130
131 if (n.NodeType == XmlNodeType.Element && ((XmlElement) n).HasAttributes) {
132 foreach (XmlAttribute a in n.Attributes)
133 if (a.NamespaceURI == "http://www.w3.org/2000/xmlns/")
134 nsmgr.AddNamespace (a.Prefix.Length == 0 ? String.Empty : a.LocalName, a.Value);
135 nsmgr.PushScope ();
136 }
137
138 if (n.NamespaceURI.Length > 0 && nsmgr.LookupPrefix (n.NamespaceURI) == null)
139 tmpList.Add (CreateXmlns (n));
140
141 if (n.NodeType == XmlNodeType.Element && ((XmlElement) n).HasAttributes) {
142 foreach (XmlAttribute a in n.Attributes)
143 if (a.NamespaceURI.Length > 0 && nsmgr.LookupNamespace (a.Prefix) == null)
144 tmpList.Add (CreateXmlns (a));
145 }
146
147 foreach (XmlAttribute a in tmpList)
148 ((XmlElement) n).SetAttributeNode (a);
149 tmpList.Clear ();
150
151 if (n.HasChildNodes) {
152 for (XmlNode c = n.FirstChild; c != null; c = c.NextSibling)
153 if (c.NodeType == XmlNodeType.Element)
154 FillMissingPrefixes (c, nsmgr, tmpList);
155 }
156 nsmgr.PopScope ();
157 }
158
159 private void WriteNode (XmlNode node)
160 {
161 // Console.WriteLine ("C14N Debug: node=" + node.Name);
162
163 bool visible = IsNodeVisible (node);
164 switch (node.NodeType) {
165 case XmlNodeType.Document:
166 case XmlNodeType.DocumentFragment:
167 WriteDocumentNode (node);
168 break;
169 case XmlNodeType.Element:
170 WriteElementNode (node, visible);
171 break;
172 case XmlNodeType.CDATA:
173 case XmlNodeType.SignificantWhitespace:
174 case XmlNodeType.Text:
175 // CDATA sections are processed as text nodes
176 WriteTextNode (node, visible);
177 break;
178 case XmlNodeType.Whitespace:
179 if (state == XmlCanonicalizerState.InsideDocElement)
180 WriteTextNode (node, visible);
181 break;
182 case XmlNodeType.Comment:
183 WriteCommentNode (node, visible);
184 break;
185 case XmlNodeType.ProcessingInstruction:
186 WriteProcessingInstructionNode (node, visible);
187 break;
188 case XmlNodeType.EntityReference:
189 for (int i = 0; i < node.ChildNodes.Count; i++)
190 WriteNode (node.ChildNodes [i]);
191 break;
192 case XmlNodeType.Attribute:
193 throw new XmlException ("Attribute node is impossible here", null);
194 case XmlNodeType.EndElement:
195 throw new XmlException ("EndElement node is impossible here", null);
196 case XmlNodeType.EndEntity:
197 throw new XmlException ("EndEntity node is impossible here", null);
198 case XmlNodeType.DocumentType:
199 case XmlNodeType.Entity:
200 case XmlNodeType.Notation:
201 case XmlNodeType.XmlDeclaration:
202 // just do nothing
203 break;
204 }
205 }
206
207 private void WriteDocumentNode (XmlNode node)
208 {
209 state = XmlCanonicalizerState.BeforeDocElement;
210 for (XmlNode child = node.FirstChild; child != null; child = child.NextSibling)
211 WriteNode (child);
212 }
213
214 // Element Nodes
215 // If the element is not in the node-set, then the result is obtained
216 // by processing the namespace axis, then the attribute axis, then
217 // processing the child nodes of the element that are in the node-set
218 // (in document order). If the element is inthe node-set, then the result
219 // is an open angle bracket (<), the element QName, the result of
220 // processing the namespace axis, the result of processing the attribute
221 // axis, a close angle bracket (>), the result of processing the child
222 // nodes of the element that are in the node-set (in document order), an
223 // open angle bracket, a forward slash (/), the element QName, and a close
224 // angle bracket.
225 private void WriteElementNode (XmlNode node, bool visible)
226 {
227 // Console.WriteLine ("Debug: element node");
228
229 // remember current state
230 int savedPrevVisibleNamespacesStart = prevVisibleNamespacesStart;
231 int savedPrevVisibleNamespacesEnd = prevVisibleNamespacesEnd;
232 int savedVisibleNamespacesSize = visibleNamespaces.Count;
233 XmlCanonicalizerState s = state;
234 if (visible && state == XmlCanonicalizerState.BeforeDocElement)
235 state = XmlCanonicalizerState.InsideDocElement;
236
237 // write start tag
238 if (visible) {
239 res.Append ("<");
240 res.Append (node.Name);
241 }
242
243 // this is odd but you can select namespaces
244 // and attributes even if node itself is not visible
245 WriteNamespacesAxis (node, visible);
246 WriteAttributesAxis (node);
247
248 if (visible)
249 res.Append (">");
250
251 // write children
252 for (XmlNode child = node.FirstChild; child != null; child = child.NextSibling)
253 WriteNode (child);
254
255 // write end tag
256 if (visible) {
257 res.Append ("</");
258 res.Append (node.Name);
259 res.Append (">");
260 }
261
262 // restore state
263 if (visible && s == XmlCanonicalizerState.BeforeDocElement)
264 state = XmlCanonicalizerState.AfterDocElement;
265 prevVisibleNamespacesStart = savedPrevVisibleNamespacesStart;
266 prevVisibleNamespacesEnd = savedPrevVisibleNamespacesEnd;
267 if (visibleNamespaces.Count > savedVisibleNamespacesSize) {
268 visibleNamespaces.RemoveRange (savedVisibleNamespacesSize,
269 visibleNamespaces.Count - savedVisibleNamespacesSize);
270 }
271 }
272
273 // Namespace Axis
274 // Consider a list L containing only namespace nodes in the
275 // axis and in the node-set in lexicographic order (ascending). To begin
276 // processing L, if the first node is not the default namespace node (a node
277 // with no namespace URI and no local name), then generate a space followed
278 // by xmlns="" if and only if the following conditions are met:
279 // - the element E that owns the axis is in the node-set
280 // - The nearest ancestor element of E in the node-set has a default
281 // namespace node in the node-set (default namespace nodes always
282 // have non-empty values in XPath)
283 // The latter condition eliminates unnecessary occurrences of xmlns="" in
284 // the canonical form since an element only receives an xmlns="" if its
285 // default namespace is empty and if it has an immediate parent in the
286 // canonical form that has a non-empty default namespace. To finish
287 // processing L, simply process every namespace node in L, except omit
288 // namespace node with local name xml, which defines the xml prefix,
289 // if its string value is http://www.w3.org/XML/1998/namespace.
290 private void WriteNamespacesAxis (XmlNode node, bool visible)
291 {
292 // Console.WriteLine ("Debug: namespaces");
293
294 XmlDocument doc = node.OwnerDocument;
295 bool has_empty_namespace = false;
296 ArrayList list = new ArrayList ();
297 for (XmlNode cur = node; cur != null && cur != doc; cur = cur.ParentNode) {
298 foreach (XmlAttribute attribute in cur.Attributes) {
299 if (!IsNamespaceNode (attribute))
300 continue;
301
302 // get namespace prefix
303 string prefix = string.Empty;
304 if (attribute.Prefix == "xmlns")
305 prefix = attribute.LocalName;
306
307 // check if it is "xml" namespace
308 if (prefix == "xml" && attribute.Value == "http://www.w3.org/XML/1998/namespace")
309 continue;
310
311 // make sure that this is an active namespace
312 // for our node
313 string ns = node.GetNamespaceOfPrefix (prefix);
314 if (ns != attribute.Value)
315 continue;
316
317 // check that it is selected with XPath
318 if (!IsNodeVisible (attribute))
319 continue;
320
321 // check that we have not rendered it yet
322 bool rendered = IsNamespaceRendered (prefix, attribute.Value);
323
324 // For exc-c14n, only visibly utilized
325 // namespaces are written.
326 if (exclusive && !IsVisiblyUtilized (node as XmlElement, attribute))
327 continue;
328
329 // add to the visible namespaces stack
330 if (visible)
331 visibleNamespaces.Add (attribute);
332
333 if (!rendered)
334 list.Add (attribute);
335
336 if (prefix == string.Empty)
337 has_empty_namespace = true;
338 }
339 }
340
341 // add empty namespace if needed
342 if (visible && !has_empty_namespace && !IsNamespaceRendered (string.Empty, string.Empty) && node.NamespaceURI == String.Empty)
343 res.Append (" xmlns=\"\"");
344
345 list.Sort (new XmlDsigC14NTransformNamespacesComparer ());
346 foreach (object obj in list) {
347 XmlNode attribute = (obj as XmlNode);
348 if (attribute != null) {
349 res.Append (" ");
350 res.Append (attribute.Name);
351 res.Append ("=\"");
352 res.Append (attribute.Value);
353 res.Append ("\"");
354 }
355 }
356
357 // move the rendered namespaces stack
358 if (visible) {
359 prevVisibleNamespacesStart = prevVisibleNamespacesEnd;
360 prevVisibleNamespacesEnd = visibleNamespaces.Count;
361 }
362 }
363
364 // Attribute Axis
365 // In lexicographic order (ascending), process each node that
366 // is in the element's attribute axis and in the node-set.
367 //
368 // The processing of an element node E MUST be modified slightly
369 // when an XPath node-set is given as input and the element's
370 // parent is omitted from the node-set.
371 private void WriteAttributesAxis (XmlNode node)
372 {
373 // Console.WriteLine ("Debug: attributes");
374
375 ArrayList list = new ArrayList ();
376 foreach (XmlNode attribute in node.Attributes) {
377 if (!IsNamespaceNode (attribute) && IsNodeVisible (attribute))
378 list.Add (attribute);
379 }
380
381 // Add attributes from "xml" namespace for "inclusive" c14n only:
382 //
383 // The method for processing the attribute axis of an element E
384 // in the node-set is enhanced. All element nodes along E's
385 // ancestor axis are examined for nearest occurrences of
386 // attributes in the xml namespace, such as xml:lang and
387 // xml:space (whether or not they are in the node-set).
388 // From this list of attributes, remove any that are in E's
389 // attribute axis (whether or not they are in the node-set).
390 // Then, lexicographically merge this attribute list with the
391 // nodes of E's attribute axis that are in the node-set. The
392 // result of visiting the attribute axis is computed by
393 // processing the attribute nodes in this merged attribute list.
394 if (!exclusive && node.ParentNode != null && node.ParentNode.ParentNode != null && !IsNodeVisible (node.ParentNode.ParentNode)) {
395 // if we have whole document then the node.ParentNode.ParentNode
396 // is always visible
397 for (XmlNode cur = node.ParentNode; cur != null; cur = cur.ParentNode) {
398 if (cur.Attributes == null)
399 continue;
400 foreach (XmlNode attribute in cur.Attributes) {
401 // we are looking for "xml:*" attributes
402 if (attribute.Prefix != "xml")
403 continue;
404
405 // exclude ones that are in the node's attributes axis
406 if (node.Attributes.GetNamedItem (attribute.LocalName, attribute.NamespaceURI) != null)
407 continue;
408
409 // finally check that we don't have the same attribute in our list
410 bool found = false;
411 foreach (object obj in list) {
412 XmlNode n = (obj as XmlNode);
413 if (n.Prefix == "xml" && n.LocalName == attribute.LocalName) {
414 found = true;
415 break;
416 }
417 }
418
419 if (found)
420 continue;
421
422 // now we can add this attribute to our list
423 list.Add (attribute);
424 }
425 }
426 }
427
428 // sort namespaces and write results
429 list.Sort (new XmlDsigC14NTransformAttributesComparer ());
430 foreach (object obj in list) {
431 XmlNode attribute = (obj as XmlNode);
432 if (attribute != null) {
433 res.Append (" ");
434 res.Append (attribute.Name);
435 res.Append ("=\"");
436 res.Append (NormalizeString (attribute.Value, XmlNodeType.Attribute));
437 res.Append ("\"");
438 }
439 }
440 }
441
442 // Text Nodes
443 // the string value, except all ampersands are replaced
444 // by &amp;, all open angle brackets (<) are replaced by &lt;, all closing
445 // angle brackets (>) are replaced by &gt;, and all #xD characters are
446 // replaced by &#xD;.
447 private void WriteTextNode (XmlNode node, bool visible)
448 {
449 // Console.WriteLine ("Debug: text node");
450 if (visible)
451 res.Append (NormalizeString (node.Value, node.NodeType));
452 // res.Append (NormalizeString (node.Value, XmlNodeType.Text));
453 }
454
455 // Comment Nodes
456 // Nothing if generating canonical XML without comments. For
457 // canonical XML with comments, generate the opening comment
458 // symbol (<!--), the string value of the node, and the
459 // closing comment symbol (-->). Also, a trailing #xA is rendered
460 // after the closing comment symbol for comment children of the
461 // root node with a lesser document order than the document
462 // element, and a leading #xA is rendered before the opening
463 // comment symbol of comment children of the root node with a
464 // greater document order than the document element. (Comment
465 // children of the root node represent comments outside of the
466 // top-level document element and outside of the document type
467 // declaration).
468 private void WriteCommentNode (XmlNode node, bool visible)
469 {
470 // Console.WriteLine ("Debug: comment node");
471 if (visible && comments) {
472 if (state == XmlCanonicalizerState.AfterDocElement)
473 res.Append ("\x0A<!--");
474 else
475 res.Append ("<!--");
476
477 res.Append (NormalizeString (node.Value, XmlNodeType.Comment));
478
479 if (state == XmlCanonicalizerState.BeforeDocElement)
480 res.Append ("-->\x0A");
481 else
482 res.Append ("-->");
483 }
484 }
485
486 // Processing Instruction (PI) Nodes-
487 // The opening PI symbol (<?), the PI target name of the node,
488 // a leading space and the string value if it is not empty, and
489 // the closing PI symbol (?>). If the string value is empty,
490 // then the leading space is not added. Also, a trailing #xA is
491 // rendered after the closing PI symbol for PI children of the
492 // root node with a lesser document order than the document
493 // element, and a leading #xA is rendered before the opening PI
494 // symbol of PI children of the root node with a greater document
495 // order than the document element.
496 private void WriteProcessingInstructionNode (XmlNode node, bool visible)
497 {
498 // Console.WriteLine ("Debug: PI node");
499
500 if (visible) {
501 if (state == XmlCanonicalizerState.AfterDocElement)
502 res.Append ("\x0A<?");
503 else
504 res.Append ("<?");
505
506 res.Append (node.Name);
507 if (node.Value.Length > 0) {
508 res.Append (" ");
509 res.Append (NormalizeString (node.Value, XmlNodeType.ProcessingInstruction));
510 }
511
512 if (state == XmlCanonicalizerState.BeforeDocElement)
513 res.Append ("?>\x0A");
514 else
515 res.Append ("?>");
516 }
517 }
518
519 // determines whether the node is in the node-set or not.
520 private bool IsNodeVisible (XmlNode node)
521 {
522 // if node list is empty then we process whole document
523 if (xnl == null)
524 return true;
525
526 // walk thru the list
527 foreach (XmlNode xn in xnl) {
528 if (node.Equals (xn))
529 return true;
530 }
531
532 return false;
533 }
534
535 // This method assumes that the namespace node is *not*
536 // rendered yet.
537 private bool IsVisiblyUtilized (XmlElement owner, XmlAttribute ns)
538 {
539 if (owner == null)
540 return false;
541
542 string prefix = ns.LocalName == "xmlns" ? String.Empty : ns.LocalName;
543 if (owner.Prefix == prefix && owner.NamespaceURI == ns.Value)
544 return true;
545 if (!owner.HasAttributes)
546 return false;
547 foreach (XmlAttribute a in owner.Attributes) {
548 if (a.Prefix == String.Empty)
549 continue;
550 if (a.Prefix != prefix || a.NamespaceURI != ns.Value)
551 continue;
552 if (IsNodeVisible (a))
553 return true;
554 }
555 return false;
556 }
557
558 private bool IsNamespaceRendered (string prefix, string uri)
559 {
560 // if the default namespace xmlns="" is not re-defined yet
561 // then we do not want to print it out
562 bool IsEmptyNs = prefix == string.Empty && uri == string.Empty;
563 int start = (IsEmptyNs) ? 0 : prevVisibleNamespacesStart;
564 for (int i = visibleNamespaces.Count - 1; i >= start; i--) {
565 XmlNode node = (visibleNamespaces[i] as XmlNode);
566 if (node != null) {
567 // get namespace prefix
568 string p = string.Empty;
569 if (node.Prefix == "xmlns")
570 p = node.LocalName;
571 if (p == prefix)
572 return node.Value == uri;
573 }
574 }
575
576 return IsEmptyNs;
577 }
578
579 private bool IsNamespaceNode (XmlNode node)
580 {
581 if (node == null || node.NodeType != XmlNodeType.Attribute)
582 return false;
583 return node.NamespaceURI == "http://www.w3.org/2000/xmlns/";
584 }
585
586 private bool IsTextNode (XmlNodeType type)
587 {
588 switch (type) {
589 case XmlNodeType.Text:
590 case XmlNodeType.CDATA:
591 case XmlNodeType.SignificantWhitespace:
592 case XmlNodeType.Whitespace:
593 return true;
594 }
595 return false;
596 }
597
598 private string NormalizeString (string input, XmlNodeType type)
599 {
600 StringBuilder sb = new StringBuilder ();
601 for (int i = 0; i < input.Length; i++) {
602 char ch = input[i];
603 if (ch == '<' && (type == XmlNodeType.Attribute || IsTextNode (type)))
604 sb.Append ("&lt;");
605 else if (ch == '>' && IsTextNode (type))
606 sb.Append ("&gt;");
607 else if (ch == '&' && (type == XmlNodeType.Attribute || IsTextNode (type)))
608 sb.Append ("&amp;");
609 else if (ch == '\"' && type == XmlNodeType.Attribute)
610 sb.Append ("&quot;");
611 else if (ch == '\x09' && type == XmlNodeType.Attribute)
612 sb.Append ("&#x9;");
613 else if (ch == '\x0A' && type == XmlNodeType.Attribute)
614 sb.Append ("&#xA;");
615 else if (ch == '\x0D')
616 sb.Append ("&#xD;");
617 else
618 sb.Append (ch);
619 }
620
621 return sb.ToString ();
622 }
623 }
624
625 internal class XmlDsigC14NTransformAttributesComparer : IComparer
626 {
627 public int Compare (object x, object y)
628 {
629 XmlNode n1 = (x as XmlNode);
630 XmlNode n2 = (y as XmlNode);
631
632 // simple cases
633 if (n1 == n2)
634 return 0;
635 else if (n1 == null)
636 return -1;
637 else if (n2 == null)
638 return 1;
639 else if (n1.Prefix == n2.Prefix)
640 return string.Compare (n1.LocalName, n2.LocalName);
641
642 // Attributes in the default namespace are first
643 // because the default namespace is not applied to
644 // unqualified attributes
645 if (n1.Prefix == string.Empty)
646 return -1;
647 else if (n2.Prefix == string.Empty)
648 return 1;
649
650 int ret = string.Compare (n1.NamespaceURI, n2.NamespaceURI);
651 if (ret == 0)
652 ret = string.Compare (n1.LocalName, n2.LocalName);
653 return ret;
654 }
655 }
656
657 internal class XmlDsigC14NTransformNamespacesComparer : IComparer
658 {
659 public int Compare (object x, object y)
660 {
661 XmlNode n1 = (x as XmlNode);
662 XmlNode n2 = (y as XmlNode);
663
664 // simple cases
665 if (n1 == n2)
666 return 0;
667 else if (n1 == null)
668 return -1;
669 else if (n2 == null)
670 return 1;
671 else if (n1.Prefix == string.Empty)
672 return -1;
673 else if (n2.Prefix == string.Empty)
674 return 1;
675
676 return string.Compare (n1.LocalName, n2.LocalName);
677 }
678 }
679 }
680
git-svn mirror of mcs