Imported Upstream version 4.0.0~alpha1

Former-commit-id: 806294f5ded97629b74c85c09952f2a74fe182d9

external/referencesource/System.Web/Configuration/CapabilitiesPattern.cs

@@ -0,0 +1,165 @@
+//------------------------------------------------------------------------------
+// <copyright file="CapabilitiesPattern.cs" company="Microsoft">
+//     Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//------------------------------------------------------------------------------
+
+namespace System.Web.Configuration {
+    
+    using System.Collections;
+    using System.Collections.Specialized;
+    using System.Diagnostics;
+    using System.Globalization;
+    using System.Reflection;
+    using System.Security;
+    using System.Text;
+    using System.Text.RegularExpressions;
+    using System.Threading;
+    using System.Web.Caching;
+    using System.Web.Compilation;
+    using System.Web.Hosting;
+    using System.Security.Permissions;
+
+    //
+    // Represents a single pattern to be expanded
+    //
+    internal class CapabilitiesPattern {
+        internal String[]    _strings;
+        internal int[]       _rules;
+
+        internal const int Literal    = 0;    // literal string
+        internal const int Reference  = 1;    // regex reference ${name} or $number
+        internal const int Variable   = 2;    // regex reference %{name}
+
+        internal static readonly Regex refPat = new Regex("\\G\\$(?:(?<name>\\d+)|\\{(?<name>\\w+)\\})");
+        internal static readonly Regex varPat = new Regex("\\G\\%\\{(?<name>\\w+)\\}");
+        internal static readonly Regex textPat = new Regex("\\G[^$%\\\\]*(?:\\.[^$%\\\\]*)*");
+        internal static readonly Regex errorPat = new Regex(".{0,8}");
+
+        internal static readonly CapabilitiesPattern Default = new CapabilitiesPattern();
+
+        internal CapabilitiesPattern() {
+            _strings = new String[1];
+            _strings[0] = String.Empty;
+            _rules = new int[1];
+            _rules[0] = Variable;
+        }
+
+        internal CapabilitiesPattern(String text) {
+            ArrayList strings = new ArrayList();
+            ArrayList rules = new ArrayList();
+
+            int textpos = 0;
+
+            for (;;) {
+                Match match = null;
+
+                // 1: scan text
+
+                if ((match = textPat.Match(text, textpos)).Success && match.Length > 0) {
+                    rules.Add(Literal);
+                    strings.Add(Regex.Unescape(match.ToString()));
+                    textpos = match.Index + match.Length;
+                }
+
+                if (textpos == text.Length)
+                    break;
+
+                // 2: look for regex references
+
+                if ((match = refPat.Match(text, textpos)).Success) {
+                    rules.Add(Reference);
+                    strings.Add(match.Groups["name"].Value);
+                }
+
+                // 3: look for variables
+
+                else if ((match = varPat.Match(text, textpos)).Success) {
+                    rules.Add(Variable);
+                    strings.Add(match.Groups["name"].Value);
+                }
+
+                // 4: encountered a syntax error (
+
+                else {
+                    match = errorPat.Match(text, textpos);
+
+                    throw new ArgumentException(
+                                               SR.GetString(SR.Unrecognized_construct_in_pattern, match.ToString(), text));
+                }
+
+                textpos = match.Index + match.Length;
+            }
+
+            _strings = (String[])strings.ToArray(typeof(String));
+
+            _rules = new int[rules.Count];
+            for (int i = 0; i < rules.Count; i++)
+                _rules[i] = (int)rules[i];
+        }
+
+        internal virtual String Expand(CapabilitiesState matchstate) {
+            StringBuilder sb = null;
+            String result = null;
+
+            for (int i = 0; i < _rules.Length; i++) {
+                if (sb == null && result != null)
+                    sb = new StringBuilder(result);
+
+                switch (_rules[i]) {
+                    case Literal:
+                        result = _strings[i];
+                        break;
+
+                    case Reference:
+                        result = matchstate.ResolveReference(_strings[i]);
+                        break;
+
+                    case Variable:
+                        result = matchstate.ResolveVariable(_strings[i]);
+                        break;
+                }
+
+                if (sb != null && result != null)
+                    sb.Append(result);
+            }
+
+            if (sb != null)
+                return sb.ToString();
+
+            if (result != null)
+                return result;
+
+            return String.Empty;
+        }
+
+#if DBG
+        internal virtual String Dump() {
+            StringBuilder sb = new StringBuilder();
+
+            for (int i = 0; i < _rules.Length; i++) {
+                switch (_rules[i]) {
+                    case Literal:
+                        sb.Append("\"" + _strings[i] + "\"");
+                        break;
+                    case Reference:
+                        sb.Append("${" + _strings[i] + "}");
+                        break;
+                    default:
+                        sb.Append("??");
+                        break;
+                }
+
+                if (i < _rules.Length - 1)
+                    sb.Append(" ");
+            }
+
+            return sb.ToString();
+        }
+
+        internal virtual String Dump(String indent) {
+            return indent + Dump() + "\n";
+        }
+#endif
+    }
+}