GroupNumberFromName() public method

public GroupNumberFromName ( string name ) : int
name string
return int
 internal RegExpMatch(ArrayPrototype parent, Regex regex, Match match, string input) : base(parent, typeof(RegExpMatch))
 {
     this.hydrated = false;
     this.regex = regex;
     this.matches = null;
     this.match = match;
     base.SetMemberValue("input", input);
     base.SetMemberValue("index", match.Index);
     base.SetMemberValue("lastIndex", (match.Length == 0) ? (match.Index + 1) : (match.Index + match.Length));
     string[] groupNames = regex.GetGroupNames();
     int num = 0;
     for (int i = 1; i < groupNames.Length; i++)
     {
         string name = groupNames[i];
         int num3 = regex.GroupNumberFromName(name);
         if (name.Equals(num3.ToString(CultureInfo.InvariantCulture)))
         {
             if (num3 > num)
             {
                 num = num3;
             }
         }
         else
         {
             Group group = match.Groups[name];
             base.SetMemberValue(name, group.Success ? group.ToString() : null);
         }
     }
     this.length = num + 1;
 }
Ejemplo n.º 2
0
        public Parser () {
            _Regex = new Regex(
                @"((?'number'(-?)[0-9]+(\.[0-9]+)?)|(?'identifier'[_A-Za-z][A-Za-z0-9_]*)|(?'operator'<=|>=|!=|[\-+/*&|^!><=.%?:@])|(?'paren'[(){}]))|(?'comma',)",
                RegexOptions.IgnorePatternWhitespace | RegexOptions.ExplicitCapture
            );

            _Group_Number = _Regex.GroupNumberFromName("number");
            _Group_Identifier = _Regex.GroupNumberFromName("identifier");
            _Group_Operator = _Regex.GroupNumberFromName("operator");
            _Group_Paren = _Regex.GroupNumberFromName("paren");
            _Group_Comma = _Regex.GroupNumberFromName("comma");
        }
 internal ReplaceUsingFunction(Regex regex, ScriptFunction function, string source)
 {
     this.function = function;
     this.cArgs = function.GetNumberOfFormalParameters();
     bool flag = (function is Closure) && ((Closure) function).func.hasArgumentsObject;
     this.groupNumbers = null;
     this.source = source;
     if ((this.cArgs > 1) || flag)
     {
         string[] groupNames = regex.GetGroupNames();
         int num = groupNames.Length - 1;
         if (flag)
         {
             this.cArgs = num + 3;
         }
         if (num > 0)
         {
             if (num > (this.cArgs - 1))
             {
                 num = this.cArgs - 1;
             }
             this.groupNumbers = new int[num];
             for (int i = 0; i < num; i++)
             {
                 this.groupNumbers[i] = regex.GroupNumberFromName(groupNames[i + 1]);
             }
         }
     }
 }
Ejemplo n.º 4
0
        /// <summary>
        /// This method parses a friendly Derived Columns expression entered by the user into a Lineage-ID based
        /// expression which is required by SSIS, using a regular-expression based parser.
        /// Additionally, it will set the Input Column Usage for any columns found in the expression.
        /// </summary>
        /// <param name="expression">Expression to be parsed.</param>
        /// <param name="transformation">Transformation to use for evaluating the lineage IDs</param>
        /// <param name="vi">Transformation Virtual Input used to search for input columns.</param>
        /// <param name="inputColumnUsageType">DTSUsageType for columns mapped in this expression.</param>
        /// <returns>Expression struct with the pre-processed and post-processed expression.</returns>
        public static Expression ExpressionCleanerAndInputMapBuilder(string expression, Transformation transformation, IDTSVirtualInput100 vi, DTSUsageType inputColumnUsageType)
        {
            Expression exp = new Expression();
            exp.OriginalExpression = expression;
            exp.ProcessedExpression = expression;
            exp.FriendlyExpression = expression;
            exp.ContainsId = false;

            foreach (IDTSVirtualInputColumn100 vcol in vi.VirtualInputColumnCollection)
            {
                string regexString = String.Format(CultureInfo.CurrentCulture, "(\"(?:[^\"]|(?<=\\\\)\")*\")|(?<vCol>(?<!@\\[?|:)\\[?\\b{0}\\b\\]?)", Regex.Escape(vcol.Name));
                var regex = new Regex(regexString, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
                int groupNumber = regex.GroupNumberFromName("vCol");

                var processedEme = new ExpressionMatchEvaluatorStruct(groupNumber, "#" + vcol.LineageID, transformation, vi, inputColumnUsageType, vcol);
                var friendlyEme = new ExpressionMatchEvaluatorStruct(groupNumber, vcol.Name, null, null, DTSUsageType.UT_IGNORED, null);

                exp.ProcessedExpression = regex.Replace(exp.ProcessedExpression, new MatchEvaluator(processedEme.EvaluateMatch));
                exp.FriendlyExpression = regex.Replace(exp.FriendlyExpression, new MatchEvaluator(friendlyEme.EvaluateMatch));
            }

            if (exp.ProcessedExpression != exp.OriginalExpression)
            {
                exp.ContainsId = true;
            }

            return exp;
        }
Ejemplo n.º 5
0
        public void NameLookupMatch()
        {
            Regex regTime = new Regex(
                    @"(?<hour>[0-9]{1,2})([\:](?<minute>[0-9]{1,2})){0,1}([\:](?<second>[0-9]{1,2})){0,1}\s*(?<ampm>(?i:(am|pm)){0,1})");

            Match mTime = regTime.Match("12:00 pm");

            Assert.AreEqual(4, regTime.GroupNumberFromName("hour"), "#A1");
            Assert.AreEqual(5, regTime.GroupNumberFromName("minute"), "#A1");
            Assert.AreEqual(6, regTime.GroupNumberFromName("second"), "#A1");
            Assert.AreEqual(7, regTime.GroupNumberFromName("ampm"), "#A1");

            Assert.AreEqual("12", mTime.Groups["hour"].Value, "#B1");
            Assert.AreEqual("00", mTime.Groups["minute"].Value, "#B2");
            Assert.AreEqual("", mTime.Groups["second"].Value, "#B3");
            Assert.AreEqual("pm", mTime.Groups["ampm"].Value, "#B4");
        }
Ejemplo n.º 6
0
    static int GroupNumberFromName(IntPtr L)
    {
        LuaScriptMgr.CheckArgsCount(L, 2);
        System.Text.RegularExpressions.Regex obj = (System.Text.RegularExpressions.Regex)LuaScriptMgr.GetNetObjectSelf(L, 1, "System.Text.RegularExpressions.Regex");
        string arg0 = LuaScriptMgr.GetLuaString(L, 2);
        int    o    = obj.GroupNumberFromName(arg0);

        LuaScriptMgr.Push(L, o);
        return(1);
    }
Ejemplo n.º 7
0
 static public int GroupNumberFromName(IntPtr l)
 {
     try {
         System.Text.RegularExpressions.Regex self = (System.Text.RegularExpressions.Regex)checkSelf(l);
         System.String a1;
         checkType(l, 2, out a1);
         var ret = self.GroupNumberFromName(a1);
         pushValue(l, true);
         pushValue(l, ret);
         return(2);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
Ejemplo n.º 8
0
 internal ReplaceUsingFunction(Regex regex, ScriptFunction function, String source) {
   this.function = function;
   this.cArgs = function.GetNumberOfFormalParameters();
   bool hasArgumentsObject = (function is Closure) && ((Closure)function).func.hasArgumentsObject;
   this.groupNumbers = null;
   this.source = source;
   if (this.cArgs > 1 || hasArgumentsObject) {
     String[] groupNames = regex.GetGroupNames();
     int cGroupNumbers = groupNames.Length - 1;
     if (hasArgumentsObject) this.cArgs = cGroupNumbers+3;
     if (cGroupNumbers > 0) {
       if (cGroupNumbers > this.cArgs - 1)
         cGroupNumbers = this.cArgs - 1;
       this.groupNumbers = new int[cGroupNumbers];
       for (int i = 0; i < cGroupNumbers; i++)
         this.groupNumbers[i] = regex.GroupNumberFromName(groupNames[i+1]);
     }
   }
 }
Ejemplo n.º 9
0
		internal static string Reformat (Regex regex, string replacement) {

			replacement = JavaUtils.ReplaceAll (replacement, BACKSLASH_PATTERN, JAVA_BACKSLASH);
			replacement = JavaUtils.ReplaceAll (replacement, DOUBLE_DOLLAR_PATTERN, JAVA_DOLLAR);

			Pattern p = Pattern.compile (SINGLE_DOLLAR_PATTERN);
			Matcher m = p.matcher ((CharSequence) (object) replacement);

			StringBuffer sb = new StringBuffer ();
			while (m.find ()) {
				if (m.start (1) >= 0) {
					int groupNumber = regex.GroupNumberFromName (m.group (1));
					if (groupNumber >= 0) {
						m.appendReplacement (sb, @"\$" + regex.GetJavaNumberByNetNumber (groupNumber));
						continue;
					}
					if (int.TryParse (m.group (1), out groupNumber) && groupNumber <= regex.GroupCount) {
						m.appendReplacement (sb, @"\$" + regex.GetJavaNumberByNetNumber (groupNumber));
						continue;
					}

					m.appendReplacement (sb, JAVA_DOLLAR + "{" + m.group (1) + "}");
					continue;
				}
				if (m.start (2) >= 0) {
					int netGroupNumber = int.Parse (m.group (2));
					if (netGroupNumber > regex.GroupCount) {
						m.appendReplacement (sb, JAVA_DOLLAR + netGroupNumber);
						continue;
					}

					m.appendReplacement (sb, @"\$" + regex.GetJavaNumberByNetNumber (netGroupNumber));
					continue;
				}

				m.appendReplacement (sb, JAVA_DOLLAR);
			}

			m.appendTail (sb);

			return sb.ToString ();
		}
        public static void Run(string path, int field)
        {
            Regex regex = new Regex(@"
                \G(^|,)
                ""
                (?<field> (?> [^""]*) (?> """" [^""]* )* )
                ""
                |
                (?<field> [^"",]* )",
                RegexOptions.Compiled | RegexOptions.ExplicitCapture | RegexOptions.IgnorePatternWhitespace);

            int fieldGroupIndex = regex.GroupNumberFromName("field");

            using (StreamReader csv = new StreamReader(path))
            {
                string s;

                if (field == -1)
                {
                    while ((s = csv.ReadLine()) != null)
                    {
                        MatchCollection m = regex.Matches(s);

                        for (int i = 0; i < m.Count; i += 2)
                            s = m[i].Groups[fieldGroupIndex].Value;
                    }
                }
                else
                {
                    while ((s = csv.ReadLine()) != null)
                    {
                        MatchCollection m = regex.Matches(s);

                        s = m[field << 1].Groups[fieldGroupIndex].Value;
                    }
                }
            }
        }
Ejemplo n.º 11
0
 internal RegExpMatch(ArrayPrototype parent, Regex regex, Match match, String input)
   : base(parent, typeof(RegExpMatch)){
   this.hydrated = false;
   this.regex = regex;
   this.matches = null;
   this.match = match;
   base.SetMemberValue("input", input);
   base.SetMemberValue("index", match.Index);
   base.SetMemberValue("lastIndex", match.Length == 0 ? match.Index + 1 : match.Index + match.Length);
   String[] groupNames = regex.GetGroupNames();
   int maxGroupNumber = 0;
   for (int i = 1; i < groupNames.Length; i++) {
     String groupName = groupNames[i];
     int groupNumber = regex.GroupNumberFromName(groupName);
     if (groupName.Equals(groupNumber.ToString(CultureInfo.InvariantCulture))){
       if (groupNumber > maxGroupNumber)
         maxGroupNumber = groupNumber;
     }else{
       Group group = match.Groups[groupName];
       base.SetMemberValue(groupName, group.Success ? group.ToString() : null);
     }
   }
   this.length = maxGroupNumber+1;
 }
		public static void ReadAll_Regex(DelimitedRecordReaderBenchmarkArguments args)
		{
			// regex from Jeffrey Friedl's Mastering Regular Expressions 2nd edition, p. 271
			// does NOT handle trimming and multiline fields
			Regex regex = new Regex(@"
				\G(^|,)
				""(?<field> (?> [^""]*) (?> """" [^""]* )* )""
				| (?<field> [^"",]* )",
				RegexOptions.Compiled | RegexOptions.ExplicitCapture | RegexOptions.IgnorePatternWhitespace);

			int fieldGroupIndex = regex.GroupNumberFromName("field");

			using (var sr = new StreamReader(args.Path, args.Encoding, true, args.BufferSize))
			{
				string s;

				if (args.FieldIndex < 0)
				{
					while ((s = sr.ReadLine()) != null)
					{
						MatchCollection mc = regex.Matches(s);

						for (int i = 0; i < mc.Count; i += 2)
							s = mc[i].Groups[fieldGroupIndex].Value;
					}
				}
				else
				{
					while ((s = sr.ReadLine()) != null)
					{
						MatchCollection mc = regex.Matches(s);

						for (int i = 0; i < args.FieldIndex + 1; i++)
							s = mc[i * 2].Groups[fieldGroupIndex].Value;
					}
				}
			}
		}
Ejemplo n.º 13
0
		public void Instance_Deny_Unrestricted ()
		{
			Regex r = new Regex (String.Empty);
			Assert.AreEqual (RegexOptions.None, r.Options, "Options");
			Assert.IsFalse (r.RightToLeft, "RightToLeft");

			Assert.AreEqual (1, r.GetGroupNames ().Length, "GetGroupNames");
			Assert.AreEqual (1, r.GetGroupNumbers ().Length, "GetGroupNumbers");
			Assert.AreEqual ("0", r.GroupNameFromNumber (0), "GroupNameFromNumber");
			Assert.AreEqual (0, r.GroupNumberFromName ("0"), "GroupNumberFromName");

			Assert.IsTrue (r.IsMatch (String.Empty), "IsMatch");
			Assert.IsTrue (r.IsMatch (String.Empty, 0), "IsMatch2");

			Assert.IsNotNull (r.Match (String.Empty), "Match");
			Assert.IsNotNull (r.Match (String.Empty, 0), "Match2");
			Assert.IsNotNull (r.Match (String.Empty, 0, 0), "Match3");

			Assert.AreEqual (1, r.Matches (String.Empty).Count, "Matches");
			Assert.AreEqual (1, r.Matches (String.Empty, 0).Count, "Matches2");

			Assert.AreEqual (String.Empty, r.Replace (String.Empty, new MatchEvaluator (Evaluator)), "Replace");
			Assert.AreEqual (String.Empty, r.Replace (String.Empty, new MatchEvaluator (Evaluator), 0), "Replace2");
			Assert.AreEqual (String.Empty, r.Replace (String.Empty, new MatchEvaluator (Evaluator), 0, 0), "Replace3");
			Assert.AreEqual (String.Empty, r.Replace (String.Empty, String.Empty), "Replace4");
			Assert.AreEqual (String.Empty, r.Replace (String.Empty, String.Empty, 0), "Replace5");
			Assert.AreEqual (String.Empty, r.Replace (String.Empty, String.Empty, 0, 0), "Replace6");

			Assert.AreEqual (2, r.Split (String.Empty).Length, "Split");
			Assert.AreEqual (2, r.Split (String.Empty, 0).Length, "Split2");
			Assert.AreEqual (2, r.Split (String.Empty, 0, 0).Length, "Split3");

			Assert.AreEqual (String.Empty, r.ToString (), "ToString");
		}
        /// <summary>
        ///    Adds a System.Web.UI.ScriptResourceDefinition object to the System.Web.UI.ScriptResourceMapping
        ///    object, but only if a file matching the supplied regex pattern is found. If the pattern includes
        ///    a capture group called "ver", it will be used to determine the highest version found.
        /// </summary>
        /// <param name="map">The ScriptResourceMapping object.</param>
        /// <param name="name">The name of the script resource.</param>
        /// <param name="assembly">A System.Reflection.Assembly object that is used along with the name as the script resource key.</param>
        /// <param name="definition">
        ///     A System.Web.UI.ScriptResourceDefinition object that specifies location support
        ///     for script resources. The Path and optionally DebugPath properties should contain
        ///     the path to the virtual folder containing the script to find, e.g. ~/Scripts/
        /// </param>
        /// <param name="fileNamePattern">
        ///     The regex pattern to match files against. If the pattern includes
        ///     a capture group called "ver", it will be used to determine the highest version found.
        ///     Use ScriptResourceMappingExtensions.VerRegexPattern for a pattern matching standard
        ///     versioning strings, e.g. 1, 1.0, 1.1.2, etc.
        /// </param>
        public static void AddDefinitionIfFound(this ScriptResourceMapping map, string name, Assembly assembly, ScriptResourceDefinition definition, string fileNamePattern)
        {
            var scriptsFolder = VirtualPathProvider.GetDirectory(definition.Path);

            if (scriptsFolder == null)
            {
                return;
            }

            var scripts = scriptsFolder.Files.Cast<VirtualFile>();

            var fileNamePatternRegex = new Regex(fileNamePattern, RegexOptions.Compiled | RegexOptions.IgnoreCase);

            var supportVer = fileNamePatternRegex.GroupNumberFromName("ver") >= 0;

            var foundFile = (from file in scripts
                             let match = fileNamePatternRegex.Match(file.Name)
                             where match.Success
                             let fileVer = supportVer ? GetVersion(match) : null
                             orderby fileVer descending
                             select new
                             {
                                 file.Name,
                                 Version = fileVer
                             }).FirstOrDefault();

            if (foundFile != null)
            {
                var ver = foundFile.Version != null
                    ? Regex.Match(foundFile.Name, VerRegexPattern, RegexOptions.IgnoreCase).Groups["ver"].Value
                    : "";
                var isMin = foundFile.Name.EndsWith(".min.js", StringComparison.OrdinalIgnoreCase);

                var fileNamePrefix = foundFile.Name.Substring(0,
                    foundFile.Name.IndexOf(ver + (isMin ? ".min.js" : ".js")));

                var altFile = scripts.SingleOrDefault(f => f.Name.Equals(
                    String.Format(isMin ? "{0}{1}.js" : "{0}{1}.min.js", fileNamePrefix, ver),
                    StringComparison.OrdinalIgnoreCase));

                var hasBoth = altFile != null;

                var minFileName = isMin
                    ? foundFile.Name
                    : hasBoth
                        ? altFile.Name
                        : null;

                var nonMinFileName = !isMin
                    ? foundFile.Name
                    : hasBoth
                        ? altFile.Name
                        : null;

                var minOnly = isMin && !hasBoth;

                var path = minOnly || hasBoth
                    ? minFileName
                    : nonMinFileName;

                var debugPath = hasBoth
                    ? nonMinFileName
                    : null;

                path = path == null ? null : definition.Path + path;

                debugPath = debugPath == null ? null : (definition.DebugPath ?? definition.Path) + debugPath;

                var cdnPath = definition.CdnPath != null
                    ? ver != null
                        ? String.Format(definition.CdnPath, ver)
                        : definition.CdnPath
                    : null;

                var cdnDebugPath = definition.CdnDebugPath != null
                    ? ver != null
                        ? String.Format(definition.CdnDebugPath, ver)
                        : definition.CdnDebugPath
                    : null;

                map.AddDefinition(name, assembly, new ScriptResourceDefinition
                {
                    Path = path,
                    DebugPath = debugPath,
                    CdnPath = cdnPath,
                    CdnDebugPath = cdnDebugPath,
                    CdnSupportsSecureConnection = definition.CdnSupportsSecureConnection
                });
            }
        }
Ejemplo n.º 15
0
        protected static int GetNumberFromCode(String mask, String code)
        {
            var numberRegex = new Regex(mask);
            var numberMatch = numberRegex.Match(code);
            var s = numberMatch.Groups[numberRegex.GroupNumberFromName("number")].Value;

            var numberByCode = 0;
            if (!int.TryParse(s, out numberByCode))
            {
                throw new Exception("Маска нумератора для объекта не содержит номера");
            }
            return numberByCode;
        }
 private static Regex GetSqlTokenParser()
 {
     Regex regex = _sqlTokenParser;
     if (regex == null)
     {
         regex = new Regex(_sqlTokenPattern, RegexOptions.ExplicitCapture | RegexOptions.IgnoreCase);
         _identifierGroup = regex.GroupNumberFromName("identifier");
         _quotedidentifierGroup = regex.GroupNumberFromName("quotedidentifier");
         _keywordGroup = regex.GroupNumberFromName("keyword");
         _stringGroup = regex.GroupNumberFromName("string");
         _otherGroup = regex.GroupNumberFromName("other");
         _sqlTokenParser = regex;
     }
     return regex;
 }
Ejemplo n.º 17
0
// ReSharper disable MemberCanBeMadeStatic
        internal List<AdressedCapture> getNamedCaptureIndex(Match m, string[] groupNames, Regex reg)
// ReSharper restore MemberCanBeMadeStatic
        {
            var res = new List<AdressedCapture>();
            var captureid = 1;
            var findex = 0;
            foreach (var groupName in groupNames){
                //√руппа с номером 0 всегда попадает в список имен, даже если включена опци¤			ExplicitCapture, это надо отсечь, равно как любые другие не эксплицитные группы
                if (groupName == "0" || Regex.IsMatch(groupName, "^\\d+$")) continue;

                findex++;
                foreach (Capture c in m.Groups[groupName].Captures){
                    res.Add(new AdressedCapture(captureid, groupName, c, reg.GroupNumberFromName(groupName)));
                    captureid++;
                }
            }
            res.Sort();
            return res;
        }
Ejemplo n.º 18
0
        private void BuildTree(Regex re, Match match)
        {
            string[] groups = re.GetGroupNames ();
            Dictionary<string, int> groupNumbers = new Dictionary<string, int> ();
            foreach (string groupName in groups)
                groupNumbers.Add (groupName, re.GroupNumberFromName (groupName));

            List<ExprMatchGroup> emgList = new List<ExprMatchGroup> ();
            for (int i = 0; i < groups.Length; i++)
            {
                string groupName = groups [i];
                if (groupName != "0")
                {
                    Group group = match.Groups [groupName];
                    if (group.Success)
                    {
                        for (int j = 0; j < group.Captures.Count; j++)
                        {
                            Capture cap = group.Captures [j];
                            emgList.Add (new ExprMatchGroup (groupName, cap.Value, cap.Index, cap.Length));
                        }
                    }
                }
            }
            emgList.Sort (new Comparison<ExprMatchGroup> ((emg1, emg2) =>  {
                int c = emg1.StartIndex.CompareTo (emg2.StartIndex);
                if (c == 0)
                    c = -1 * emg1.EndIndex.CompareTo (emg2.EndIndex);
                if (c == 0)
                {
                    if (emg1.Name == BadrGrammar.GROUP_VARIABLE_VALUE)
                        return 1;
                    else
                        if (emg2.Name == BadrGrammar.GROUP_VARIABLE_VALUE)
                            return -1;
                }
                return c;
            }));
            for (int i = 0; i < emgList.Count; i++)
            {
                Add (emgList [i], true);
            }
        }
Ejemplo n.º 19
0
 /// <summary>
 /// Returns the group number that corresponds to the specified group name.
 /// </summary>
 /// <param name="name">Group name to be converted to the corresponding group number.</param>
 /// <returns>Group number corresponding to the specified group <paramref name="name"/>, or -1 if <paramref name="name"/> is not a valid group <paramref name="name"/>.</returns>
 /// <exception cref="ArgumentNullException">name has the value null.</exception>
 public int GroupNumberFromName(string name)
 {
     return(_regex.GroupNumberFromName(name));
 }
 private string ValidateReplacementPattern(XmlReader reader, Regex find, string repl)
 {
     var sb = new StringBuilder(repl).Append('\0');
     int index = -1;
     int mode = 0;
     while (++index < sb.Length)
     {
         char c = sb[index];
         switch (mode)
         {
             case 0:
                 if (c == '$')
                 {
                     mode = 2;
                 }
                 break;
             case 1: // $$
                 if ("0123456789{".IndexOf(c) >= 0)
                 {
                     _factory.Warn(reader, string.Format("replaceWith=\"{0}\" - Perhaps you meant \"{1}${2}\"?", repl, sb.ToString(0, index), c));
                 }
                 index -= 1;
                 mode = 0;
                 break;
             case 2: // $
                 mode = 0;
                 switch (c)
                 {
                     case '0': case '1': case '2': case '3': case '4':
                     case '5': case '6': case '7': case '8': case '9':
                         mode = 3;
                         break;
                     case '{':
                         mode = 4;
                         break;
                     case '$':
                         mode = 1;
                         break;
                     case '\'':
                     case '`':
                     case '_':
                         _factory.Warn(reader, string.Format("replaceWith=\"{0}\" - Are you sure you want \"${1}\" in the replacement pattern?", repl, c));
                         break;
                     case '&':
                     case '+':
                         break;
                     default:
                         sb.Insert(index, '$');
                         _factory.Verbose(reader, string.Format("replaceWith=\"{0}\" - Missing '$' inserted: \"{1}\"", repl, sb.ToString(0, index + 1)));
                         break;
                 }
                 break;
             case 3: // $[0-9]+
                 if ("0123456789".IndexOf(c) < 0)
                 {
                     var start = sb.ToString(0, index).LastIndexOf('$') + 1;
                     var group = sb.ToString(start, index - start);
                     if (find.GroupNumberFromName(group) < 0)
                     {
                         _factory.Warn(reader, string.Format("replaceWith=\"{0}\" - Group \"{1}\" is not defined in the regular expression pattern!", repl, group));
                     }
                     index -= 1;
                     mode = 0;
                 }
                 break;
             case 4: // ${
                 mode = 5;
                 if ("_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".IndexOf(c) < 0)
                 {
                     _factory.Warn(reader, string.Format("replaceWith=\"{0}\" - Invalid group identifier \"{1}\"?", repl, sb.ToString(index - 2, 3)));
                     index -= 1;
                     mode = 0;
                 }
                 break;
             case 5: // ${[0-9A-Za-z]+
                 if (c == '}')
                 {
                     var start = sb.ToString(0, index).LastIndexOf('{') + 1;
                     var group = sb.ToString(start, index - start);
                     if (find.GroupNumberFromName(group) < 0)
                     {
                         _factory.Warn(reader, string.Format("replaceWith=\"{0}\" - Group \"{1}\" is not defined in the regular expression pattern!", repl, group));
                     }
                     mode = 0;
                 }
                 else if ("_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".IndexOf(c) < 0)
                 {
                     var start = sb.ToString(0, index).LastIndexOf('$');
                     _factory.Warn(reader, string.Format("replaceWith=\"{0}\" - Invalid group identifier \"{1}\"?", repl, sb.ToString(start, index - start)));
                     index -= 1;
                     mode = 0;
                 }
                 break;
         }
     }
     return sb.ToString(0, sb.Length - 1);
 }
 private static Regex GetSqlTokenParser()
 {
     Regex regex = _sqlTokenParser;
     if (regex == null)
     {
         regex = new Regex(_sqlTokenPattern, RegexOptions.ExplicitCapture);
         _commentGroup = regex.GroupNumberFromName("comment");
         _identifierGroup = regex.GroupNumberFromName("identifier");
         _parameterMarkerGroup = regex.GroupNumberFromName("parametermarker");
         _queryGroup = regex.GroupNumberFromName("query");
         _stringGroup = regex.GroupNumberFromName("string");
         _otherGroup = regex.GroupNumberFromName("other");
         _sqlTokenParser = regex;
     }
     return regex;
 }
        /// <summary>
        /// Check if a specific .NET Framework version is installed.
        /// </summary>
        /// <param name="version">version to test</param>
        /// <returns>True if installed</returns>
        public static bool IsVersionInstalled(FrameworkVersions version)
        {
            try
            {
                switch (version)
                {
                    case FrameworkVersions.Mono_2_4:

                        if (!string.IsNullOrEmpty(MonoVersion))
                        {
                            var regex = new Regex(@"^Mono (?<major>\d+)\.(?<minor>\d+)(\..*)?$");
                            if (regex.IsMatch(MonoVersion))
                            {
                                var items = regex.Split(MonoVersion);

                                var major = Convert.ToInt32(items[regex.GroupNumberFromName("major")]);
                                var minor = Convert.ToInt32(items[regex.GroupNumberFromName("minor")]);

                                return (major == 2 && minor >= 4) || (major >= 3);
                            }
                        }
                        break;
                    default:
                        var masterKey = Registry.LocalMachine.OpenSubKey(RegLocation);

                        if (masterKey != null)
                        {
	                        var subKeyNames = masterKey.GetSubKeyNames();
	                        if (subKeyNames.Any(ver => ver.ToLower().Replace(".", "_") == version.ToString()))
		                        return true;
                        }
		                break;
                }
            }
            catch (Exception)
            {
				return false;
			}

            return false;
        }
Ejemplo n.º 23
0
        public GroupImpl FromName(string inputName)
        {
            int index = _regex.GroupNumberFromName(inputName);

            return(new GroupImpl(_groups[(int)index], (int)index, _regex));
        }