mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
314 lines
9.7 KiB
C#
314 lines
9.7 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="Wildcard.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
/*
|
|
* 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;
|
|
}
|
|
}
|
|
}
|