/// <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); }