public RegularExpression(List<Expression>/*!*/ pattern, RubyRegexOptions options, bool isCondition, SourceSpan location)
            : base(location) {
            Assert.NotNull(pattern);

            _pattern = pattern;
            _options = options;
        }

 internal static string Transform(string/*!*/ rubyPattern, RubyRegexOptions options) {
     if (rubyPattern == "\\Af(?=[[:xdigit:]]{2}+\\z)") {
         // pp.rb uses this pattern. The real fix requires cracking the entire regexp and so is left for later
         return "\\Af(?=(?:[[:xdigit:]]{2})+\\z)";
     }
     RegexpTransformer transformer = new RegexpTransformer(rubyPattern);
     return transformer.Transform();
 }

 internal static string Transform(string/*!*/ rubyPattern, RubyRegexOptions options, out bool hasGAnchor) {
     if (rubyPattern == "\\Af(?=[[:xdigit:]]{2}+\\z)") {
         // pp.rb uses this pattern. The real fix requires cracking the entire regexp and so is left for later
         hasGAnchor = false;
         return "\\Af(?=(?:[[:xdigit:]]{2})+\\z)";
     }
     RegexpTransformer transformer = new RegexpTransformer(rubyPattern);
     var result = transformer.Transform();
     hasGAnchor = transformer._hasGAnchor;
     return result;
 }

 internal static string Transform(string/*!*/ rubyPattern, RubyRegexOptions options, out bool hasGAnchor) {
     // TODO: surrogates (REXML uses this pattern)
     if (rubyPattern == "^[\t\n\r -\uD7FF\uE000-\uFFFD\uD800\uDC00-\uDBFF\uDFFF]*$") {
         hasGAnchor = false;
         return "^(?:[\t\n\r -\uD7FF\uE000-\uFFFD]|[\uD800-\uDBFF][\uDC00-\uDFFF])*$";
     }
     
     RegexpTransformer transformer = new RegexpTransformer(rubyPattern);
     var result = transformer.Transform();
     hasGAnchor = transformer._hasGAnchor;
     return result;
 }

        private static RubyRegex/*!*/ CreateRegexWorker(
            RubyRegexOptions options, 
            StrongBox<RubyRegex> regexpCache, 
            bool isLiteralWithoutSubstitutions,
            Func<RubyRegex> createRegex) {

            try {
                bool once = ((options & RubyRegexOptions.Once) == RubyRegexOptions.Once) || isLiteralWithoutSubstitutions;
                if (once) {
                    // Note that the user is responsible for thread synchronization
                    if (regexpCache.Value == null) {
                        regexpCache.Value = createRegex();
                    }
                    return regexpCache.Value;
                } else {
                    // In the future, we can consider caching the last Regexp. For some regexp literals 
                    // with substitution, the substition will be the same most of the time
                    return createRegex();
                }
            } catch (RegexpError e) {
                if (isLiteralWithoutSubstitutions) {
                    // Ideally, this should be thrown during parsing of the source, even if the 
                    // expression happens to be unreachable at runtime.
                    throw new SyntaxError(e.Message);
                } else {
                    throw;
                }
            }
        }

 public static RubyRegex/*!*/ CreateRegexN(object[]/*!*/ strings, RubyEncoding/*!*/ encoding, RubyRegexOptions options, StrongBox<RubyRegex> regexpCache) {
     Func<RubyRegex> createRegex = delegate { return new RubyRegex(CreateMutableStringN(strings, encoding), options); };
     return CreateRegexWorker(options, regexpCache, false, createRegex);
 }

 internal static string/*!*/ TransformPattern(string/*!*/ pattern, RubyRegexOptions options) {
     return RegexpTransformer.Transform(pattern, options);
 }

 protected GenericRegex(RubyRegexOptions options) {
     ContractUtils.Requires(RubyRegex.GetPersistedOptions(options) == options);
     _options = options;
 }

 public override GenericRegex/*!*/ ToRegularExpression(RubyRegexOptions options) {
     // TODO: Fix BinaryRegex and use instead
     return new StringRegex(ToString(), options);
 }

 public static RubyRegex/*!*/ CreateRegexM(MutableString str1, RubyRegexOptions options) {
     return new RubyRegex(MutableString.CreateInternal(str1), options);
 }

 internal void SetRegexOptions(RubyRegexOptions value) {
     Integer1 = (int)value;
 }

 public static RubyRegex/*!*/ CreateRegexU(string/*!*/ str1, RubyRegexOptions options) {
     return new RubyRegex(str1, options);
 }

 public static RubyRegex/*!*/ CreateRegexE(string/*!*/ str1, int codepage, RubyRegexOptions options) {
     return new RubyRegex(str1, options);
 }

 public static RubyRegex/*!*/ CreateRegexN(object[]/*!*/ strings, int codepage, RubyRegexOptions options) {
     return new RubyRegex(ConcatenateStrings(strings), options);
 }

 public static RubyRegex/*!*/ CreateRegexME(MutableString str1, string/*!*/ str2, int codepage, RubyRegexOptions options) {
     return new RubyRegex(MutableString.CreateInternal(str1).Append(str2), options);
 }

 public static RubyRegex/*!*/ CreateRegexUM(string/*!*/ str1, MutableString str2, RubyRegexOptions options) {
     return new RubyRegex(MutableString.Create(str1).Append(str2), options);
 }

 private RegexpTransformer(string/*!*/ rubyPattern, RubyRegexOptions options) {
     _rubyPattern = rubyPattern;
     _options = options;
 }

 //[DebuggerHidden]
 private void TestCorrectPatternTranslation(string/*!*/ pattern, RubyRegexOptions options, string/*!*/ expected, bool expectedGAnchor, IList<string> expectedWarnings)
 {
     bool hasGAnchor;
     List<string> warnings;
     string actual = RegexpTransformer.Transform(pattern, options, out hasGAnchor, out warnings);
     AreEqual(expected, actual);
     new Regex(expected);
     Assert(hasGAnchor == expectedGAnchor);
     if (warnings != null) {
         Assert(expectedWarnings != null);
         Assert(expectedWarnings.Count == warnings.Count);
         foreach (var warning in expectedWarnings) {
             Assert(warnings.IndexOf(warning) >= 0);
         }
     } else {
         Assert(expectedWarnings == null || expectedWarnings.Count == 0);
     }
 }

        public static RubyEncoding GetKCoding(RubyRegexOptions options) {
#if SILVERLIGHT
            return null;
#else
            switch (options & RubyRegexOptions.EncodingMask) {
                case RubyRegexOptions.EUC: return RubyEncoding.KCodeEUC;
                case RubyRegexOptions.SJIS: return RubyEncoding.KCodeSJIS;
                case RubyRegexOptions.UTF8: return RubyEncoding.KCodeUTF8;
                default: return null;
            }
#endif
        }

 public abstract GenericRegex/*!*/ ToRegularExpression(RubyRegexOptions options);