RegExpConstructor.cs 4.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157
  1. using System.Text.RegularExpressions;
  2. using Jint.Native.Function;
  3. using Jint.Native.Object;
  4. using Jint.Native.Symbol;
  5. using Jint.Runtime;
  6. using Jint.Runtime.Descriptors;
  7. using Jint.Runtime.Interop;
  8. namespace Jint.Native.RegExp;
  9. public sealed class RegExpConstructor : Constructor
  10. {
  11. private static readonly JsString _functionName = new JsString("RegExp");
  12. internal RegExpConstructor(
  13. Engine engine,
  14. Realm realm,
  15. FunctionPrototype functionPrototype,
  16. ObjectPrototype objectPrototype)
  17. : base(engine, realm, _functionName)
  18. {
  19. _prototype = functionPrototype;
  20. PrototypeObject = new RegExpPrototype(engine, realm, this, objectPrototype);
  21. _length = new PropertyDescriptor(2, PropertyFlag.Configurable);
  22. _prototypeDescriptor = new PropertyDescriptor(PrototypeObject, PropertyFlag.AllForbidden);
  23. }
  24. internal RegExpPrototype PrototypeObject { get; }
  25. protected override void Initialize()
  26. {
  27. var symbols = new SymbolDictionary(1)
  28. {
  29. [GlobalSymbolRegistry.Species] = new GetSetPropertyDescriptor(get: new ClrFunction(_engine, "get [Symbol.species]", (thisObj, _) => thisObj, 0, PropertyFlag.Configurable), set: Undefined, PropertyFlag.Configurable)
  30. };
  31. SetSymbols(symbols);
  32. }
  33. protected internal override JsValue Call(JsValue thisObject, JsCallArguments arguments)
  34. {
  35. return Construct(arguments, thisObject);
  36. }
  37. public ObjectInstance Construct(JsCallArguments arguments)
  38. {
  39. return Construct(arguments, this);
  40. }
  41. /// <summary>
  42. /// https://tc39.es/ecma262/#sec-regexp-pattern-flags
  43. /// </summary>
  44. public override ObjectInstance Construct(JsCallArguments arguments, JsValue newTarget)
  45. {
  46. var pattern = arguments.At(0);
  47. var flags = arguments.At(1);
  48. var patternIsRegExp = pattern.IsRegExp();
  49. if (newTarget.IsUndefined())
  50. {
  51. newTarget = this;
  52. if (patternIsRegExp && flags.IsUndefined())
  53. {
  54. var patternConstructor = pattern.Get(CommonProperties.Constructor);
  55. if (ReferenceEquals(newTarget, patternConstructor))
  56. {
  57. return (ObjectInstance) pattern;
  58. }
  59. }
  60. }
  61. JsValue p;
  62. JsValue f;
  63. if (pattern is JsRegExp regExpInstance)
  64. {
  65. p = regExpInstance.Source;
  66. f = flags.IsUndefined() ? regExpInstance.Flags : flags;
  67. }
  68. else if (patternIsRegExp)
  69. {
  70. p = pattern.Get(RegExpPrototype.PropertySource);
  71. f = flags.IsUndefined() ? pattern.Get(RegExpPrototype.PropertyFlags) : flags;
  72. }
  73. else
  74. {
  75. p = pattern;
  76. f = flags;
  77. }
  78. var r = RegExpAlloc(newTarget);
  79. return RegExpInitialize(r, p, f);
  80. }
  81. private JsRegExp RegExpInitialize(JsRegExp r, JsValue pattern, JsValue flags)
  82. {
  83. var p = pattern.IsUndefined() ? "" : TypeConverter.ToString(pattern);
  84. if (string.IsNullOrEmpty(p))
  85. {
  86. p = "(?:)";
  87. }
  88. var f = flags.IsUndefined() ? "" : TypeConverter.ToString(flags);
  89. var parserOptions = _engine.GetActiveParserOptions();
  90. try
  91. {
  92. var regExpParseResult = Tokenizer.AdaptRegExp(p, f, compiled: false, parserOptions.RegexTimeout,
  93. ecmaVersion: parserOptions.EcmaVersion,
  94. experimentalESFeatures: parserOptions.ExperimentalESFeatures);
  95. if (!regExpParseResult.Success)
  96. {
  97. ExceptionHelper.ThrowSyntaxError(_realm, $"Unsupported regular expression. {regExpParseResult.ConversionError!.Description}");
  98. }
  99. r.Value = regExpParseResult.Regex!;
  100. r.ParseResult = regExpParseResult;
  101. }
  102. catch (Exception ex)
  103. {
  104. ExceptionHelper.ThrowSyntaxError(_realm, ex.Message);
  105. }
  106. r.Flags = f;
  107. r.Source = p;
  108. RegExpInitialize(r);
  109. return r;
  110. }
  111. private JsRegExp RegExpAlloc(JsValue newTarget)
  112. {
  113. var r = OrdinaryCreateFromConstructor(
  114. newTarget,
  115. static intrinsics => intrinsics.RegExp.PrototypeObject,
  116. static (Engine engine, Realm _, object? _) => new JsRegExp(engine));
  117. return r;
  118. }
  119. public JsRegExp Construct(Regex regExp, string source, string flags, RegExpParseResult regExpParseResult = default)
  120. {
  121. var r = RegExpAlloc(this);
  122. r.Value = regExp;
  123. r.Source = source;
  124. r.Flags = flags;
  125. r.ParseResult = regExpParseResult;
  126. RegExpInitialize(r);
  127. return r;
  128. }
  129. private static void RegExpInitialize(JsRegExp r)
  130. {
  131. r.SetOwnProperty(JsRegExp.PropertyLastIndex, new PropertyDescriptor(0, PropertyFlag.OnlyWritable));
  132. }
  133. }