mcs/class/System/System.Text.RegularExpressions/Regex.cs

   1 //
   2 // assembly:    System
   3 // namespace:   System.Text.RegularExpressions
   4 // file:        regex.cs
   5 //
   6 // author:      Dan Lewis (dlewis@gmx.co.uk)
   7 //              (c) 2002
   8
   9 //
  10 // Permission is hereby granted, free of charge, to any person obtaining
  11 // a copy of this software and associated documentation files (the
  12 // "Software"), to deal in the Software without restriction, including
  13 // without limitation the rights to use, copy, modify, merge, publish,
  14 // distribute, sublicense, and/or sell copies of the Software, and to
  15 // permit persons to whom the Software is furnished to do so, subject to
  16 // the following conditions:
  17 //
  18 // The above copyright notice and this permission notice shall be
  19 // included in all copies or substantial portions of the Software.
  20 //
  21 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  22 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  23 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  24 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  25 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  26 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  27 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  28 //
  29
  30 using System;
  31 using System.Text;
  32 using System.Collections;
  33 using System.Reflection;
  34 using System.Reflection.Emit;
  35 using System.Runtime.Serialization;
  36
  37 using RegularExpression = System.Text.RegularExpressions.Syntax.RegularExpression;
  38 using Parser = System.Text.RegularExpressions.Syntax.Parser;
  39
  40 using System.Diagnostics;
  41
  42
  43 namespace System.Text.RegularExpressions {
  44
  45         [Serializable]
  46         public partial class Regex : ISerializable {
  47
  48 #if NET_2_0
  49                 private static int cache_size = 15;
  50 #endif
  51 #if !TARGET_JVM
  52                 [MonoTODO]
  53                 public static void CompileToAssembly (RegexCompilationInfo [] regexes, AssemblyName aname)
  54                 {
  55                         Regex.CompileToAssembly(regexes, aname, new CustomAttributeBuilder [] {}, null);
  56                 }
  57
  58                 [MonoTODO]
  59                 public static void CompileToAssembly (RegexCompilationInfo [] regexes, AssemblyName aname,
  60                                                       CustomAttributeBuilder [] attribs)
  61                 {
  62                         Regex.CompileToAssembly(regexes, aname, attribs, null);
  63                 }
  64
  65                 [MonoTODO]
  66                 public static void CompileToAssembly (RegexCompilationInfo [] regexes, AssemblyName aname,
  67                                                       CustomAttributeBuilder [] attribs, string resourceFile)
  68                 {
  69                         throw new NotImplementedException ();
  70                         // TODO : Make use of attribs and resourceFile parameters
  71                         /*
  72                         AssemblyBuilder asmBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly (aname, AssemblyBuilderAccess.RunAndSave);
  73                         ModuleBuilder modBuilder = asmBuilder.DefineDynamicModule("InnerRegexModule",aname.Name);
  74                         Parser psr = new Parser ();
  75
  76                         System.Console.WriteLine("CompileToAssembly");
  77
  78                         for(int i=0; i < regexes.Length; i++)
  79                                 {
  80                                         System.Console.WriteLine("Compiling expression :" + regexes[i].Pattern);
  81                                         RegularExpression re = psr.ParseRegularExpression (regexes[i].Pattern, regexes[i].Options);
  82
  83                                         // compile
  84
  85                                         CILCompiler cmp = new CILCompiler (modBuilder, i);
  86                                         bool reverse = (regexes[i].Options & RegexOptions.RightToLeft) !=0;
  87                                         re.Compile (cmp, reverse);
  88                                         cmp.Close();
  89
  90                                 }
  91
  92
  93                         // Define a runtime class with specified name and attributes.
  94                         TypeBuilder builder = modBuilder.DefineType("ITest");
  95                         builder.CreateType();
  96                         asmBuilder.Save(aname.Name);
  97                         */
  98                 }
  99 #endif
 100
 101                 public static string Escape (string str)
 102                 {
 103                         return Parser.Escape (str);
 104                 }
 105
 106                 public static string Unescape (string str)
 107                 {
 108                         return Parser.Unescape (str);
 109                 }
 110
 111                 public static bool IsMatch (string input, string pattern)
 112                 {
 113                         return IsMatch (input, pattern, RegexOptions.None);
 114                 }
 115
 116                 public static bool IsMatch (string input, string pattern, RegexOptions options)
 117                 {
 118                         Regex re = new Regex (pattern, options);
 119                         return re.IsMatch (input);
 120                 }
 121
 122                 public static Match Match (string input, string pattern)
 123                 {
 124                         return Regex.Match (input, pattern, RegexOptions.None);
 125                 }
 126
 127                 public static Match Match (string input, string pattern, RegexOptions options)
 128                 {
 129                         Regex re = new Regex (pattern, options);
 130                         return re.Match (input);
 131                 }
 132
 133                 public static MatchCollection Matches (string input, string pattern)
 134                 {
 135                         return Matches (input, pattern, RegexOptions.None);
 136                 }
 137
 138                 public static MatchCollection Matches (string input, string pattern, RegexOptions options)
 139                 {
 140                         Regex re = new Regex (pattern, options);
 141                         return re.Matches (input);
 142                 }
 143
 144                 public static string Replace (string input, string pattern, MatchEvaluator evaluator)
 145                 {
 146                         return Regex.Replace (input, pattern, evaluator, RegexOptions.None);
 147                 }
 148
 149                 public static string Replace (string input, string pattern, MatchEvaluator evaluator,
 150                                               RegexOptions options)
 151                 {
 152                         Regex re = new Regex (pattern, options);
 153                         return re.Replace (input, evaluator);
 154                 }
 155
 156                 public static string Replace (string input, string pattern, string replacement)
 157                 {
 158                         return Regex.Replace (input, pattern, replacement, RegexOptions.None);
 159                 }
 160
 161                 public static string Replace (string input, string pattern, string replacement,
 162                                               RegexOptions options)
 163                 {
 164                         Regex re = new Regex (pattern, options);
 165                         return re.Replace (input, replacement);
 166                 }
 167
 168                 public static string [] Split (string input, string pattern)
 169                 {
 170                         return Regex.Split (input, pattern, RegexOptions.None);
 171                 }
 172
 173                 public static string [] Split (string input, string pattern, RegexOptions options)
 174                 {
 175                         Regex re = new Regex (pattern, options);
 176                         return re.Split (input);
 177                 }
 178
 179 #if NET_2_0
 180                 [MonoTODO ("should be used somewhere ? FactoryCache ?")]
 181                 public static int CacheSize {
 182                         get { return cache_size; }
 183                         set {
 184                                 if (value < 0)
 185                                         throw new ArgumentOutOfRangeException ("CacheSize");
 186                                 cache_size = value;
 187                         }
 188                 }
 189 #endif
 190
 191                 // private
 192
 193                 private static FactoryCache cache = new FactoryCache (200);     // TODO put some meaningful number here
 194
 195                 // constructors
 196
 197                 // This constructor is used by compiled regular expressions that are
 198                 // classes derived from Regex class. No initialization required.
 199                 protected Regex ()
 200                 {
 201                 }
 202
 203                 public Regex (string pattern) : this (pattern, RegexOptions.None)
 204                 {
 205                 }
 206
 207                 public Regex (string pattern, RegexOptions options)
 208                 {
 209                         this.pattern = pattern;
 210                         this.roptions = options;
 211                         Init ();
 212                 }
 213 #if !TARGET_JVM
 214                 private void Init ()
 215                 {
 216                         this.machineFactory = cache.Lookup (this.pattern, this.roptions);
 217
 218                         if (this.machineFactory == null) {
 219                                 InitNewRegex();
 220                         } else {
 221                                 this.group_count = this.machineFactory.GroupCount;
 222                                 this.mapping = this.machineFactory.Mapping;
 223                                 this._groupNumberToNameMap = this.machineFactory.NamesMapping;
 224                         }
 225                 }
 226 #endif
 227
 228                 private void InitNewRegex ()
 229                 {
 230                         this.machineFactory = CreateMachineFactory (this.pattern, this.roptions);
 231                         this.group_count = machineFactory.GroupCount;
 232                         this.mapping = machineFactory.Mapping;
 233                         this._groupNumberToNameMap = this.machineFactory.NamesMapping;
 234                 }
 235
 236                 private static IMachineFactory CreateMachineFactory (string pattern, RegexOptions options)
 237                 {
 238                         Parser psr = new Parser ();
 239                         RegularExpression re = psr.ParseRegularExpression (pattern, options);
 240
 241                         ICompiler cmp;
 242                         //if ((options & RegexOptions.Compiled) != 0)
 243                         //      //throw new Exception ("Not implemented.");
 244                         //      cmp = new CILCompiler ();
 245                         //else
 246                         cmp = new PatternCompiler ();
 247
 248                         re.Compile (cmp, (options & RegexOptions.RightToLeft) != 0);
 249
 250                         IMachineFactory machineFactory = cmp.GetMachineFactory ();
 251                         machineFactory.Mapping = psr.GetMapping ();
 252                         machineFactory.NamesMapping = GetGroupNamesArray (machineFactory.GroupCount, machineFactory.Mapping);
 253
 254                         return machineFactory;
 255                 }
 256
 257 #if NET_2_0
 258                 protected
 259 #else
 260                 private
 261 #endif
 262                 Regex (SerializationInfo info, StreamingContext context) :
 263                         this (info.GetString ("pattern"),
 264                               (RegexOptions) info.GetValue ("options", typeof (RegexOptions)))
 265                 {
 266                 }
 267
 268 #if ONLY_1_1 && !TARGET_JVM
 269                 // fixes public API signature
 270                 ~Regex ()
 271                 {
 272                 }
 273 #endif
 274                 // public instance properties
 275
 276                 public RegexOptions Options {
 277                         get { return roptions; }
 278                 }
 279
 280                 public bool RightToLeft {
 281                         get { return (roptions & RegexOptions.RightToLeft) != 0; }
 282                 }
 283
 284                 // public instance methods
 285
 286                 public string [] GetGroupNames ()
 287                 {
 288                         string [] names = new string [mapping.Count];
 289                         mapping.Keys.CopyTo (names, 0);
 290
 291                         return names;
 292                 }
 293
 294                 public int[] GetGroupNumbers ()
 295                 {
 296                         int[] numbers = new int [mapping.Count];
 297                         mapping.Values.CopyTo (numbers, 0);
 298
 299                         return numbers;
 300                 }
 301
 302                 public string GroupNameFromNumber (int i)
 303                 {
 304                         if (i < 0 || i > group_count)
 305                                 return "";
 306
 307                         return _groupNumberToNameMap [i];
 308                 }
 309
 310                 public int GroupNumberFromName (string name)
 311                 {
 312                         if (mapping.Contains (name))
 313                                 return (int) mapping [name];
 314
 315                         return -1;
 316                 }
 317
 318                 // match methods
 319
 320                 public bool IsMatch (string input)
 321                 {
 322                         return IsMatch (input, RightToLeft ? input.Length : 0);
 323                 }
 324
 325                 public bool IsMatch (string input, int startat)
 326                 {
 327                         return Match (input, startat).Success;
 328                 }
 329
 330                 public Match Match (string input)
 331                 {
 332                         return Match (input, RightToLeft ? input.Length : 0);
 333                 }
 334
 335                 public Match Match (string input, int startat)
 336                 {
 337                         return CreateMachine ().Scan (this, input, startat, input.Length);
 338                 }
 339
 340                 public Match Match (string input, int startat, int length)
 341                 {
 342                         return CreateMachine ().Scan (this, input, startat, startat + length);
 343                 }
 344
 345                 public MatchCollection Matches (string input)
 346                 {
 347                         return Matches (input, RightToLeft ? input.Length : 0);
 348                 }
 349
 350                 public MatchCollection Matches (string input, int startat)
 351                 {
 352                         Match m = Match (input, startat);
 353                         return new MatchCollection (m);
 354                 }
 355
 356                 // replace methods
 357
 358                 public string Replace (string input, MatchEvaluator evaluator)
 359                 {
 360                         return Replace (input, evaluator, Int32.MaxValue, RightToLeft ? input.Length : 0);
 361                 }
 362
 363                 public string Replace (string input, MatchEvaluator evaluator, int count)
 364                 {
 365                         return Replace (input, evaluator, count, RightToLeft ? input.Length : 0);
 366                 }
 367
 368                 class Adapter {
 369                         MatchEvaluator ev;
 370                         public Adapter (MatchEvaluator ev) { this.ev = ev; }
 371                         public void Evaluate (Match m, StringBuilder sb) { sb.Append (ev (m)); }
 372                 }
 373
 374                 public string Replace (string input, MatchEvaluator evaluator, int count, int startat)
 375                 {
 376                         BaseMachine m = (BaseMachine)CreateMachine ();
 377
 378                         if (RightToLeft)
 379                                 return m.RTLReplace (this, input, evaluator, count, startat);
 380
 381                         // NOTE: If this is a cause of a lot of allocations, we can convert it to
 382                         //       use a ThreadStatic allocation mitigator
 383                         Adapter a = new Adapter (evaluator);
 384
 385                         return m.LTRReplace (this, input, new BaseMachine.MatchAppendEvaluator (a.Evaluate),
 386                                                                  count, startat);
 387                 }
 388
 389                 public string Replace (string input, string replacement)
 390                 {
 391                         return Replace (input, replacement, Int32.MaxValue, RightToLeft ? input.Length : 0);
 392                 }
 393
 394                 public string Replace (string input, string replacement, int count)
 395                 {
 396                         return Replace (input, replacement, count, RightToLeft ? input.Length : 0);
 397                 }
 398
 399                 public string Replace (string input, string replacement, int count, int startat)
 400                 {
 401                         return CreateMachine ().Replace (this, input, replacement, count, startat);
 402                 }
 403
 404                 // split methods
 405
 406                 public string [] Split (string input)
 407                 {
 408                         return Split (input, Int32.MaxValue, RightToLeft ? input.Length : 0);
 409                 }
 410
 411                 public string [] Split (string input, int count)
 412                 {
 413                         return Split (input, count, RightToLeft ? input.Length : 0);
 414                 }
 415
 416                 public string [] Split (string input, int count, int startat)
 417                 {
 418                         return CreateMachine ().Split (this, input, count, startat);
 419                 }
 420
 421                 // This method is called at the end of the constructor of compiled
 422                 // regular expression classes to do internal initialization.
 423                 protected void InitializeReferences ()
 424                 {
 425                         if (refsInitialized)
 426                                 throw new NotSupportedException ("This operation is only allowed once per object.");
 427
 428                         refsInitialized = true;
 429
 430                         // Compile pattern that results in performance loss as existing
 431                         // CIL code is ignored but provides support for regular
 432                         // expressions compiled to assemblies.
 433                         Init ();
 434                 }
 435
 436                 protected bool UseOptionC ()
 437                 {
 438                         return ((roptions & RegexOptions.Compiled) != 0);
 439                 }
 440
 441                 protected bool UseOptionR ()
 442                 {
 443                         return ((roptions & RegexOptions.RightToLeft) != 0);
 444                 }
 445
 446                 // object methods
 447
 448                 public override string ToString ()
 449                 {
 450                         return pattern;
 451                 }
 452
 453                 // ISerializable interface
 454                 void ISerializable.GetObjectData (SerializationInfo info, StreamingContext context)
 455                 {
 456                         info.AddValue ("pattern", this.ToString (), typeof (string));
 457                         info.AddValue ("options", this.Options, typeof (RegexOptions));
 458                 }
 459
 460                 // internal
 461
 462                 internal int GroupCount {
 463                         get { return group_count; }
 464                 }
 465
 466                 // private
 467
 468                 private IMachine CreateMachine ()
 469                 {
 470                         return machineFactory.NewInstance ();
 471                 }
 472
 473                 private static string [] GetGroupNamesArray (int groupCount, IDictionary mapping)
 474                 {
 475                         string [] groupNumberToNameMap = new string [groupCount + 1];
 476                         foreach (string name in mapping.Keys) {
 477                                 groupNumberToNameMap [(int) mapping [name]] = name;
 478                         }
 479                         return groupNumberToNameMap;
 480                 }
 481
 482                 private IMachineFactory machineFactory;
 483                 private IDictionary mapping;
 484                 private int group_count;
 485                 private bool refsInitialized;
 486                 private string [] _groupNumberToNameMap;
 487
 488
 489                 // protected members
 490
 491                 protected internal string pattern;
 492                 protected internal RegexOptions roptions;
 493
 494                 // MS undocumented members
 495 #if NET_2_1
 496                 [MonoTODO]
 497                 protected internal System.Collections.Generic.Dictionary<string, int> capnames;
 498                 [MonoTODO]
 499                 protected internal System.Collections.Generic.Dictionary<int, int> caps;
 500 #else
 501                 [MonoTODO]
 502                 protected internal System.Collections.Hashtable capnames;
 503                 [MonoTODO]
 504                 protected internal System.Collections.Hashtable caps;
 505 #endif
 506                 [MonoTODO]
 507                 protected internal int capsize;
 508                 [MonoTODO]
 509                 protected internal string [] capslist;
 510                 [MonoTODO]
 511                 protected internal RegexRunnerFactory factory;
 512         }
 513 }