/// <summary>
/// Gets a contents of a specified cell from a specified query result resource.
/// </summary>
/// <param name="resultHandle">Query result resource.</param>
/// <param name="row">Row index.</param>
/// <param name="field">Column (field) integer index or string name.</param>
/// <returns>The value of the cell or a <B>null</B> reference (<B>false</B> in PHP) on failure (invalid resource or row/field index/name).</returns>
/// <remarks>
/// Result is affected by run-time quoting.
/// </remarks>
public static PhpValue mysql_result(PhpResource resultHandle, int row, PhpValue field)
{
var result = MySqlResultResource.ValidResult(resultHandle);
if (result == null)
{
return(PhpValue.False);
}
string field_name;
object field_value;
if (field.IsEmpty)
{
field_value = result.GetFieldValue(row, result.CurrentFieldIndex);
}
else if ((field_name = PhpVariable.AsString(field)) != null)
{
field_value = result.GetFieldValue(row, field_name);
}
else
{
field_value = result.GetFieldValue(row, (int)field.ToLong());
}
return(PhpValue.FromClr(field_value)); // TODO: Core.Convert.Quote(field_value, context);
}
public static object GetField(PhpResource resultHandle, int rowIndex, object field)
{
PhpSqlDbResult result = PhpSqlDbResult.ValidResult(resultHandle);
ScriptContext context = ScriptContext.CurrentContext;
if (result == null)
{
return(null);
}
string field_name;
object field_value;
if (field == null)
{
field_value = result.GetFieldValue(rowIndex, result.CurrentFieldIndex);
}
else if ((field_name = PhpVariable.AsString(field)) != null)
{
field_value = result.GetFieldValue(rowIndex, field_name);
}
else
{
field_value = result.GetFieldValue(rowIndex, Core.Convert.ObjectToInteger(field));
}
return(Core.Convert.Quote(field_value, context));
}
public static void f7(params PhpArray[] args)
{
foreach (PhpArray arg in args)
{
PhpVariable.Dump(arg);
}
}
public static void f5(params double[] args)
{
foreach (double arg in args)
{
PhpVariable.Dump(arg);
}
}
public static void __dump_session()
{
TextWriter o = ScriptContext.CurrentContext.Output;
HttpContext context = HttpContext.Current;
if (context == null)
{
o.WriteLine("HTTP CONTEXT NULL"); return;
}
HttpSessionState state = context.Session;
if (context == null)
{
o.WriteLine("SESSION NULL"); return;
}
PhpArray a = new PhpArray();
foreach (string name in state)
{
a[name] = state[name];
}
PhpVariable.Dump(o, a);
}
public static void DebugDump(object var)
{
StringWriter s = new StringWriter();
PhpVariable.Dump(s, var);
Debug.WriteLine("DEBUG", s.ToString());
}
public virtual object getMethod(ScriptContext /*!*/ context, object name)
{
if (typedesc == null)
{
return(false);
}
var nameStr = PhpVariable.AsString(name);
if (string.IsNullOrEmpty(nameStr))
{
return(false);
}
DRoutineDesc method;
if (typedesc.GetMethod(new Name(nameStr), typedesc, out method) == GetMemberResult.NotFound)
{
return(false);
}
return(new ReflectionMethod(context, true)
{
dtype = method.DeclaringType,
method = method,
});
}
public object __construct(ScriptContext __context, object wsdl, [System.Runtime.InteropServices.OptionalAttribute()]
object options)
{
string tmp1 = PhpVariable.AsString(wsdl);
if (tmp1 == null)
{
PhpException.InvalidImplicitCast(wsdl, "string", "__construct");
return(null);
}
PhpArray tmp2 = null;
if (options != Arg.Default)
{
tmp2 = options as PhpArray;
if (tmp2 == null)
{
PhpException.InvalidImplicitCast(options, "PhpArray", "__construct");
return(null);
}
}
__construct(tmp1, tmp2);
return(null);
}
protected void ConstructDirectoryIteratorInternal(ScriptContext /*!*/ context, object path)
{
string pathstr = PhpVariable.AsString(path);
if (string.IsNullOrEmpty(pathstr))
{
RuntimeException.ThrowSplException(c => new RuntimeException(c, true), context, @"Directory name must not be empty.", 0, null);
return;
}
string errmessage = null;
try
{
this.fs_info = new DirectoryInfo(Path.Combine(context.WorkingDirectory, pathstr));
this.CreateEnumeratorInternal();
}
catch (System.Exception ex)
{
errmessage = ex.Message;
}
if (errmessage != null)
{
UnexpectedValueException.ThrowSplException(c => new UnexpectedValueException(c, true), context, errmessage, 0, null);
}
}
internal RuntimeTypeHandle ResolveNewScope(object newthis, PhpValue newscope = default(PhpValue))
{
if (newscope.IsSet)
{
// Operators.TypeNameOrObjectToType(newscope) + handle "static"
object obj;
string str;
if ((obj = (newscope.AsObject())) != null)
{
return(obj.GetType().TypeHandle);
}
else if ((str = PhpVariable.AsString(newscope)) != null)
{
return("static".Equals(str, StringComparison.OrdinalIgnoreCase)
? _scope
: _ctx.GetDeclaredTypeOrThrow(str, true).TypeHandle);
}
else if (newscope.IsNull)
{
return(default(RuntimeTypeHandle));
}
else
{
throw new ArgumentException(nameof(newscope));
}
}
return(ReferenceEquals(newthis, null) ? _scope : newthis.GetType().TypeHandle);
}
protected override object GetArrayItemOverride(object key, bool quiet)
{
PhpStack stack = ScriptContext.CurrentContext.Stack;
stack.AddFrame(key);
return(PhpVariable.Dereference(arrayAccess.InvokeMethod(offsetGet, null, stack.Context)));
}
internal static object GetUserArrayItem(DObject /*!*/ arrayAccess, object index, Operators.GetItemKinds kind)
{
PhpStack stack = ScriptContext.CurrentContext.Stack;
switch (kind)
{
case Operators.GetItemKinds.Isset:
// pass isset() ""/null to say true/false depending on the value returned from "offsetExists":
stack.AddFrame(index);
return(Core.Convert.ObjectToBoolean(arrayAccess.InvokeMethod(offsetExists, null, stack.Context)) ? "" : null);
case Operators.GetItemKinds.Empty:
// if "offsetExists" returns false, the empty()/isset() returns false (pass null to say true/false):
// otherwise, "offsetGet" is called to retrieve the value, which is passed to isset():
stack.AddFrame(index);
if (!Core.Convert.ObjectToBoolean(arrayAccess.InvokeMethod(offsetExists, null, stack.Context)))
{
return(null);
}
else
{
goto default;
}
default:
// regular getter:
stack.AddFrame(index);
return(PhpVariable.Dereference(arrayAccess.InvokeMethod(offsetGet, null, stack.Context)));
}
}
/// <summary>
/// Gets a contents of a specified cell from a specified query result resource.
/// </summary>
/// <param name="ctx">PHP context.</param>
/// <param name="resultHandle">Query result resource.</param>
/// <param name="rowIndex">Row index.</param>
/// <param name="field">Column (field) integer index or string name.</param>
/// <returns>The value of the cell or <B>false</B> on failure (invalid resource or row index).</returns>
public static PhpValue mssql_result(Context ctx, PhpResource resultHandle, int rowIndex, PhpValue field)
{
var result = PhpSqlDbResult.ValidResult(resultHandle);
if (result == null)
{
return(PhpValue.False);
}
string field_name;
object field_value;
if (field.IsNull)
{
field_value = result.GetFieldValue(rowIndex, result.CurrentFieldIndex);
}
else if ((field_name = PhpVariable.AsString(field)) != null)
{
field_value = result.GetFieldValue(rowIndex, field_name);
}
else
{
field_value = result.GetFieldValue(rowIndex, (int)field.ToLong());
}
if (field_value == null)
{
return(PhpValue.False);
}
return(PhpValue.FromClr(field_value)); // Core.Convert.Quote(field_value, context);
}
/// <summary>
/// Sets user-level session storage functions
/// </summary>
public static bool session_set_save_handler(
Context ctx,
IPhpCallable open, IPhpCallable close,
IPhpCallable read, IPhpCallable write,
IPhpCallable destroy, IPhpCallable gc,
IPhpCallable create_sid = null,
IPhpCallable validate_sid = null,
IPhpCallable update_timestamp = null)
{
if (!ctx.IsWebApplication ||
!PhpVariable.IsValidBoundCallback(ctx, open) ||
!PhpVariable.IsValidBoundCallback(ctx, close) ||
!PhpVariable.IsValidBoundCallback(ctx, read) ||
!PhpVariable.IsValidBoundCallback(ctx, write) ||
!PhpVariable.IsValidBoundCallback(ctx, destroy) ||
!PhpVariable.IsValidBoundCallback(ctx, gc))
{
return(false);
}
session_set_save_handler(
ctx,
sessionhandler: new CustomSessionHandler(ctx,
open, close, read, write, destroy, gc,
create_sid: create_sid, validate_sid: validate_sid, update_timestamp: update_timestamp),
register_shutdown: false);
return(true);
}
/// <summary>
/// Deserializes a graph of connected object from a byte array using a given formatter.
/// </summary>
/// <param name="bytes">The byte array to deserialize the graph from.</param>
/// <param name="caller">DTypeDesc of the caller's class context if it is known or UnknownTypeDesc if it should be determined lazily.</param>
/// <returns>
/// The deserialized object graph or an instance of <see cref="PhpReference"/> containing <B>false</B> on error.
/// </returns>
/// <exception cref="PhpException">Deserialization failed (Notice).</exception>
public PhpReference Deserialize(PhpBytes bytes, DTypeDesc caller)
{
MemoryStream stream = new MemoryStream(bytes.ReadonlyData);
object result = null;
try
{
try
{
// deserialize the data
result = GetFormatter(caller).Deserialize(stream);
}
catch (System.Reflection.TargetInvocationException e)
{
throw e.InnerException;
}
}
catch (SerializationException e)
{
PhpException.Throw(PhpError.Notice, LibResources.GetString("deserialization_failed",
e.Message, stream.Position, stream.Length));
return(new PhpReference(false));
}
return(PhpVariable.MakeReference(result));
}
public static void f3(params object[] args)
{
foreach (object arg in args)
{
PhpVariable.Dump(arg);
}
}
public static void f2(params int[] args)
{
foreach (int arg in args)
{
PhpVariable.Dump(arg);
}
}
public static void f1(params PhpReference[] args)
{
foreach (PhpReference arg in args)
{
PhpVariable.Dump(arg.value);
arg.value = "hello";
}
}
public void TestRandomKeys()
{
PhpArray a = PhpArray.Keyed("Server1", 1, "Server2", 2, "Server3", 3);
PhpVariable.Dump(a);
string result = PhpArrays.RandomKeys(a) as string;
Assert.IsTrue(result == "Server1" || result == "Server2" || result == "Server3");
}
public static void Dump(params object[] variables)
{
TextWriter output = ScriptContext.CurrentContext.Output;
foreach (object variable in variables)
{
PhpVariable.Dump(output, variable);
}
}
/// <summary>
/// Specifies dynamic behavior for invoke operation for global function
/// </summary>
public bool TryInvokeMember(
string memberName,
Object[] args,
out Object result
)
{
result = PhpVariable.Unwrap(PhpVariable.Dereference(Context.Call(memberName, null, null, wrapArgs(args))));
return(true);
}
/// <summary>
/// Specifies dynamic behavior for invoke operation for static method
/// </summary>
public override bool TryInvokeMember(
InvokeMemberBinder binder,
Object[] args,
out Object result
)
{
Context.Stack.AddFrame(wrapArgs(args));
result = PhpVariable.Unwrap(PhpVariable.Dereference(Operators.InvokeStaticMethod(type, binder.Name, null, null, Context)));
return(true);
}
/// <summary>
/// Create and return a new anonymous function from given callable using the current scope.
/// This method checks if the callable is callable in the current scope and throws a TypeError if it is not.
/// </summary>
public static Closure fromCallable(Context ctx, IPhpCallable callable)
{
if (callable is Closure closure)
{
return(closure);
}
if (callable != null && PhpVariable.IsValidBoundCallback(ctx, callable))
{
return(new Closure(ctx, callable, null, default, null, PhpArray.Empty, PhpArray.Empty));
private void AddFormData(object data)
{
//currentData.Type = FormType.FORM_CONTENT;
PhpBytes bytes = PhpVariable.AsBytes(data);
currentData.Data = bytes.ReadonlyData;
NextDataIsFooter();
}
public virtual object isSubclassOf(ScriptContext /*!*/ context, object @class)
{
var classname = PhpVariable.AsString(@class);
if (!string.IsNullOrEmpty(classname) && this.typedesc != null)
{
var dtype = context.ResolveType(classname, null, null, null, ResolveTypeFlags.ThrowErrors | ResolveTypeFlags.UseAutoload);
return(dtype != null && this.typedesc.IsAssignableFrom(dtype));
}
return(false);
}
public object __setLocation(ScriptContext __context, object new_location)
{
string tmp1 = PhpVariable.AsString(new_location);
if (tmp1 == null)
{
PhpException.InvalidImplicitCast(new_location, "string", "__setLocation");
return(null);
}
return(__setLocation(tmp1));
}
/// <summary>
/// Verifies that the contents of a variable can be called as a function.
/// </summary>
/// <param name="ctx">Current runtime context.</param>
/// <param name="callerCtx">Type of the current calling context.</param>
/// <param name="variable">The variable.</param>
/// <param name="syntaxOnly">If <B>true</B>, it is only checked that has <pararef name="variable"/>
/// a valid structure to be used as a callback. if <B>false</B>, the existence of the function (or
/// method) is also verified.</param>
/// <param name="callableName">Receives the name of the function or method (for example
/// <c>SomeClass::SomeMethod</c>).</param>
/// <returns><B>true</B> if <paramref name="variable"/> denotes a function, <B>false</B>
/// otherwise.</returns>
public static bool is_callable(Context ctx, [ImportCallerClass] RuntimeTypeHandle callerCtx, PhpValue variable, bool syntaxOnly, out string callableName)
{
var callback = variable.AsCallable(callerCtx);
if (PhpVariable.IsValidCallback(callback))
{
callableName = callback.ToString();
return(true);
}
callableName = variable.ToString(ctx);
return(false);
}
public static string get_class(PhpValue @object)
{
var obj = @object.AsObject();
if (obj == null || obj is PhpResource)
{
// TODO: Warning: get_class() expects parameter 1 to be object, {PhpVariable.GetTypeName(@object)} given
PhpException.InvalidArgumentType(nameof(@object), PhpVariable.TypeNameObject);
return(null); // FALSE
}
return(PhpVariable.GetClassName(obj));
}
public static PhpArray GetDefinedVariables(Dictionary <string, object> localVariables)
{
PhpArray globals = (localVariables != null) ? null : ScriptContext.CurrentContext.GlobalVariables;
PhpArray result = new PhpArray((localVariables != null) ? localVariables.Count : globals.Count);
foreach (KeyValuePair <string, object> entry in PhpArray.GetEnumerator(globals, localVariables))
{
result.Add(entry.Key, PhpVariable.DeepCopy(entry.Value));
}
return(result);
}
/// <summary>
/// Verifies that the contents of a variable can be called as a function.
/// </summary>
/// <param name="ctx">Current runtime context.</param>
/// <param name="variable">The variable.</param>
/// <param name="syntaxOnly">If <B>true</B>, it is only checked that has <pararef name="variable"/>
/// a valid structure to be used as a callback. if <B>false</B>, the existence of the function (or
/// method) is also verified.</param>
/// <param name="callableName">Receives the name of the function or method (for example
/// <c>SomeClass::SomeMethod</c>).</param>
/// <returns><B>true</B> if <paramref name="variable"/> denotes a function, <B>false</B>
/// otherwise.</returns>
public static bool is_callable(Context ctx /*, caller*/, PhpValue variable, bool syntaxOnly, out string callableName)
{
var callback = variable.AsCallable();
if (PhpVariable.IsValidCallback(callback))
{
callableName = callback.ToString();
return(true);
}
callableName = variable.ToString(ctx);
return(false);
}
