Code:
/ FXUpdate3074 / FXUpdate3074 / 1.1 / DEVDIV / depot / DevDiv / releases / whidbey / QFE / ndp / fx / src / xsp / System / Web / Util / Wildcard.cs / 1 / Wildcard.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
* Wildcard
*
* wildcard wrappers for Regex
*
* (1) Wildcard does straight string wildcarding with no path separator awareness
* (2) WildcardUrl recognizes that forward / slashes are special and can't match * or ?
* (3) WildcardDos recognizes that backward \ and : are special and can't match * or ?
*
* Copyright (c) 1999, Microsoft Corporation
*/
namespace System.Web.Util {
using System.Runtime.Serialization.Formatters;
using System.Text.RegularExpressions;
/*
* Wildcard
*
* Wildcard patterns have three metacharacters:
*
* A ? is equivalent to .
* A * is equivalent to .*
* A , is equivalent to |
*
* Note that by each alternative is surrounded by \A...\z to anchor
* at the edges of the string.
*/
internal class Wildcard {
#if NOT_USED
internal /*public*/ Wildcard(String pattern) : this (pattern, false) {
}
#endif
internal /*public*/ Wildcard(String pattern, bool caseInsensitive) {
_pattern = pattern;
_caseInsensitive = caseInsensitive;
}
internal String _pattern;
internal bool _caseInsensitive;
internal Regex _regex;
protected static Regex metaRegex = new Regex("[\\+\\{\\\\\\[\\|\\(\\)\\.\\^\\$]");
protected static Regex questRegex = new Regex("\\?");
protected static Regex starRegex = new Regex("\\*");
protected static Regex commaRegex = new Regex(",");
protected static Regex slashRegex = new Regex("(?=/)");
protected static Regex backslashRegex = new Regex("(?=[\\\\:])");
/*
* IsMatch returns true if the input is an exact match for the
* wildcard pattern.
*/
internal /*public*/ bool IsMatch(String input) {
EnsureRegex();
bool result = _regex.IsMatch(input);
return result;
}
#if DONT_COMPILE
internal /*public*/ String Pattern {
get {
return _pattern;
}
}
#endif
/*
* Builds the matching regex when needed
*/
protected void EnsureRegex() {
// threadsafe without protection because of gc
if (_regex != null)
return;
_regex = RegexFromWildcard(_pattern, _caseInsensitive);
}
/*
* Basic wildcard -> Regex conversion, no slashes
*/
protected virtual Regex RegexFromWildcard(String pattern, bool caseInsensitive) {
RegexOptions options = RegexOptions.None;
// match right-to-left (for speed) if the pattern starts with a *
if (pattern.Length > 0 && pattern[0] == '*')
options = RegexOptions.RightToLeft | RegexOptions.Singleline;
else
options = RegexOptions.Singleline;
// case insensitivity
if (caseInsensitive)
options |= RegexOptions.IgnoreCase | RegexOptions.CultureInvariant;
// Remove regex metacharacters
pattern = metaRegex.Replace(pattern, "\\$0");
// Replace wildcard metacharacters with regex codes
pattern = questRegex.Replace(pattern, ".");
pattern = starRegex.Replace(pattern, ".*");
pattern = commaRegex.Replace(pattern, "\\z|\\A");
// anchor the pattern at beginning and end, and return the regex
return new Regex("\\A" + pattern + "\\z", options);
}
}
abstract internal class WildcardPath : Wildcard {
#if NOT_USED
internal /*public*/ WildcardPath(String pattern) : base(pattern) {
}
private Regex[][] _dirs;
#endif
internal /*public*/ WildcardPath(String pattern, bool caseInsensitive) : base(pattern, caseInsensitive) {
}
private Regex _suffix;
/*
* IsSuffix returns true if a suffix of the input is an exact
* match for the wildcard pattern.
*/
internal /*public*/ bool IsSuffix(String input) {
EnsureSuffix();
return _suffix.IsMatch(input);
}
#if NOT_USED
/*
* AllowPrefix returns true if the input is an exact match for
* a prefix-directory of the wildcard pattern (i.e., if it
* is possible to match the wildcard pattern by adding
* more subdirectories or a filename at the end of the path).
*/
internal /*public*/ bool AllowPrefix(String prefix) {
String[] dirs = SplitDirs(prefix);
EnsureDirs();
for (int i = 0; i < _dirs.Length; i++) {
// pattern is shorter than prefix: reject
if (_dirs[i].Length < dirs.Length)
goto NextAlt;
for (int j = 0; j < dirs.Length; j++) {
// the jth directory doesn't match; path is not a prefix
if (!_dirs[i][j].IsMatch(dirs[j]))
goto NextAlt;
}
// one alternative passed: we pass.
return true;
NextAlt:
;
}
return false;
}
/*
* Builds the matching regex array when needed
*/
protected void EnsureDirs() {
// threadsafe without protection because of gc
if (_dirs != null)
return;
_dirs = DirsFromWildcard(_pattern);
}
#endif
/*
* Builds the matching regex when needed
*/
protected void EnsureSuffix() {
// threadsafe without protection because of gc
if (_suffix != null)
return;
_suffix = SuffixFromWildcard(_pattern, _caseInsensitive);
}
/*
* Specialize for forward-slash and backward-slash cases
*/
protected abstract Regex SuffixFromWildcard(String pattern, bool caseInsensitive);
protected abstract Regex[][] DirsFromWildcard(String pattern);
protected abstract String[] SplitDirs(String input);
}
/*
* WildcardUrl
*
* The twist is that * and ? cannot match forward slashes,
* and we can do an exact suffix match that starts after
* any /, and we can also do a prefix prune.
*/
internal class WildcardUrl : WildcardPath {
#if NOT_USED
internal /*public*/ WildcardUrl(String pattern) : base(pattern) {
}
#endif
internal /*public*/ WildcardUrl(String pattern, bool caseInsensitive) : base(pattern, caseInsensitive) {
}
protected override String[] SplitDirs(String input) {
return slashRegex.Split(input);
}
protected override Regex RegexFromWildcard(String pattern, bool caseInsensitive) {
RegexOptions options;
// match right-to-left (for speed) if the pattern starts with a *
if (pattern.Length > 0 && pattern[0] == '*')
options = RegexOptions.RightToLeft;
else
options = RegexOptions.None;
// case insensitivity
if (caseInsensitive)
options |= RegexOptions.IgnoreCase | RegexOptions.CultureInvariant;
// Remove regex metacharacters
pattern = metaRegex.Replace(pattern, "\\$0");
// Replace wildcard metacharacters with regex codes
pattern = questRegex.Replace(pattern, "[^/]");
pattern = starRegex.Replace(pattern, "[^/]*");
pattern = commaRegex.Replace(pattern, "\\z|\\A");
// anchor the pattern at beginning and end, and return the regex
return new Regex("\\A" + pattern + "\\z", options);
}
protected override Regex SuffixFromWildcard(String pattern, bool caseInsensitive) {
RegexOptions options;
// match right-to-left (for speed)
options = RegexOptions.RightToLeft;
// case insensitivity
if (caseInsensitive)
options |= RegexOptions.IgnoreCase | RegexOptions.CultureInvariant;
// Remove regex metacharacters
pattern = metaRegex.Replace(pattern, "\\$0");
// Replace wildcard metacharacters with regex codes
pattern = questRegex.Replace(pattern, "[^/]");
pattern = starRegex.Replace(pattern, "[^/]*");
pattern = commaRegex.Replace(pattern, "\\z|(?:\\A|(?<=/))");
// anchor the pattern at beginning and end, and return the regex
return new Regex("(?:\\A|(?<=/))" + pattern + "\\z", options);
}
protected override Regex[][] DirsFromWildcard(String pattern) {
String[] alts = commaRegex.Split(pattern);
Regex[][] dirs = new Regex[alts.Length][];
for (int i = 0; i < alts.Length; i++) {
String[] dirpats = slashRegex.Split(alts[i]);
Regex[] dirregex = new Regex[dirpats.Length];
if (alts.Length == 1 && dirpats.Length == 1) {
// common case: no commas, no slashes: dir regex is same as top regex.
EnsureRegex();
dirregex[0] = _regex;
}
else {
for (int j = 0; j < dirpats.Length; j++) {
dirregex[j] = RegexFromWildcard(dirpats[j], _caseInsensitive);
}
}
dirs[i] = dirregex;
}
return dirs;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
* Wildcard
*
* wildcard wrappers for Regex
*
* (1) Wildcard does straight string wildcarding with no path separator awareness
* (2) WildcardUrl recognizes that forward / slashes are special and can't match * or ?
* (3) WildcardDos recognizes that backward \ and : are special and can't match * or ?
*
* Copyright (c) 1999, Microsoft Corporation
*/
namespace System.Web.Util {
using System.Runtime.Serialization.Formatters;
using System.Text.RegularExpressions;
/*
* Wildcard
*
* Wildcard patterns have three metacharacters:
*
* A ? is equivalent to .
* A * is equivalent to .*
* A , is equivalent to |
*
* Note that by each alternative is surrounded by \A...\z to anchor
* at the edges of the string.
*/
internal class Wildcard {
#if NOT_USED
internal /*public*/ Wildcard(String pattern) : this (pattern, false) {
}
#endif
internal /*public*/ Wildcard(String pattern, bool caseInsensitive) {
_pattern = pattern;
_caseInsensitive = caseInsensitive;
}
internal String _pattern;
internal bool _caseInsensitive;
internal Regex _regex;
protected static Regex metaRegex = new Regex("[\\+\\{\\\\\\[\\|\\(\\)\\.\\^\\$]");
protected static Regex questRegex = new Regex("\\?");
protected static Regex starRegex = new Regex("\\*");
protected static Regex commaRegex = new Regex(",");
protected static Regex slashRegex = new Regex("(?=/)");
protected static Regex backslashRegex = new Regex("(?=[\\\\:])");
/*
* IsMatch returns true if the input is an exact match for the
* wildcard pattern.
*/
internal /*public*/ bool IsMatch(String input) {
EnsureRegex();
bool result = _regex.IsMatch(input);
return result;
}
#if DONT_COMPILE
internal /*public*/ String Pattern {
get {
return _pattern;
}
}
#endif
/*
* Builds the matching regex when needed
*/
protected void EnsureRegex() {
// threadsafe without protection because of gc
if (_regex != null)
return;
_regex = RegexFromWildcard(_pattern, _caseInsensitive);
}
/*
* Basic wildcard -> Regex conversion, no slashes
*/
protected virtual Regex RegexFromWildcard(String pattern, bool caseInsensitive) {
RegexOptions options = RegexOptions.None;
// match right-to-left (for speed) if the pattern starts with a *
if (pattern.Length > 0 && pattern[0] == '*')
options = RegexOptions.RightToLeft | RegexOptions.Singleline;
else
options = RegexOptions.Singleline;
// case insensitivity
if (caseInsensitive)
options |= RegexOptions.IgnoreCase | RegexOptions.CultureInvariant;
// Remove regex metacharacters
pattern = metaRegex.Replace(pattern, "\\$0");
// Replace wildcard metacharacters with regex codes
pattern = questRegex.Replace(pattern, ".");
pattern = starRegex.Replace(pattern, ".*");
pattern = commaRegex.Replace(pattern, "\\z|\\A");
// anchor the pattern at beginning and end, and return the regex
return new Regex("\\A" + pattern + "\\z", options);
}
}
abstract internal class WildcardPath : Wildcard {
#if NOT_USED
internal /*public*/ WildcardPath(String pattern) : base(pattern) {
}
private Regex[][] _dirs;
#endif
internal /*public*/ WildcardPath(String pattern, bool caseInsensitive) : base(pattern, caseInsensitive) {
}
private Regex _suffix;
/*
* IsSuffix returns true if a suffix of the input is an exact
* match for the wildcard pattern.
*/
internal /*public*/ bool IsSuffix(String input) {
EnsureSuffix();
return _suffix.IsMatch(input);
}
#if NOT_USED
/*
* AllowPrefix returns true if the input is an exact match for
* a prefix-directory of the wildcard pattern (i.e., if it
* is possible to match the wildcard pattern by adding
* more subdirectories or a filename at the end of the path).
*/
internal /*public*/ bool AllowPrefix(String prefix) {
String[] dirs = SplitDirs(prefix);
EnsureDirs();
for (int i = 0; i < _dirs.Length; i++) {
// pattern is shorter than prefix: reject
if (_dirs[i].Length < dirs.Length)
goto NextAlt;
for (int j = 0; j < dirs.Length; j++) {
// the jth directory doesn't match; path is not a prefix
if (!_dirs[i][j].IsMatch(dirs[j]))
goto NextAlt;
}
// one alternative passed: we pass.
return true;
NextAlt:
;
}
return false;
}
/*
* Builds the matching regex array when needed
*/
protected void EnsureDirs() {
// threadsafe without protection because of gc
if (_dirs != null)
return;
_dirs = DirsFromWildcard(_pattern);
}
#endif
/*
* Builds the matching regex when needed
*/
protected void EnsureSuffix() {
// threadsafe without protection because of gc
if (_suffix != null)
return;
_suffix = SuffixFromWildcard(_pattern, _caseInsensitive);
}
/*
* Specialize for forward-slash and backward-slash cases
*/
protected abstract Regex SuffixFromWildcard(String pattern, bool caseInsensitive);
protected abstract Regex[][] DirsFromWildcard(String pattern);
protected abstract String[] SplitDirs(String input);
}
/*
* WildcardUrl
*
* The twist is that * and ? cannot match forward slashes,
* and we can do an exact suffix match that starts after
* any /, and we can also do a prefix prune.
*/
internal class WildcardUrl : WildcardPath {
#if NOT_USED
internal /*public*/ WildcardUrl(String pattern) : base(pattern) {
}
#endif
internal /*public*/ WildcardUrl(String pattern, bool caseInsensitive) : base(pattern, caseInsensitive) {
}
protected override String[] SplitDirs(String input) {
return slashRegex.Split(input);
}
protected override Regex RegexFromWildcard(String pattern, bool caseInsensitive) {
RegexOptions options;
// match right-to-left (for speed) if the pattern starts with a *
if (pattern.Length > 0 && pattern[0] == '*')
options = RegexOptions.RightToLeft;
else
options = RegexOptions.None;
// case insensitivity
if (caseInsensitive)
options |= RegexOptions.IgnoreCase | RegexOptions.CultureInvariant;
// Remove regex metacharacters
pattern = metaRegex.Replace(pattern, "\\$0");
// Replace wildcard metacharacters with regex codes
pattern = questRegex.Replace(pattern, "[^/]");
pattern = starRegex.Replace(pattern, "[^/]*");
pattern = commaRegex.Replace(pattern, "\\z|\\A");
// anchor the pattern at beginning and end, and return the regex
return new Regex("\\A" + pattern + "\\z", options);
}
protected override Regex SuffixFromWildcard(String pattern, bool caseInsensitive) {
RegexOptions options;
// match right-to-left (for speed)
options = RegexOptions.RightToLeft;
// case insensitivity
if (caseInsensitive)
options |= RegexOptions.IgnoreCase | RegexOptions.CultureInvariant;
// Remove regex metacharacters
pattern = metaRegex.Replace(pattern, "\\$0");
// Replace wildcard metacharacters with regex codes
pattern = questRegex.Replace(pattern, "[^/]");
pattern = starRegex.Replace(pattern, "[^/]*");
pattern = commaRegex.Replace(pattern, "\\z|(?:\\A|(?<=/))");
// anchor the pattern at beginning and end, and return the regex
return new Regex("(?:\\A|(?<=/))" + pattern + "\\z", options);
}
protected override Regex[][] DirsFromWildcard(String pattern) {
String[] alts = commaRegex.Split(pattern);
Regex[][] dirs = new Regex[alts.Length][];
for (int i = 0; i < alts.Length; i++) {
String[] dirpats = slashRegex.Split(alts[i]);
Regex[] dirregex = new Regex[dirpats.Length];
if (alts.Length == 1 && dirpats.Length == 1) {
// common case: no commas, no slashes: dir regex is same as top regex.
EnsureRegex();
dirregex[0] = _regex;
}
else {
for (int j = 0; j < dirpats.Length; j++) {
dirregex[j] = RegexFromWildcard(dirpats[j], _caseInsensitive);
}
}
dirs[i] = dirregex;
}
return dirs;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- DoubleAnimation.cs
- ScrollItemProviderWrapper.cs
- SignatureHelper.cs
- ToolboxComponentsCreatedEventArgs.cs
- ExtractorMetadata.cs
- ButtonBase.cs
- SigningCredentials.cs
- DesignTimeSiteMapProvider.cs
- DataGridAddNewRow.cs
- updatecommandorderer.cs
- TypeHelper.cs
- IntSecurity.cs
- _AutoWebProxyScriptEngine.cs
- ParserExtension.cs
- LayoutInformation.cs
- Converter.cs
- PlatformNotSupportedException.cs
- CircleEase.cs
- VerificationException.cs
- TransformerInfo.cs
- MetaColumn.cs
- ConfigXmlDocument.cs
- MatrixCamera.cs
- RequestResizeEvent.cs
- FormatControl.cs
- ListDictionary.cs
- GridViewUpdateEventArgs.cs
- TimersDescriptionAttribute.cs
- Debug.cs
- KeysConverter.cs
- TrustLevel.cs
- XmlDictionary.cs
- RequestSecurityTokenResponse.cs
- SemaphoreFullException.cs
- HttpProfileGroupBase.cs
- LocatorGroup.cs
- BindingCompleteEventArgs.cs
- XmlTypeMapping.cs
- DataBindingExpressionBuilder.cs
- Literal.cs
- FacetChecker.cs
- Image.cs
- EventLogPermissionAttribute.cs
- WebPartEventArgs.cs
- CompareInfo.cs
- CompositeScriptReference.cs
- WindowsFormsHelpers.cs
- TriggerActionCollection.cs
- PrintingPermissionAttribute.cs
- DynamicMethod.cs
- CompareValidator.cs
- WebBrowser.cs
- ComponentResourceKeyConverter.cs
- HMACSHA256.cs
- AssociationSetEnd.cs
- BamlRecords.cs
- TemplateParser.cs
- Tuple.cs
- AffineTransform3D.cs
- StateValidator.cs
- QueryAccessibilityHelpEvent.cs
- DataShape.cs
- SqlErrorCollection.cs
- FontSourceCollection.cs
- Span.cs
- EtwProvider.cs
- FolderNameEditor.cs
- TextPenaltyModule.cs
- DocumentPage.cs
- Geometry3D.cs
- WebPartHelpVerb.cs
- Pool.cs
- Int32RectValueSerializer.cs
- XmlTextEncoder.cs
- DelegatedStream.cs
- SynchronizedInputProviderWrapper.cs
- MenuAdapter.cs
- DataControlReferenceCollection.cs
- SapiRecognizer.cs
- ZipIOExtraField.cs
- _ListenerAsyncResult.cs
- BackStopAuthenticationModule.cs
- DragDrop.cs
- ViewUtilities.cs
- XmlSchemaSet.cs
- WebControl.cs
- InputLanguageCollection.cs
- ObjectTypeMapping.cs
- DataObject.cs
- AsyncPostBackTrigger.cs
- SpStreamWrapper.cs
- GenericPrincipal.cs
- ObjectDataSourceFilteringEventArgs.cs
- FileDialog_Vista_Interop.cs
- CollectionType.cs
- BindingManagerDataErrorEventArgs.cs
- Storyboard.cs
- AddInContractAttribute.cs
- StructuralType.cs
- IncrementalCompileAnalyzer.cs