* System.dll.sources: Update.
In System.Text.RegularExpressions:
* regex.cs: Remove. Split into ...
* MatchEvaluator.cs, Regex.cs, RegexCompilationInfo.cs,
RegexOptions.cs: ... these. Now every publicly exposed type in
this namespace has its own file.
svn path=/trunk/mcs/; revision=48728
+2005-08-23 Raja R Harinath <rharinath@novell.com>
+
+ * System.dll.sources: Update.
+
2005-08-18 Gert Driesen <drieseng@users.sourceforge.net>
* System_test.dll.sources: Added DecimalConverterTests.cs,
+2005-08-23 Raja R Harinath <rharinath@novell.com>
+
+ * regex.cs: Remove. Split into ...
+ * MatchEvaluator.cs, Regex.cs, RegexCompilationInfo.cs,
+ RegexOptions.cs: ... these. Now every publicly exposed type in
+ this namespace has its own file.
+
2005-07-21 Florian Gross <flgr@ccan.de>
* Fixed a bug in category.cs that caused ECMAScript \d to fail.
--- /dev/null
+//
+// assembly: System
+// namespace: System.Text.RegularExpressions
+// file: regex.cs
+//
+// author: Dan Lewis (dlewis@gmx.co.uk)
+// (c) 2002
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+namespace System.Text.RegularExpressions {
+ public delegate string MatchEvaluator (Match match);
+}
--- /dev/null
+//
+// assembly: System
+// namespace: System.Text.RegularExpressions
+// file: regex.cs
+//
+// author: Dan Lewis (dlewis@gmx.co.uk)
+// (c) 2002
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Text;
+using System.Collections;
+using System.Reflection;
+using System.Reflection.Emit;
+using System.Runtime.Serialization;
+
+using RegularExpression = System.Text.RegularExpressions.Syntax.RegularExpression;
+using Parser = System.Text.RegularExpressions.Syntax.Parser;
+
+using System.Diagnostics;
+
+
+namespace System.Text.RegularExpressions {
+
+ [Serializable]
+ public class Regex : ISerializable {
+ public static void CompileToAssembly (RegexCompilationInfo [] regexes, AssemblyName aname)
+ {
+ Regex.CompileToAssembly(regexes, aname, new CustomAttributeBuilder [] {}, null);
+ }
+
+ public static void CompileToAssembly (RegexCompilationInfo [] regexes, AssemblyName aname,
+ CustomAttributeBuilder [] attribs)
+ {
+ Regex.CompileToAssembly(regexes, aname, attribs, null);
+ }
+
+ [MonoTODO]
+ public static void CompileToAssembly (RegexCompilationInfo [] regexes, AssemblyName aname,
+ CustomAttributeBuilder [] attribs, string resourceFile)
+ {
+ throw new NotImplementedException ();
+ // TODO : Make use of attribs and resourceFile parameters
+ /*
+ AssemblyBuilder asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly (aname, AssemblyBuilderAccess.RunAndSave);
+ ModuleBuilder modBuilder = asmBuilder.DefineDynamicModule("InnerRegexModule",aname.Name);
+ Parser psr = new Parser ();
+
+ System.Console.WriteLine("CompileToAssembly");
+
+ for(int i=0; i < regexes.Length; i++)
+ {
+ System.Console.WriteLine("Compiling expression :" + regexes[i].Pattern);
+ RegularExpression re = psr.ParseRegularExpression (regexes[i].Pattern, regexes[i].Options);
+
+ // compile
+
+ CILCompiler cmp = new CILCompiler (modBuilder, i);
+ bool reverse = (regexes[i].Options & RegexOptions.RightToLeft) !=0;
+ re.Compile (cmp, reverse);
+ cmp.Close();
+
+ }
+
+
+ // Define a runtime class with specified name and attributes.
+ TypeBuilder builder = modBuilder.DefineType("ITest");
+ builder.CreateType();
+ asmBuilder.Save(aname.Name);
+ */
+ }
+
+ public static string Escape (string str)
+ {
+ return Parser.Escape (str);
+ }
+
+ public static string Unescape (string str)
+ {
+ return Parser.Unescape (str);
+ }
+
+ public static bool IsMatch (string input, string pattern)
+ {
+ return IsMatch (input, pattern, RegexOptions.None);
+ }
+
+ public static bool IsMatch (string input, string pattern, RegexOptions options)
+ {
+ Regex re = new Regex (pattern, options);
+ return re.IsMatch (input);
+ }
+
+ public static Match Match (string input, string pattern)
+ {
+ return Regex.Match (input, pattern, RegexOptions.None);
+ }
+
+ public static Match Match (string input, string pattern, RegexOptions options)
+ {
+ Regex re = new Regex (pattern, options);
+ return re.Match (input);
+ }
+
+ public static MatchCollection Matches (string input, string pattern)
+ {
+ return Matches (input, pattern, RegexOptions.None);
+ }
+
+ public static MatchCollection Matches (string input, string pattern, RegexOptions options)
+ {
+ Regex re = new Regex (pattern, options);
+ return re.Matches (input);
+ }
+
+ public static string Replace (string input, string pattern, MatchEvaluator evaluator)
+ {
+ return Regex.Replace (input, pattern, evaluator, RegexOptions.None);
+ }
+
+ public static string Replace (string input, string pattern, MatchEvaluator evaluator,
+ RegexOptions options)
+ {
+ Regex re = new Regex (pattern, options);
+ return re.Replace (input, evaluator);
+ }
+
+ public static string Replace (string input, string pattern, string replacement)
+ {
+ return Regex.Replace (input, pattern, replacement, RegexOptions.None);
+ }
+
+ public static string Replace (string input, string pattern, string replacement,
+ RegexOptions options)
+ {
+ Regex re = new Regex (pattern, options);
+ return re.Replace (input, replacement);
+ }
+
+ public static string [] Split (string input, string pattern)
+ {
+ return Regex.Split (input, pattern, RegexOptions.None);
+ }
+
+ public static string [] Split (string input, string pattern, RegexOptions options)
+ {
+ Regex re = new Regex (pattern, options);
+ return re.Split (input);
+ }
+
+ // private
+
+ private static FactoryCache cache = new FactoryCache (200); // TODO put some meaningful number here
+
+ // constructors
+
+ protected Regex ()
+ {
+ // XXX what's this constructor for?
+ // : Used to compile to assembly (Custum regex inherit from Regex and use this constructor)
+ }
+
+ public Regex (string pattern) : this (pattern, RegexOptions.None)
+ {
+ }
+
+ public Regex (string pattern, RegexOptions options)
+ {
+ this.pattern = pattern;
+ this.roptions = options;
+
+ this.machineFactory = cache.Lookup (pattern, options);
+
+ if (this.machineFactory == null) {
+ // parse and install group mapping
+
+ Parser psr = new Parser ();
+ RegularExpression re = psr.ParseRegularExpression (pattern, options);
+ this.group_count = re.GroupCount;
+ this.mapping = psr.GetMapping ();
+
+ // compile
+
+ ICompiler cmp;
+ //if ((options & RegexOptions.Compiled) != 0)
+ // //throw new Exception ("Not implemented.");
+ // cmp = new CILCompiler ();
+ //else
+ cmp = new PatternCompiler ();
+
+ re.Compile (cmp, RightToLeft);
+
+ // install machine factory and add to pattern cache
+
+ this.machineFactory = cmp.GetMachineFactory ();
+ this.machineFactory.Mapping = mapping;
+ cache.Add (pattern, options, this.machineFactory);
+ } else {
+ this.group_count = this.machineFactory.GroupCount;
+ this.mapping = this.machineFactory.Mapping;
+ }
+ }
+
+ private Regex (SerializationInfo info, StreamingContext context) :
+ this (info.GetString ("pattern"),
+ (RegexOptions) info.GetValue ("options", typeof (RegexOptions)))
+ {
+ }
+
+ // fixes public API signature
+ ~Regex ()
+ {
+ }
+
+ // public instance properties
+
+ public RegexOptions Options {
+ get { return roptions; }
+ }
+
+ public bool RightToLeft {
+ get { return (roptions & RegexOptions.RightToLeft) != 0; }
+ }
+
+ // public instance methods
+
+ public string [] GetGroupNames ()
+ {
+ string [] names = new string [mapping.Count];
+ mapping.Keys.CopyTo (names, 0);
+
+ return names;
+ }
+
+ public int[] GetGroupNumbers ()
+ {
+ int[] numbers = new int [mapping.Count];
+ mapping.Values.CopyTo (numbers, 0);
+
+ return numbers;
+ }
+
+ public string GroupNameFromNumber (int i)
+ {
+ if (i > group_count)
+ return "";
+
+ foreach (string name in mapping.Keys) {
+ if ((int) mapping [name] == i)
+ return name;
+ }
+
+ return "";
+ }
+
+ public int GroupNumberFromName (string name)
+ {
+ if (mapping.Contains (name))
+ return (int) mapping [name];
+
+ return -1;
+ }
+
+ // match methods
+
+ public bool IsMatch (string input)
+ {
+ return IsMatch (input, RightToLeft ? input.Length : 0);
+ }
+
+ public bool IsMatch (string input, int startat)
+ {
+ return Match (input, startat).Success;
+ }
+
+ public Match Match (string input)
+ {
+ return Match (input, RightToLeft ? input.Length : 0);
+ }
+
+ public Match Match (string input, int startat)
+ {
+ return CreateMachine ().Scan (this, input, startat, input.Length);
+ }
+
+ public Match Match (string input, int startat, int length)
+ {
+ return CreateMachine ().Scan (this, input, startat, startat + length);
+ }
+
+ public MatchCollection Matches (string input)
+ {
+ return Matches (input, RightToLeft ? input.Length : 0);
+ }
+
+ public MatchCollection Matches (string input, int startat)
+ {
+ Match m = Match (input, startat);
+ return new MatchCollection (m);
+ }
+
+ // replace methods
+
+ public string Replace (string input, MatchEvaluator evaluator)
+ {
+ return Replace (input, evaluator, Int32.MaxValue, RightToLeft ? input.Length : 0);
+ }
+
+ public string Replace (string input, MatchEvaluator evaluator, int count)
+ {
+ return Replace (input, evaluator, count, RightToLeft ? input.Length : 0);
+ }
+
+ class Adapter {
+ MatchEvaluator ev;
+ public Adapter (MatchEvaluator ev) { this.ev = ev; }
+ public void Evaluate (Match m, StringBuilder sb) { sb.Append (ev (m)); }
+ }
+
+ delegate void MatchAppendEvaluator (Match match, StringBuilder sb);
+
+ public string Replace (string input, MatchEvaluator evaluator, int count, int startat)
+ {
+ Adapter a = new Adapter (evaluator);
+ return Replace (input, new MatchAppendEvaluator (a.Evaluate), count, startat);
+ }
+
+ string Replace (string input, MatchAppendEvaluator evaluator, int count, int startat)
+ {
+ StringBuilder result = new StringBuilder ();
+ int ptr = startat;
+ int counter = count;
+
+ result.Append (input, 0, ptr);
+
+ Match m = Match (input, startat);
+ while (m.Success) {
+ if (count != -1)
+ if(counter -- <= 0)
+ break;
+ result.Append (input, ptr, m.Index - ptr);
+ evaluator (m, result);
+
+ ptr = m.Index + m.Length;
+ m = m.NextMatch ();
+ }
+
+ if (ptr == 0)
+ return input;
+
+ result.Append (input, ptr, input.Length - ptr);
+
+ return result.ToString ();
+ }
+
+ public string Replace (string input, string replacement)
+ {
+ return Replace (input, replacement, Int32.MaxValue, RightToLeft ? input.Length : 0);
+ }
+
+ public string Replace (string input, string replacement, int count)
+ {
+ return Replace (input, replacement, count, RightToLeft ? input.Length : 0);
+ }
+
+ public string Replace (string input, string replacement, int count, int startat)
+ {
+ ReplacementEvaluator ev = new ReplacementEvaluator (this, replacement);
+ return Replace (input, new MatchAppendEvaluator (ev.EvaluateAppend), count, startat);
+ }
+
+ // split methods
+
+ public string [] Split (string input)
+ {
+ return Split (input, Int32.MaxValue, RightToLeft ? input.Length : 0);
+ }
+
+ public string [] Split (string input, int count)
+ {
+ return Split (input, count, RightToLeft ? input.Length : 0);
+ }
+
+ public string [] Split (string input, int count, int startat)
+ {
+ ArrayList splits = new ArrayList ();
+ if (count == 0)
+ count = Int32.MaxValue;
+
+ int ptr = startat;
+ Match m = null;
+ while (--count > 0) {
+ if (m != null)
+ m = m.NextMatch ();
+ else
+ m = Match (input, ptr);
+
+ if (!m.Success)
+ break;
+
+ if (RightToLeft)
+ splits.Add (input.Substring (m.Index + m.Length, ptr - m.Index - m.Length));
+ else
+ splits.Add (input.Substring (ptr, m.Index - ptr));
+
+ int gcount = m.Groups.Count;
+ for (int gindex = 1; gindex < gcount; gindex++) {
+ Group grp = m.Groups [gindex];
+ splits.Add (input.Substring (grp.Index, grp.Length));
+ }
+
+ if (RightToLeft)
+ ptr = m.Index;
+ else
+ ptr = m.Index + m.Length;
+
+ }
+
+ if (RightToLeft && ptr >= 0)
+ splits.Add (input.Substring (0, ptr));
+ if (!RightToLeft && ptr <= input.Length)
+ splits.Add (input.Substring (ptr));
+
+ return (string []) splits.ToArray (typeof (string));
+ }
+
+ // MS undocummented method
+ [MonoTODO]
+ protected void InitializeReferences()
+ {
+ throw new NotImplementedException ();
+ }
+
+ [MonoTODO]
+ protected bool UseOptionC()
+ {
+ throw new NotImplementedException ();
+ }
+
+ [MonoTODO]
+ protected bool UseOptionR()
+ {
+ throw new NotImplementedException ();
+ }
+
+ // object methods
+
+ public override string ToString ()
+ {
+ return pattern;
+ }
+
+ // ISerializable interface
+ void ISerializable.GetObjectData (SerializationInfo info, StreamingContext context)
+ {
+ info.AddValue ("pattern", this.ToString (), typeof (string));
+ info.AddValue ("options", this.Options, typeof (RegexOptions));
+ }
+
+ // internal
+
+ internal int GroupCount {
+ get { return group_count; }
+ }
+
+ // private
+
+ private IMachine CreateMachine ()
+ {
+ return machineFactory.NewInstance ();
+ }
+
+ private IMachineFactory machineFactory;
+ private IDictionary mapping;
+ private int group_count;
+
+
+ // protected members
+
+ protected internal string pattern;
+ protected internal RegexOptions roptions;
+
+ // MS undocumented members
+ [MonoTODO]
+ protected internal System.Collections.Hashtable capnames;
+ [MonoTODO]
+ protected internal System.Collections.Hashtable caps;
+ [MonoTODO]
+ protected internal int capsize;
+ [MonoTODO]
+ protected internal string [] capslist;
+ [MonoTODO]
+ protected internal RegexRunnerFactory factory;
+ }
+}
--- /dev/null
+//
+// assembly: System
+// namespace: System.Text.RegularExpressions
+// file: regex.cs
+//
+// author: Dan Lewis (dlewis@gmx.co.uk)
+// (c) 2002
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System.Runtime.Serialization;
+
+namespace System.Text.RegularExpressions {
+
+ [Serializable]
+ public class RegexCompilationInfo {
+ public RegexCompilationInfo (string pattern, RegexOptions options, string name, string nspace, bool isPublic)
+ {
+ this.pattern = pattern;
+ this.options = options;
+ this.name = name;
+ this.nspace = nspace;
+ this.isPublic = isPublic;
+ }
+
+ public bool IsPublic {
+ get { return isPublic; }
+ set { isPublic = value; }
+ }
+
+ public string Name {
+ get { return name; }
+ set { name = value; }
+ }
+
+ public string Namespace {
+ get { return nspace; }
+ set { nspace = value; }
+ }
+
+ public RegexOptions Options {
+ get { return options; }
+ set { options = value; }
+ }
+
+ public string Pattern {
+ get { return pattern; }
+ set { pattern = value; }
+ }
+
+ // private
+
+ private string pattern, name, nspace;
+ private RegexOptions options;
+ private bool isPublic;
+ }
+}
--- /dev/null
+//
+// assembly: System
+// namespace: System.Text.RegularExpressions
+// file: regex.cs
+//
+// author: Dan Lewis (dlewis@gmx.co.uk)
+// (c) 2002
+
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+namespace System.Text.RegularExpressions {
+
+ [Flags]
+ public enum RegexOptions {
+ None = 0x000,
+ IgnoreCase = 0x001,
+ Multiline = 0x002,
+ ExplicitCapture = 0x004,
+ Compiled = 0x008,
+ Singleline = 0x010,
+ IgnorePatternWhitespace = 0x020,
+ RightToLeft = 0x040,
+ ECMAScript = 0x100,
+ CultureInvariant = 0x200
+ }
+}
+++ /dev/null
-//\r
-// assembly: System\r
-// namespace: System.Text.RegularExpressions\r
-// file: regex.cs\r
-//\r
-// author: Dan Lewis (dlewis@gmx.co.uk)\r
-// (c) 2002\r
-\r
-//\r
-// Permission is hereby granted, free of charge, to any person obtaining\r
-// a copy of this software and associated documentation files (the\r
-// "Software"), to deal in the Software without restriction, including\r
-// without limitation the rights to use, copy, modify, merge, publish,\r
-// distribute, sublicense, and/or sell copies of the Software, and to\r
-// permit persons to whom the Software is furnished to do so, subject to\r
-// the following conditions:\r
-// \r
-// The above copyright notice and this permission notice shall be\r
-// included in all copies or substantial portions of the Software.\r
-// \r
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,\r
-// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\r
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND\r
-// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE\r
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION\r
-// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION\r
-// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
-//\r
-\r
-using System;\r
-using System.Text;\r
-using System.Collections;\r
-using System.Reflection;\r
-using System.Reflection.Emit;\r
-using System.Runtime.Serialization;\r
-\r
-using RegularExpression = System.Text.RegularExpressions.Syntax.RegularExpression;\r
-using Parser = System.Text.RegularExpressions.Syntax.Parser;\r
-\r
-using System.Diagnostics;\r
-\r
-\r
-namespace System.Text.RegularExpressions {\r
- \r
- public delegate string MatchEvaluator (Match match);\r
-\r
- delegate void MatchAppendEvaluator (Match match, StringBuilder sb);\r
-\r
- [Flags]\r
- public enum RegexOptions {\r
- None = 0x000,\r
- IgnoreCase = 0x001,\r
- Multiline = 0x002,\r
- ExplicitCapture = 0x004,\r
- Compiled = 0x008,\r
- Singleline = 0x010,\r
- IgnorePatternWhitespace = 0x020,\r
- RightToLeft = 0x040,\r
- ECMAScript = 0x100,\r
- CultureInvariant = 0x200 \r
- }\r
- \r
- [Serializable]\r
- public class Regex : ISerializable {\r
- public static void CompileToAssembly\r
- (RegexCompilationInfo[] regexes, AssemblyName aname)\r
- {\r
- Regex.CompileToAssembly(regexes, aname, new CustomAttributeBuilder[] {}, null);\r
- }\r
-\r
- public static void CompileToAssembly\r
- (RegexCompilationInfo[] regexes, AssemblyName aname,\r
- CustomAttributeBuilder[] attribs)\r
- {\r
- Regex.CompileToAssembly(regexes, aname, attribs, null);\r
- }\r
-\r
- [MonoTODO]\r
- public static void CompileToAssembly\r
- (RegexCompilationInfo[] regexes, AssemblyName aname,\r
- CustomAttributeBuilder[] attribs, string resourceFile)\r
- {\r
- throw new NotImplementedException ();\r
- // TODO : Make use of attribs and resourceFile parameters\r
- /*\r
- AssemblyBuilder asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly (aname, AssemblyBuilderAccess.RunAndSave);\r
- ModuleBuilder modBuilder = asmBuilder.DefineDynamicModule("InnerRegexModule",aname.Name);\r
- Parser psr = new Parser (); \r
- \r
- System.Console.WriteLine("CompileToAssembly");\r
- \r
- for(int i=0; i < regexes.Length; i++)\r
- {\r
- System.Console.WriteLine("Compiling expression :" + regexes[i].Pattern);\r
- RegularExpression re = psr.ParseRegularExpression (regexes[i].Pattern, regexes[i].Options);\r
- \r
- // compile\r
- \r
- CILCompiler cmp = new CILCompiler (modBuilder, i);\r
- bool reverse = (regexes[i].Options & RegexOptions.RightToLeft) !=0;\r
- re.Compile (cmp, reverse);\r
- cmp.Close();\r
- \r
- }\r
- \r
-\r
- // Define a runtime class with specified name and attributes.\r
- TypeBuilder builder = modBuilder.DefineType("ITest");\r
- builder.CreateType();\r
- asmBuilder.Save(aname.Name);\r
- */\r
- }\r
- \r
- public static string Escape (string str) {\r
- return Parser.Escape (str);\r
- }\r
-\r
- public static string Unescape (string str) {\r
- return Parser.Unescape (str);\r
- }\r
-\r
- public static bool IsMatch (string input, string pattern) {\r
- return IsMatch (input, pattern, RegexOptions.None);\r
- }\r
-\r
- public static bool IsMatch (string input, string pattern, RegexOptions options) {\r
- Regex re = new Regex (pattern, options);\r
- return re.IsMatch (input);\r
- }\r
-\r
- public static Match Match (string input, string pattern) {\r
- return Regex.Match (input, pattern, RegexOptions.None);\r
- }\r
-\r
- public static Match Match (string input, string pattern, RegexOptions options) {\r
- Regex re = new Regex (pattern, options);\r
- return re.Match (input);\r
- }\r
-\r
- public static MatchCollection Matches (string input, string pattern) {\r
- return Matches (input, pattern, RegexOptions.None);\r
- }\r
-\r
- public static MatchCollection Matches (string input, string pattern, RegexOptions options) {\r
- Regex re = new Regex (pattern, options);\r
- return re.Matches (input);\r
- }\r
-\r
- public static string Replace\r
- (string input, string pattern, MatchEvaluator evaluator)\r
- {\r
- return Regex.Replace (input, pattern, evaluator, RegexOptions.None);\r
- }\r
-\r
- public static string Replace\r
- (string input, string pattern, MatchEvaluator evaluator,\r
- RegexOptions options)\r
- {\r
- Regex re = new Regex (pattern, options);\r
- return re.Replace (input, evaluator);\r
- }\r
-\r
- public static string Replace\r
- (string input, string pattern, string replacement)\r
- {\r
- return Regex.Replace (input, pattern, replacement, RegexOptions.None);\r
- }\r
-\r
- public static string Replace\r
- (string input, string pattern, string replacement,\r
- RegexOptions options)\r
- {\r
- Regex re = new Regex (pattern, options);\r
- return re.Replace (input, replacement);\r
- }\r
-\r
- public static string[] Split (string input, string pattern) {\r
- return Regex.Split (input, pattern, RegexOptions.None);\r
- }\r
-\r
- public static string[] Split (string input, string pattern, RegexOptions options) {\r
- Regex re = new Regex (pattern, options);\r
- return re.Split (input);\r
- }\r
-\r
- // private\r
-\r
- private static FactoryCache cache = new FactoryCache (200); // TODO put some meaningful number here\r
-\r
- // constructors\r
-\r
- protected Regex () {\r
- // XXX what's this constructor for?\r
- // : Used to compile to assembly (Custum regex inherit from Regex and use this constructor)\r
- }\r
-\r
- public Regex (string pattern) : this (pattern, RegexOptions.None) {\r
- }\r
-\r
- public Regex (string pattern, RegexOptions options) {\r
- this.pattern = pattern;\r
- this.roptions = options;\r
- \r
- this.machineFactory = cache.Lookup (pattern, options);\r
-\r
- if (this.machineFactory == null) {\r
- // parse and install group mapping\r
-\r
- Parser psr = new Parser ();\r
- RegularExpression re = psr.ParseRegularExpression (pattern, options);\r
- this.group_count = re.GroupCount;\r
- this.mapping = psr.GetMapping ();\r
-\r
- // compile\r
- \r
- ICompiler cmp;\r
- //if ((options & RegexOptions.Compiled) != 0)\r
- // //throw new Exception ("Not implemented.");\r
- // cmp = new CILCompiler ();\r
- //else\r
- cmp = new PatternCompiler ();\r
-\r
- re.Compile (cmp, RightToLeft);\r
-\r
- // install machine factory and add to pattern cache\r
-\r
- this.machineFactory = cmp.GetMachineFactory ();\r
- this.machineFactory.Mapping = mapping;\r
- cache.Add (pattern, options, this.machineFactory);\r
- } else {\r
- this.group_count = this.machineFactory.GroupCount;\r
- this.mapping = this.machineFactory.Mapping;\r
- }\r
- }\r
-\r
- private Regex (SerializationInfo info, StreamingContext context) :\r
- this (info.GetString ("pattern"), \r
- (RegexOptions) info.GetValue ("options", typeof (RegexOptions))) {\r
- }\r
-\r
- // fixes public API signature\r
- ~Regex ()\r
- {\r
- }\r
-\r
- // public instance properties\r
- \r
- public RegexOptions Options {\r
- get { return roptions; }\r
- }\r
-\r
- public bool RightToLeft {\r
- get { return (roptions & RegexOptions.RightToLeft) != 0; }\r
- }\r
-\r
- // public instance methods\r
- \r
- public string[] GetGroupNames () {\r
- string[] names = new string[mapping.Count];\r
- mapping.Keys.CopyTo (names, 0);\r
-\r
- return names;\r
- }\r
-\r
- public int[] GetGroupNumbers () {\r
- int[] numbers = new int[mapping.Count];\r
- mapping.Values.CopyTo (numbers, 0);\r
-\r
- return numbers;\r
- }\r
-\r
- public string GroupNameFromNumber (int i) {\r
- if (i > group_count)\r
- return "";\r
- \r
- foreach (string name in mapping.Keys) {\r
- if ((int)mapping[name] == i)\r
- return name;\r
- }\r
-\r
- return "";\r
- }\r
-\r
- public int GroupNumberFromName (string name) {\r
- if (mapping.Contains (name))\r
- return (int)mapping[name];\r
-\r
- return -1;\r
- }\r
-\r
- // match methods\r
- \r
- public bool IsMatch (string input) {\r
- if (RightToLeft)\r
- return IsMatch (input, input.Length);\r
- else\r
- return IsMatch (input, 0);\r
- }\r
-\r
- public bool IsMatch (string input, int startat) {\r
- return Match (input, startat).Success;\r
- }\r
-\r
- public Match Match (string input) {\r
- if (RightToLeft)\r
- return Match (input, input.Length);\r
- else\r
- return Match (input, 0);\r
- }\r
-\r
- public Match Match (string input, int startat) {\r
- \r
- return CreateMachine ().Scan (this, input, startat, input.Length);\r
- }\r
-\r
- public Match Match (string input, int startat, int length) {\r
- \r
- return CreateMachine ().Scan (this, input, startat, startat + length);\r
- }\r
-\r
- public MatchCollection Matches (string input) {\r
- if (RightToLeft)\r
- return Matches (input, input.Length);\r
- else\r
- return Matches (input, 0);\r
- }\r
-\r
- public MatchCollection Matches (string input, int startat) {\r
- Match m = Match (input, startat);\r
- return new MatchCollection (m);\r
- }\r
-\r
- // replace methods\r
-\r
- public string Replace (string input, MatchEvaluator evaluator) {\r
- if (RightToLeft) \r
- return Replace (input, evaluator, Int32.MaxValue, input.Length);\r
- else\r
- return Replace (input, evaluator, Int32.MaxValue, 0);\r
- }\r
-\r
- public string Replace (string input, MatchEvaluator evaluator, int count) {\r
- if (RightToLeft)\r
- return Replace (input, evaluator, count, input.Length);\r
- else\r
- return Replace (input, evaluator, count, 0);\r
- }\r
-\r
- class Adapter\r
- {\r
- MatchEvaluator ev;\r
- public Adapter (MatchEvaluator ev) { this.ev = ev; }\r
- public void Evaluate (Match m, StringBuilder sb) { sb.Append (ev (m)); }\r
- }\r
-\r
- public string Replace (string input, MatchEvaluator evaluator, int count, int startat)\r
- {\r
- Adapter a = new Adapter (evaluator);\r
- return Replace (input, new MatchAppendEvaluator (a.Evaluate), count, startat);\r
- }\r
-\r
- string Replace (string input, MatchAppendEvaluator evaluator, int count, int startat)\r
- {\r
- StringBuilder result = new StringBuilder ();\r
- int ptr = startat;\r
- int counter = count;\r
-\r
- result.Append (input, 0, ptr);\r
-\r
- Match m = Match (input, startat);\r
- while (m.Success) {\r
- if (count != -1)\r
- if(counter -- <= 0)\r
- break;\r
- result.Append (input, ptr, m.Index - ptr);\r
- evaluator (m, result);\r
-\r
- ptr = m.Index + m.Length;\r
- m = m.NextMatch ();\r
- }\r
- \r
- if (ptr == 0)\r
- return input;\r
- \r
- result.Append (input, ptr, input.Length - ptr);\r
-\r
- return result.ToString ();\r
- }\r
-\r
- public string Replace (string input, string replacement) {\r
- if (RightToLeft)\r
- return Replace (input, replacement, Int32.MaxValue, input.Length);\r
- else\r
- return Replace (input, replacement, Int32.MaxValue, 0);\r
- }\r
-\r
- public string Replace (string input, string replacement, int count) {\r
- if (RightToLeft) \r
- return Replace (input, replacement, count, input.Length);\r
- else \r
- return Replace (input, replacement, count, 0);\r
- }\r
-\r
- public string Replace (string input, string replacement, int count, int startat) {\r
- ReplacementEvaluator ev = new ReplacementEvaluator (this, replacement);\r
- return Replace (input, new MatchAppendEvaluator (ev.EvaluateAppend), count, startat);\r
- }\r
-\r
- // split methods\r
-\r
- public string[] Split (string input) {\r
- if (RightToLeft) \r
- return Split (input, Int32.MaxValue, input.Length);\r
- else\r
- return Split (input, Int32.MaxValue, 0);\r
- }\r
-\r
- public string[] Split (string input, int count) {\r
- if (RightToLeft) \r
- return Split (input, count, input.Length);\r
- else\r
- return Split (input, count, 0);\r
- }\r
-\r
- public string[] Split (string input, int count, int startat) {\r
- ArrayList splits = new ArrayList ();\r
- if (count == 0)\r
- count = Int32.MaxValue;\r
-\r
- int ptr = startat;\r
- Match m = null;\r
- while (--count > 0) {\r
- if (m != null)\r
- m = m.NextMatch ();\r
- else\r
- m = Match (input, ptr);\r
-\r
- if (!m.Success)\r
- break;\r
- \r
- if (RightToLeft)\r
- splits.Add (input.Substring (m.Index + m.Length , ptr - m.Index - m.Length ));\r
- else\r
- splits.Add (input.Substring (ptr, m.Index - ptr));\r
- \r
- int gcount = m.Groups.Count;\r
- for (int gindex = 1; gindex < gcount; gindex++) {\r
- Group grp = m.Groups [gindex];\r
- splits.Add (input.Substring (grp.Index, grp.Length));\r
- }\r
-\r
- if (RightToLeft)\r
- ptr = m.Index; \r
- else\r
- ptr = m.Index + m.Length;\r
- \r
- }\r
-\r
- if (RightToLeft) {\r
- if ( ptr >= 0) {\r
- splits.Add (input.Substring(0, ptr));\r
- }\r
- } \r
- else {\r
- if (ptr <= input.Length) {\r
- splits.Add (input.Substring (ptr));\r
- }\r
- \r
- }\r
-\r
- return (string []) splits.ToArray (typeof (string));\r
- }\r
-\r
- // MS undocummented method\r
- [MonoTODO]\r
- protected void InitializeReferences() {\r
- throw new NotImplementedException ();\r
- }\r
-\r
- [MonoTODO]\r
- protected bool UseOptionC(){\r
- throw new NotImplementedException ();\r
- }\r
-\r
- [MonoTODO]\r
- protected bool UseOptionR(){\r
- throw new NotImplementedException ();\r
- }\r
-\r
- // object methods\r
- \r
- public override string ToString () {\r
- return pattern;\r
- }\r
-\r
- // ISerializable interface\r
- void ISerializable.GetObjectData (SerializationInfo info, StreamingContext context) {\r
- info.AddValue ("pattern", this.ToString (), typeof (string));\r
- info.AddValue ("options", this.Options, typeof (RegexOptions));\r
- }\r
-\r
- // internal\r
-\r
- internal int GroupCount {\r
- get { return group_count; }\r
- }\r
-\r
- // private\r
-\r
- private IMachine CreateMachine () {\r
- return machineFactory.NewInstance ();\r
- }\r
-\r
- private IMachineFactory machineFactory;\r
- private IDictionary mapping;\r
- private int group_count;\r
-\r
- \r
- // protected members\r
-\r
- protected internal string pattern;\r
- protected internal RegexOptions roptions;\r
- \r
- // MS undocumented members\r
- [MonoTODO]\r
- protected internal System.Collections.Hashtable capnames;\r
- [MonoTODO]\r
- protected internal System.Collections.Hashtable caps;\r
- [MonoTODO]\r
- protected internal int capsize;\r
- [MonoTODO]\r
- protected internal string[] capslist;\r
- [MonoTODO]\r
- protected internal RegexRunnerFactory factory;\r
- }\r
-\r
- [Serializable]\r
- public class RegexCompilationInfo {\r
- public RegexCompilationInfo (string pattern, RegexOptions options, string name, string nspace, bool isPublic)\r
- {\r
- this.pattern = pattern;\r
- this.options = options;\r
- this.name = name;\r
- this.nspace = nspace;\r
- this.isPublic = isPublic;\r
- }\r
-\r
- public bool IsPublic {\r
- get { return isPublic; }\r
- set { isPublic = value; }\r
- }\r
-\r
- public string Name {\r
- get { return name; }\r
- set { name = value; }\r
- }\r
-\r
- public string Namespace {\r
- get { return nspace; }\r
- set { nspace = value; }\r
- }\r
-\r
- public RegexOptions Options {\r
- get { return options; }\r
- set { options = value; }\r
- }\r
-\r
- public string Pattern {\r
- get { return pattern; }\r
- set { pattern = value; }\r
- }\r
-\r
- // private\r
-\r
- private string pattern, name, nspace;\r
- private RegexOptions options;\r
- private bool isPublic;\r
- }\r
-}\r
System.Text.RegularExpressions/interval.cs
System.Text.RegularExpressions/Match.cs
System.Text.RegularExpressions/MatchCollection.cs
+System.Text.RegularExpressions/MatchEvaluator.cs
System.Text.RegularExpressions/parser.cs
System.Text.RegularExpressions/quicksearch.cs
-System.Text.RegularExpressions/regex.cs
+System.Text.RegularExpressions/Regex.cs
+System.Text.RegularExpressions/RegexCompilationInfo.cs
+System.Text.RegularExpressions/RegexOptions.cs
System.Text.RegularExpressions/RegexRunner.cs
System.Text.RegularExpressions/RegexRunnerFactory.cs
System.Text.RegularExpressions/replace.cs
projects / mono.git / commitdiff