The Labs \ Source Viewer \ SSCLI \ System.Net \ ShellExpression

  1. //------------------------------------------------------------------------------
  2. // <copyright file="_ShellExpression.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. namespace System.Net
  16. {
  17.     using System;
  18.    
  19.     internal struct ShellExpression
  20.     {
  21.         private enum ShExpTokens
  22.         {
  23.             Asterisk = -1,
  24.             Question = -2,
  25.             AugmentedDot = -3,
  26.             AugmentedAsterisk = -4,
  27.             AugmentedQuestion = -5,
  28.             Start = -6,
  29.             End = -7
  30.         }
  31.        
  32.         private ShExpTokens[] pattern;
  33.         private int[] match;
  34.        
  35.         // Normally would defer parsing, but we want to throw here if it's invalid.
  36.         internal ShellExpression(string pattern)
  37.         {
  38.             this.pattern = null;
  39.             this.match = null;
  40.             GlobalLog.Print("ShellServices.ShellExpression#" + ValidationHelper.HashString(this) + "::.ctor() pattern:" + ValidationHelper.ToString(pattern));
  41.             Parse(pattern);
  42.         }
  43.        
  44. /*
  45.         //                                   
  46.         internal void SetPattern(string pattern)
  47.         {
  48.             GlobalLog.Print("ShellServices.ShellExpression#" + ValidationHelper.HashString(this) + "::SetPattern() pattern:" + ValidationHelper.ToString(pattern));
  49.             Parse(pattern);
  50.         }
  51.         */       
  52.        
  53.         internal bool IsMatch(string target)
  54.         {
  55.             GlobalLog.Print("ShellServices.ShellExpression#" + ValidationHelper.HashString(this) + "::IsMatch() target:" + ValidationHelper.ToString(target));
  56.             int i = 0;
  57.             int j = 0;
  58.             bool reverse = false;
  59.             bool matched = false;
  60.            
  61.             while (true) {
  62.                 if (!reverse) {
  63.                     if (j > target.Length) {
  64.                         break;
  65.                     }
  66.                    
  67.                     switch (pattern[i]) {
  68.                         case ShExpTokens.Asterisk:
  69.                             match[i++] = j = target.Length;
  70.                             continue;
  71.                         case ShExpTokens.Question:
  72.                            
  73.                             if (j == target.Length) {
  74.                                 reverse = true;
  75.                             }
  76.                             else {
  77.                                 match[i++] = ++j;
  78.                             }
  79.                             continue;
  80.                         case ShExpTokens.AugmentedDot:
  81.                            
  82.                             if (j == target.Length) {
  83.                                 match[i++] = j;
  84.                             }
  85.                             else if (target[j] == '.') {
  86.                                 match[i++] = ++j;
  87.                             }
  88.                             else {
  89.                                 reverse = true;
  90.                             }
  91.                             continue;
  92.                         case ShExpTokens.AugmentedAsterisk:
  93.                            
  94.                             if (j == target.Length || target[j] == '.') {
  95.                                 reverse = true;
  96.                             }
  97.                             else {
  98.                                 match[i++] = ++j;
  99.                             }
  100.                             continue;
  101.                         case ShExpTokens.AugmentedQuestion:
  102.                            
  103.                             if (j == target.Length || target[j] == '.') {
  104.                                 match[i++] = j;
  105.                             }
  106.                             else {
  107.                                 match[i++] = ++j;
  108.                             }
  109.                             continue;
  110.                         case ShExpTokens.Start:
  111.                            
  112.                             if (j != 0) {
  113.                                 break;
  114.                             }
  115.                             match[i++] = 0;
  116.                             continue;
  117.                         case ShExpTokens.End:
  118.                            
  119.                             if (j == target.Length) {
  120.                                 matched = true;
  121.                                 break;
  122.                             }
  123.                             reverse = true;
  124.                             continue;
  125.                         default:
  126.                            
  127.                             if (j < target.Length && (int)pattern[i] == (int)char.ToLowerInvariant(target[j])) {
  128.                                 match[i++] = ++j;
  129.                             }
  130.                             else {
  131.                                 reverse = true;
  132.                             }
  133.                             continue;
  134.                     }
  135.                 }
  136.                 else {
  137.                     switch (pattern[--i]) {
  138.                         case ShExpTokens.Asterisk:
  139.                         case ShExpTokens.AugmentedQuestion:
  140.                             if (match[i] != match[i - 1]) {
  141.                                 j = --match[i++];
  142.                                 reverse = false;
  143.                             }
  144.                             continue;
  145.                         case ShExpTokens.Start:
  146.                         case ShExpTokens.End:
  147.                            
  148.                             break;
  149.                         case ShExpTokens.Question:
  150.                         case ShExpTokens.AugmentedDot:
  151.                         case ShExpTokens.AugmentedAsterisk:
  152.                         default:
  153.                            
  154.                             continue;
  155.                     }
  156.                 }
  157.                 break;
  158.             }
  159.            
  160.             GlobalLog.Print("ShellServices.ShellExpression#" + ValidationHelper.HashString(this) + "::IsMatch() return:" + matched.ToString());
  161.             return matched;
  162.         }
  163.        
  164.         private void Parse(string patString)
  165.         {
  166.             pattern = new ShExpTokens[patString.Length + 2];
  167.             // 2 for the start, end
  168.             match = null;
  169.             int i = 0;
  170.            
  171.             pattern[i++] = ShExpTokens.Start;
  172.             for (int j = 0; j < patString.Length; j++) {
  173.                 switch (patString[j]) {
  174.                     case '?':
  175.                         pattern[i++] = ShExpTokens.Question;
  176.                         break;
  177.                     case '*':
  178.                        
  179.                         pattern[i++] = ShExpTokens.Asterisk;
  180.                         break;
  181.                     case '^':
  182.                        
  183.                         if (j < patString.Length - 1) {
  184.                             j++;
  185.                         }
  186.                         else {
  187.                             pattern = null;
  188.                             if (Logging.On)
  189.                                 Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_shell_expression_pattern_format_warning, patString));
  190.                             throw new FormatException(SR.GetString(SR.net_format_shexp, patString));
  191.                         }
  192.                         switch (patString[j]) {
  193.                             case '.':
  194.                                 pattern[i++] = ShExpTokens.AugmentedDot;
  195.                                 break;
  196.                             case '?':
  197.                                
  198.                                 pattern[i++] = ShExpTokens.AugmentedQuestion;
  199.                                 break;
  200.                             case '*':
  201.                                
  202.                                 pattern[i++] = ShExpTokens.AugmentedAsterisk;
  203.                                 break;
  204.                             default:
  205.                                
  206.                                 pattern = null;
  207.                                 if (Logging.On)
  208.                                     Logging.PrintWarning(Logging.Web, SR.GetString(SR.net_log_shell_expression_pattern_format_warning, patString));
  209.                                 throw new FormatException(SR.GetString(SR.net_format_shexp, patString));
  210.                                 break;
  211.                         }
  212.                         break;
  213.                     default:
  214.                        
  215.                         pattern[i++] = (ShExpTokens)(int)char.ToLowerInvariant(patString[j]);
  216.                         break;
  217.                 }
  218.             }
  219.            
  220.             pattern[i++] = ShExpTokens.End;
  221.             match = new int[i];
  222.         }
  223.     }
  224. }

Developer Fusion