/// <summary>
/// Implements <c>+</c> operator on values.
/// </summary>
public static PhpArray Add(PhpArray x, PhpValue y)
{
var arr = y.AsArray(); // array or &array
if (arr != null)
{
return(PhpArray.Union(x, arr));
}
//PhpException.UnsupportedOperandTypes();
//return 0;
throw new ArgumentException(); // TODO: ErrCode & return 0
}
/// <summary>
/// Implements <c>+</c> operator for unconvertible values or arrays.
/// </summary>
static PhpValue AddNonNumbers(ref PhpValue x, ref PhpValue y)
{
var arr_x = x.AsArray();
var arr_y = y.AsArray();
if (arr_x != null && arr_y != null)
{
return((PhpValue)PhpArray.Union(arr_x, arr_y));
}
//PhpException.UnsupportedOperandTypes();
//return 0;
throw new ArgumentException(); // TODO: ErrCode & return 0
}
/// <summary>
/// Perform a regular expression search and replace.
/// </summary>
/// <param name="ctx">A reference to current context. Cannot be <c>null</c>.</param>
/// <param name="pattern">The pattern to search for. It can be either a string or an array with strings.</param>
/// <param name="replacement">The string or an array with strings to replace.
/// If this parameter is a string and the pattern parameter is an array, all patterns will be
/// replaced by that string. If both pattern and replacement parameters are arrays, each pattern will be
/// replaced by the replacement counterpart. If there are fewer elements in the replacement array than
/// in the pattern array, any extra patterns will be replaced by an empty string.</param>
/// <param name="subject">The string or an array with strings to search and replace.
/// If subject is an array, then the search and replace is performed on every entry of subject, and the return value is an array as well.</param>
/// <param name="limit">The maximum possible replacements for each pattern in each subject string. Defaults to <c>-1</c> (no limit).</param>
/// <param name="count">This variable will be filled with the number of replacements done.</param>
/// <returns></returns>
public static PhpValue preg_replace(Context ctx, PhpValue pattern, PhpValue replacement, PhpValue subject, int limit, out long count)
{
count = 0;
// PHP's behaviour for undocumented limit range
if (limit < -1)
{
limit = 0;
}
//
var replacement_array = replacement.AsArray();
var pattern_array = pattern.AsArray();
if (pattern_array == null)
{
if (replacement_array == null)
{
// string pattern
// string replacement
return preg_replace(ctx, pattern.ToStringOrThrow(ctx), replacement.ToStringOrThrow(ctx), null, subject, limit, ref count);
}
else
{
// string pattern and array replacement not allowed:
throw new ArgumentException("replacement_array_pattern_not", nameof(replacement));
// return PhpValue.Null;
}
}
else if (replacement_array == null)
{
// array pattern
// string replacement
}
else
{
// array pattern
// array replacement
}
throw new NotImplementedException();
}
static PhpValue preg_replace(Context ctx, string pattern, string replacement, PhpCallable callback, PhpValue subject, int limit, ref long count)
{
var regex = new PerlRegex.Regex(pattern);
// TODO: count
// TODO: callback
var subject_array = subject.AsArray();
if (subject_array == null)
{
return PhpValue.Create(regex.Replace(subject.ToStringOrThrow(ctx), replacement, limit));
}
else
{
var arr = new PhpArray(subject_array, false);
var enumerator = arr.GetFastEnumerator();
while (enumerator.MoveNext())
{
var newvalue = regex.Replace(enumerator.CurrentValue.ToStringOrThrow(ctx), replacement, limit);
enumerator.CurrentValue = PhpValue.Create(newvalue);
}
return PhpValue.Create(arr);
}
}
/// <summary> /// Casts value to <see cref="PhpArray"/> or <c>null</c>. /// </summary> public static PhpArray AsArray(PhpValue value) => value.AsArray();
/// <summary> /// Checks the value is of type <c>string</c> or <c>&string</c> and gets its value. /// Single-byte strings are decoded using <c>UTF-8</c>. /// </summary> public static bool IsPhpArray(this PhpValue value, out PhpArray array) => (array = value.AsArray()) != null;
/// <summary> /// Gets the array access object. /// </summary> public static object AsArray(PhpValue value) => value.AsArray();
/// <summary>
/// Sets variable's type.
/// </summary>
/// <param name="ctx">Current runtime context.</param>
/// <param name="variable">The variable.</param>
/// <param name="type">The string identifying a new type. See PHP manual for details.</param>
/// <returns>Whether <paramref name="type"/> is valid type identifier.</returns>
/// <exception cref="PhpException"><paramref name="type"/> has invalid value.</exception>
public static bool settype(Context ctx, ref PhpValue variable, string type)
{
switch (type.ToLowerInvariant())
{
case "bool":
case "boolean":
variable = PhpValue.Create(variable.ToBoolean());
return true;
case "int":
case "integer":
variable = PhpValue.Create(variable.ToLong());
return true;
case "float":
case "double":
variable = PhpValue.Create(variable.ToDouble());
return true;
case "string":
variable = PhpValue.Create(variable.ToString(ctx));
return true;
case "array":
variable = PhpValue.Create(variable.AsArray());
return true;
case "object":
variable = PhpValue.FromClass(variable.ToClass());
return true;
case "null":
variable = PhpValue.Null;
return true;
}
//PhpException.InvalidArgument("type", LibResources.GetString("invalid_type_name"));
//return false;
throw new ArgumentException(nameof(type));
}
public static bool IsPhpArray(this PhpValue value, /*[MaybeNullWhen(false)]*/ out PhpArray?array) => (array = value.AsArray()) != null; // TODO: STANDARD21