public static object Search(ScriptEngine engine, object thisObject, object substrOrRegExp)
{
if (thisObject == Null.Value || thisObject == Undefined.Value)
{
throw new JavaScriptException(ErrorType.TypeError, "String.prototype.search called on null or undefined.");
}
if (substrOrRegExp != Null.Value && substrOrRegExp != Undefined.Value)
{
// Get the [Symbol.search] property value.
var matchFunctionObj = TypeConverter.ToObject(engine, substrOrRegExp)[Symbol.Search];
if (matchFunctionObj != Undefined.Value)
{
// If it's a function, call it and return the result.
if (matchFunctionObj is FunctionInstance matchFunction)
{
return(matchFunction.CallLateBound(substrOrRegExp, thisObject));
}
else
{
throw new JavaScriptException(ErrorType.TypeError, "Symbol.search value is not a function.");
}
}
}
// Convert the argument to a regex.
var regex = new RegExpInstance(engine.RegExp.InstancePrototype, TypeConverter.ToString(substrOrRegExp, string.Empty));
// Call the [Symbol.search] function.
return(regex.Search(TypeConverter.ToString(thisObject)));
}
// INITIALIZATION
//_________________________________________________________________________________________
/// <summary>
/// Creates a new RegExp object.
/// </summary>
/// <param name="prototype"> The next object in the prototype chain. </param>
internal RegExpConstructor(ObjectInstance prototype)
: base(prototype, __STUB__Construct, __STUB__Call)
{
// Initialize the constructor properties.
var properties = GetDeclarativeProperties(Engine);
InitializeConstructorProperties(properties, "RegExp", 2, RegExpInstance.CreatePrototype(Engine, this));
AddDeprecatedProperties(properties);
InitializeProperties(properties);
}
/// <summary>
/// Creates a new regular expression instance by copying the pattern and flags from another
/// RegExp instance.
/// </summary>
/// <param name="prototype"> The next object in the prototype chain. </param>
/// <param name="existingInstance"> The instance to copy the pattern and flags from. </param>
internal RegExpInstance(ObjectInstance prototype, RegExpInstance existingInstance)
: base(prototype)
{
if (existingInstance == null)
throw new ArgumentNullException("existingInstance");
this.value = existingInstance.value;
this.globalSearch = existingInstance.globalSearch;
// Initialize the javascript properties.
FastSetProperty("lastIndex", 0.0, PropertyAttributes.Writable);
}
/// <summary>
/// Creates a new regular expression instance by copying the pattern and flags from another
/// RegExp instance.
/// </summary>
/// <param name="prototype"> The next object in the prototype chain. </param>
/// <param name="existingInstance"> The instance to copy the pattern and flags from. </param>
internal RegExpInstance(ObjectInstance prototype, RegExpInstance existingInstance)
: base(prototype)
{
if (existingInstance == null)
{
throw new ArgumentNullException("existingInstance");
}
this.value = existingInstance.value;
this.globalSearch = existingInstance.globalSearch;
// Initialize the javascript properties.
FastSetProperty("lastIndex", 0.0, PropertyAttributes.Writable);
}
/// <summary>
/// Creates a new regular expression instance by copying the pattern and flags from another
/// RegExp instance.
/// </summary>
/// <param name="prototype"> The next object in the prototype chain. </param>
/// <param name="existingInstance"> The instance to copy the pattern and flags from. </param>
internal RegExpInstance(ObjectInstance prototype, RegExpInstance existingInstance)
: base(prototype)
{
if (existingInstance == null)
{
throw new ArgumentNullException(nameof(existingInstance));
}
this.value = existingInstance.value;
this.globalSearch = existingInstance.globalSearch;
// Initialize the javascript properties.
InitializeProperties(new PropertyNameAndValue[]
{
new PropertyNameAndValue("lastIndex", 0.0, PropertyAttributes.Writable),
});
}
/// <summary>
/// Splits this string into an array of strings by separating the string into substrings.
/// </summary>
/// <param name="regExp"> A regular expression that indicates where to split the string. </param>
/// <param name="limit"> The maximum number of array items to return. Defaults to unlimited. </param>
/// <returns> An array containing the split strings. </returns>
public static ArrayInstance Split(string thisObject, RegExpInstance regExp, [DefaultParameterValue(uint.MaxValue)] uint limit = uint.MaxValue)
{
return regExp.Split(thisObject, limit);
}
/// <summary>
/// Returns a copy of this string with text replaced using a regular expression and a
/// replacement function.
/// </summary>
/// <param name="regExp"> The regular expression to search for. </param>
/// <param name="replaceFunction"> A function that is called to produce the text to replace
/// for every successful match. </param>
/// <returns> A copy of this string with text replaced using a regular expression. </returns>
public static string Replace(string thisObject, RegExpInstance regExp, FunctionInstance replaceFunction)
{
return regExp.Replace(thisObject, replaceFunction);
}
/// <summary>
/// Returns a copy of this string with text replaced using a regular expression.
/// </summary>
/// <param name="regExp"> The regular expression to search for. </param>
/// <param name="replaceText"> A string containing the text to replace for every successful match. </param>
/// <returns> A copy of this string with text replaced using a regular expression. </returns>
public static string Replace(string thisObject, RegExpInstance regExp, string replaceText)
{
return regExp.Replace(thisObject, replaceText);
}
/// <summary>
/// Splits this string into an array of strings by separating the string into substrings.
/// </summary>
/// <param name="thisObject"> The string that is being operated on. </param>
/// <param name="regExp"> A regular expression that indicates where to split the string. </param>
/// <param name="limit"> The maximum number of array items to return. Defaults to unlimited. </param>
/// <returns> An array containing the split strings. </returns>
public static ArrayInstance Split(string thisObject, RegExpInstance regExp, uint limit = uint.MaxValue)
{
return(regExp.Split(thisObject, limit));
}
/// <summary>
/// Returns a copy of this string with text replaced using a regular expression and a
/// replacement function.
/// </summary>
/// <param name="thisObject"> The string that is being operated on. </param>
/// <param name="regExp"> The regular expression to search for. </param>
/// <param name="replaceFunction"> A function that is called to produce the text to replace
/// for every successful match. </param>
/// <returns> A copy of this string with text replaced using a regular expression. </returns>
public static string Replace(string thisObject, RegExpInstance regExp, FunctionInstance replaceFunction)
{
return(regExp.Replace(thisObject, replaceFunction));
}
/// <summary>
/// Returns a copy of this string with text replaced using a regular expression.
/// </summary>
/// <param name="thisObject"> The string that is being operated on. </param>
/// <param name="regExp"> The regular expression to search for. </param>
/// <param name="replaceText"> A string containing the text to replace for every successful match. </param>
/// <returns> A copy of this string with text replaced using a regular expression. </returns>
public static string Replace(string thisObject, RegExpInstance regExp, string replaceText)
{
return(regExp.Replace(thisObject, replaceText));
}
/// <summary>
/// Splits this string into an array of strings by separating the string into substrings.
/// </summary>
/// <param name="regExp"> A regular expression that indicates where to split the string. </param>
/// <param name="limit"> The maximum number of array items to return. Defaults to unlimited. </param>
/// <returns> An array containing the split strings. </returns>
public static ArrayInstance Split(string thisObject, RegExpInstance regExp, [DefaultParameterValue(uint.MaxValue)] uint limit = uint.MaxValue)
{
return(regExp.Split(thisObject, limit));
}
/// <summary>
/// Splits this string into an array of strings by separating the string into substrings.
/// </summary>
/// <param name="thisObject"> The string that is being operated on. </param>
/// <param name="regExp"> A regular expression that indicates where to split the string. </param>
/// <param name="limit"> The maximum number of array items to return. Defaults to unlimited. </param>
/// <returns> An array containing the split strings. </returns>
public static ArrayInstance Split(string thisObject, RegExpInstance regExp, uint limit = uint.MaxValue)
{
return regExp.Split(thisObject, limit);
}
