* 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,
+ DoubleConverterTests.cs, Int64ConverterTests.cs, SByteConverterTests.cs
+ SingleConverterTests.cs, UInt16ConverterTests.cs,
+ UInt32ConverterTests.cs, UInt64ConverterTests.cs.
+
2005-08-16 Gert Driesen <drieseng@users.sourceforge.net>
* System_test.dll.sources: Added ByteConverterTests.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
--- /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
--- /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
--- /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
--- /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