/// <summary>
/// Performs bitwise negation.
/// </summary>
internal static PhpValue BitNot(ref PhpValue x)
{
switch (x.TypeCode)
{
case PhpTypeCode.Long: return(PhpValue.Create(~x.Long));
case PhpTypeCode.Int32: return(PhpValue.Create(~x.ToLong()));
case PhpTypeCode.Alias: return(BitNot(ref x.Alias.Value));
case PhpTypeCode.String:
case PhpTypeCode.WritableString:
throw new NotImplementedException(); // bitwise negation of each character in string
case PhpTypeCode.Object:
if (x.Object == null)
{
return(PhpValue.Null);
}
goto default;
default:
// TODO: Err UnsupportedOperandTypes
return(PhpValue.Null);
}
}
/// <summary>
/// Performs bitwise negation.
/// </summary>
internal static PhpValue BitNot(ref PhpValue x)
{
switch (x.TypeCode)
{
case PhpTypeCode.Long: return PhpValue.Create(~x.Long);
case PhpTypeCode.Int32: return PhpValue.Create(~x.ToLong());
case PhpTypeCode.Alias: return BitNot(ref x.Alias.Value);
case PhpTypeCode.String:
case PhpTypeCode.WritableString:
throw new NotImplementedException(); // bitwise negation of each character in string
case PhpTypeCode.Object:
if (x.Object == null)
{
return PhpValue.Null;
}
goto default;
default:
// TODO: Err UnsupportedOperandTypes
return PhpValue.Null;
}
}
/// <summary>
/// Performs bitwise or operation.
/// </summary>
internal static PhpValue BitOr(ref PhpValue x, ref PhpValue y)
{
var bx = x.ToBytesOrNull();
if (bx != null)
{
var by = y.ToBytesOrNull();
if (by != null)
{
throw new NotImplementedException();
}
}
//
return PhpValue.Create(x.ToLong() | y.ToLong());
}
static int ProcessStatus(Context ctx, PhpValue status)
{
switch (status.TypeCode)
{
case PhpTypeCode.Alias:
return ProcessStatus(ctx, status.Alias.Value);
case PhpTypeCode.Long:
return (int)status.ToLong();
default:
ctx?.Echo(status);
return 0;
}
}
/// <summary>
/// Performs bitwise or operation.
/// </summary>
internal static PhpValue BitOr(ref PhpValue x, ref PhpValue y)
{
var xtype = x.TypeCode;
if (xtype == PhpTypeCode.String || xtype == PhpTypeCode.WritableString)
{
var ytype = y.TypeCode;
if (ytype == PhpTypeCode.String || ytype == PhpTypeCode.WritableString)
{
throw new NotImplementedException();
}
}
//
return PhpValue.Create(x.ToLong() | y.ToLong());
}
/// <summary>
/// Performs exclusive or operation.
/// </summary>
internal static PhpValue BitXor(ref PhpValue x, ref PhpValue y)
{
var bx = x.ToBytesOrNull();
if (bx != null)
{
var by = y.ToBytesOrNull();
if (by != null)
{
return PhpValue.Create(new PhpString(BitXor(bx, by)));
}
}
//
return PhpValue.Create(x.ToLong() ^ y.ToLong());
}
/// <summary>
/// Performs bitwise or operation.
/// </summary>
internal static PhpValue BitOr(ref PhpValue x, ref PhpValue y)
{
var xtype = x.TypeCode;
if (xtype == PhpTypeCode.String || xtype == PhpTypeCode.WritableString)
{
var ytype = y.TypeCode;
if (ytype == PhpTypeCode.String || ytype == PhpTypeCode.WritableString)
{
throw new NotImplementedException();
}
}
//
return(PhpValue.Create(x.ToLong() | y.ToLong()));
}
int ProcessStatus(Context ctx, ref PhpValue status)
{
switch (status.TypeCode)
{
case PhpTypeCode.Alias:
return(ProcessStatus(ctx, ref status.Alias.Value));
case PhpTypeCode.Long:
return((int)status.ToLong());
default:
if (ctx != null)
{
ctx.Echo(status);
}
return(0);
}
}
int ProcessStatus(Context ctx, ref PhpValue status)
{
switch (status.TypeCode)
{
case PhpTypeCode.Alias:
return ProcessStatus(ctx, ref status.Alias.Value);
case PhpTypeCode.Long:
case PhpTypeCode.Int32:
return (int)status.ToLong();
default:
if (ctx != null)
{
ctx.Echo(status);
}
return 0;
}
}
public static bool IsLong(this PhpValue value, out long l)
{
switch (value.TypeCode)
{
case PhpTypeCode.Long:
l = value.Long;
return(true);
case PhpTypeCode.Int32:
l = value.ToLong();
return(true);
case PhpTypeCode.Alias:
return(IsLong(value.Alias.Value, out l));
default:
l = default(long);
return(false);
}
}
public static bool IsLong(this PhpValue value, out long l)
{
if (value.TypeCode == PhpTypeCode.Long)
{
l = value.Long;
return(true);
}
if (value.TypeCode == PhpTypeCode.Int32)
{
l = value.ToLong();
return(true);
}
if (value.TypeCode == PhpTypeCode.Alias)
{
return(IsLong(value.Alias.Value, out l));
}
//
l = default(long);
return(false);
}
public virtual bool SetParameter(StreamParameterOptions option, PhpValue value)
{
// Do not display error messages here, the caller will.
// EX: will have to distinguish between failed and unsupported.
// (use additional message when fails)
// Descendants may call this default implementation for unhandled options
switch (option)
{
case StreamParameterOptions.BlockingMode:
// Unimplemented in Win32 PHP.
return false;
case StreamParameterOptions.ReadBufferSize:
// Unused option (only turns buffering off)
return false;
case StreamParameterOptions.WriteBufferSize:
if (value.IsInteger())
{
// Let the write buffer reset on next write operation.
FlushWriteBuffer();
writeBuffer = null;
// Set the new size (0 to disable write buffering).
writeBufferSize = (int)value.ToLong();
if (writeBufferSize < 0) writeBufferSize = 0;
return true;
}
return false;
case StreamParameterOptions.ReadTimeout:
// Set the read timeout for network-based streams (overrides DefaultTimeout).
this.readTimeout = (double)value;
return false;
case StreamParameterOptions.SetChunkSize:
if (value.IsInteger())
{
// This setting will affect reading after the buffers are emptied.
readChunkSize = (int)value.ToLong();
if (readChunkSize < 1) readChunkSize = 1;
return true;
}
return false;
case StreamParameterOptions.Locking:
return false;
case StreamParameterOptions.MemoryMap:
return false;
case StreamParameterOptions.Truncate:
// EX: [Truncate] Override SetParameter in NativeStream to truncate a local file.
return false;
default:
Debug.Assert(false); // invalid option
return false;
}
}
public long ToLong() => Value.ToLong();
/// <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));
}
/// <summary>
/// Converts to integer using a specified base.
/// </summary>
/// <param name="variable">The variable.</param>
/// <param name="base">The base.</param>
/// <returns>The converted value.</returns>
public static long intval(PhpValue variable, int @base)
{
// TODO: base
// The integer value of var on success, or 0 on failure. Empty arrays and objects return 0, non-empty arrays and objects return 1.
// The maximum value depends on the system. 32 bit systems have a maximum signed integer range of -2147483648 to 2147483647. So for example on such a system, intval('1000000000000') will return 2147483647. The maximum signed integer value for 64 bit systems is 9223372036854775807.
return variable.ToLong();
}
/// <summary> /// Converts to integer. /// </summary> /// <param name="variable">The variable.</param> /// <returns>The converted value.</returns> public static long intval(PhpValue variable) => variable.ToLong();
protected override void FetchCurrent(ref PhpValue key, ref PhpValue value)
{
key = (PhpValue)(key.IsSet ? key.ToLong() + 1L : 0L);
value = PhpValue.FromClr(_enumerator.Current);
}
