The Labs \ Source Viewer \ SSCLI \ System.Xml \ XmlComplianceUtil

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlComplianceUtil.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. using System;
  16. using System.IO;
  17. namespace System.Xml
  18. {
  19.     using System.Text;
  20.    
  21.     static internal class XmlComplianceUtil
  22.     {
  23.        
  24.         // Replaces \r\n, \n, \r and \t with single space (0x20) and then removes spaces
  25.         // at the beggining and and the end of the string and replaces sequences of spaces
  26.         // with a single space.
  27.         public static string NonCDataNormalize(string value)
  28.         {
  29.             int len = value.Length;
  30.             if (len <= 0) {
  31.                 return string.Empty;
  32.             }
  33.            
  34.             int startPos = 0;
  35.             StringBuilder norValue = null;
  36.             XmlCharType xmlCharType = XmlCharType.Instance;
  37.             while (xmlCharType.IsWhiteSpace(value[startPos])) {
  38.                 startPos++;
  39.                 if (startPos == len) {
  40.                     return " ";
  41.                 }
  42.             }
  43.            
  44.             int i = startPos;
  45.             while (i < len) {
  46.                 if (!xmlCharType.IsWhiteSpace(value[i])) {
  47.                     i++;
  48.                     continue;
  49.                 }
  50.                
  51.                 int j = i + 1;
  52.                 while (j < len && xmlCharType.IsWhiteSpace(value[j])) {
  53.                     j++;
  54.                 }
  55.                 if (j == len) {
  56.                     if (norValue == null) {
  57.                         return value.Substring(startPos, i - startPos);
  58.                     }
  59.                     else {
  60.                         norValue.Append(value, startPos, i - startPos);
  61.                         return norValue.ToString();
  62.                     }
  63.                 }
  64.                 if (j > i + 1 || value[i] != 32) {
  65.                     if (norValue == null) {
  66.                         norValue = new StringBuilder(len);
  67.                     }
  68.                     norValue.Append(value, startPos, i - startPos);
  69.                     norValue.Append((char)32);
  70.                     startPos = j;
  71.                     i = j;
  72.                 }
  73.                 else {
  74.                     i++;
  75.                 }
  76.             }
  77.            
  78.             if (norValue != null) {
  79.                 if (startPos < i) {
  80.                     norValue.Append(value, startPos, i - startPos);
  81.                 }
  82.                 return norValue.ToString();
  83.             }
  84.             else {
  85.                 if (startPos > 0) {
  86.                     return value.Substring(startPos, len - startPos);
  87.                 }
  88.                 else {
  89.                     return value;
  90.                 }
  91.             }
  92.         }
  93.        
  94.         // Replaces \r\n, \n, \r and \t with single space (0x20)
  95.         public static string CDataNormalize(string value)
  96.         {
  97.             int len = value.Length;
  98.            
  99.             if (len <= 0) {
  100.                 return string.Empty;
  101.             }
  102.            
  103.             int i = 0;
  104.             int startPos = 0;
  105.             StringBuilder norValue = null;
  106.            
  107.             while (i < len) {
  108.                 char ch = value[i];
  109.                 if (ch >= 32 || (ch != 9 && ch != 10 && ch != 13)) {
  110.                     i++;
  111.                     continue;
  112.                 }
  113.                
  114.                 if (norValue == null) {
  115.                     norValue = new StringBuilder(len);
  116.                 }
  117.                 if (startPos < i) {
  118.                     norValue.Append(value, startPos, i - startPos);
  119.                 }
  120.                 norValue.Append((char)32);
  121.                
  122.                 if (ch == 13 && (i + 1 < len && value[i + 1] == 10)) {
  123.                     i += 2;
  124.                 }
  125.                 else {
  126.                     i++;
  127.                 }
  128.                 startPos = i;
  129.             }
  130.            
  131.             if (norValue == null) {
  132.                 return value;
  133.             }
  134.             else {
  135.                 if (i > startPos) {
  136.                     norValue.Append(value, startPos, i - startPos);
  137.                 }
  138.                 return norValue.ToString();
  139.             }
  140.         }
  141.        
  142.         // StripSpaces removes spaces at the beginning and at the end of the value and replaces sequences of spaces with a single space
  143.         public static string StripSpaces(string value)
  144.         {
  145.             int len = value.Length;
  146.             if (len <= 0) {
  147.                 return string.Empty;
  148.             }
  149.            
  150.             int startPos = 0;
  151.             StringBuilder norValue = null;
  152.            
  153.             while (value[startPos] == 32) {
  154.                 startPos++;
  155.                 if (startPos == len) {
  156.                     return " ";
  157.                 }
  158.             }
  159.            
  160.             int i;
  161.             for (i = startPos; i < len; i++) {
  162.                 if (value[i] == 32) {
  163.                     int j = i + 1;
  164.                     while (j < len && value[j] == 32) {
  165.                         j++;
  166.                     }
  167.                     if (j == len) {
  168.                         if (norValue == null) {
  169.                             return value.Substring(startPos, i - startPos);
  170.                         }
  171.                         else {
  172.                             norValue.Append(value, startPos, i - startPos);
  173.                             return norValue.ToString();
  174.                         }
  175.                     }
  176.                     if (j > i + 1) {
  177.                         if (norValue == null) {
  178.                             norValue = new StringBuilder(len);
  179.                         }
  180.                         norValue.Append(value, startPos, i - startPos + 1);
  181.                         startPos = j;
  182.                         i = j - 1;
  183.                     }
  184.                 }
  185.             }
  186.             if (norValue == null) {
  187.                 return (startPos == 0) ? value : value.Substring(startPos, len - startPos);
  188.             }
  189.             else {
  190.                 if (i > startPos) {
  191.                     norValue.Append(value, startPos, i - startPos);
  192.                 }
  193.                 return norValue.ToString();
  194.             }
  195.         }
  196.        
  197.         // StripSpaces removes spaces at the beginning and at the end of the value and replaces sequences of spaces with a single space
  198.         public static void StripSpaces(char[] value, int index, ref int len)
  199.         {
  200.             if (len <= 0) {
  201.                 return;
  202.             }
  203.            
  204.             int startPos = index;
  205.             int endPos = index + len;
  206.            
  207.             while (value[startPos] == 32) {
  208.                 startPos++;
  209.                 if (startPos == endPos) {
  210.                     len = 1;
  211.                     return;
  212.                 }
  213.             }
  214.            
  215.             int offset = startPos - index;
  216.             int i;
  217.             for (i = startPos; i < endPos; i++) {
  218.                 char ch;
  219.                 if ((ch = value[i]) == 32) {
  220.                     int j = i + 1;
  221.                     while (j < endPos && value[j] == 32) {
  222.                         j++;
  223.                     }
  224.                     if (j == endPos) {
  225.                         offset += (j - i);
  226.                         break;
  227.                     }
  228.                     if (j > i + 1) {
  229.                         offset += (j - i - 1);
  230.                         i = j - 1;
  231.                     }
  232.                 }
  233.                 value[i - offset] = ch;
  234.             }
  235.             len -= offset;
  236.         }
  237.        
  238.         public static bool IsValidLanguageID(char[] value, int startPos, int length)
  239.         {
  240.             int len = length;
  241.             if (len < 2) {
  242.                 return false;
  243.             }
  244.            
  245.             bool fSeenLetter = false;
  246.             int i = startPos;
  247.             XmlCharType xmlCharType = XmlCharType.Instance;
  248.            
  249.             char ch = value[i];
  250.             if (xmlCharType.IsLetter(ch)) {
  251.                 if (xmlCharType.IsLetter(value[++i])) {
  252.                     if (len == 2) {
  253.                         return true;
  254.                     }
  255.                     len--;
  256.                     i++;
  257.                 }
  258.                 else if (('I' != ch && 'i' != ch) && ('X' != ch && 'x' != ch)) {
  259.                     //IANA or custom Code
  260.                     return false;
  261.                 }
  262.                
  263.                 if (value[i] != '-') {
  264.                     return false;
  265.                 }
  266.                
  267.                 len -= 2;
  268.                 while (len-- > 0) {
  269.                     ch = value[++i];
  270.                     if (xmlCharType.IsLetter(ch)) {
  271.                         fSeenLetter = true;
  272.                     }
  273.                     else if (ch == '-' && fSeenLetter) {
  274.                         fSeenLetter = false;
  275.                     }
  276.                     else {
  277.                         return false;
  278.                     }
  279.                 }
  280.                 if (fSeenLetter) {
  281.                     return true;
  282.                 }
  283.             }
  284.             return false;
  285.         }
  286.     }
  287. }

Developer Fusion