/// <summary>
/// Implements <c>[]</c> operator on <see cref="string"/>.
/// </summary>
public static string GetItemValue(string value, IntStringKey key)
{
int index = key.IsInteger
? key.Integer
: (int)Convert.StringToLongInteger(key.String);
return(GetItemValue(value, index));
}
/// <summary>
/// Gets value at given index.
/// Gets <c>void</c> value in case the key is not found.
/// </summary>
PhpValue IPhpArray.GetItemValue(IntStringKey key)
{
int index = key.IsInteger ? key.Integer : (int)Convert.StringToLongInteger(key.String);
return((index >= 0 && index < this.Length)
? PhpValue.Create(this[index].ToString())
: PhpValue.Create(string.Empty));
}
void Accept(IntStringKey name)
{
// if variable exists adds a copy of its current value to the result:
if (_locals.TryGetValue(name, out var value))
{
_result.Add(name, value.DeepCopy());
}
}
/// <summary>
/// Called when an INI section is encountered.
/// </summary>
public void ProcessSection(IntStringKey sectionName)
{
if (_processSections)
{
_currentSection = new PhpArray();
_result[sectionName] = (PhpValue)_currentSection;
}
}
/// <summary>
/// Implements <c>[]</c> operator on <see cref="string"/> with <c>isset</c> semantics.
/// </summary>
public static string GetItemValueOrNull(string value, IntStringKey key)
{
int index = key.IsInteger
? key.Integer
: (int)Convert.StringToLongInteger(key.String);
return((value != null && index >= 0 && index < value.Length)
? value[index].ToString()
: null);
}
/// <summary>
/// Returns <see cref="ReflectionReference"/> if array element is a reference, <c>null</c> otherwise.
/// </summary>
public static ReflectionReference fromArrayElement(PhpArray array, IntStringKey /*int|string*/ key)
{
if (array != null && array.TryGetValue(key, out var value) && value.Object is PhpAlias alias)
{
return(new ReflectionReference(alias));
}
else
{
return(null);
}
}
public PhpValue GetItemValue(IntStringKey key)
{
if (key.IsInteger)
{
return(PhpValue.FromClr(_array[key.Integer]));
}
else
{
throw new ArgumentException(nameof(key));
}
}
public void RemoveKey(IntStringKey key)
{
if (key.IsInteger)
{
_array.RemoveAt(key.Integer);
}
else
{
throw new ArgumentException(nameof(key));
}
}
/// <summary>
/// Called when an option (i.e. a key-value pair) is encountered.
/// </summary>
public void ProcessOption(IntStringKey key, string value)
{
if (key.IsString)
{
NameValueCollectionUtils.AddVariable(_currentSection, key.String, value, rawname: true);
}
else
{
_currentSection[key] = value;
}
}
public void SetItemAlias(IntStringKey key, PhpAlias alias)
{
if (key.IsInteger)
{
_array[key.Integer] = ToObject(alias.Value);
}
else
{
throw new ArgumentException(nameof(key));
}
}
public void SetItemValue(IntStringKey key, PhpValue value)
{
if (key.IsInteger)
{
_array[key.Integer] = ToObject(value);
}
else
{
throw new ArgumentException(nameof(key));
}
}
public override PhpAlias EnsureItemAlias(ref PhpValue me, IntStringKey key, bool quiet)
{
var arr = me.Object as IPhpArray;
if (arr != null)
{
return(arr.EnsureItemAlias(key));
}
// TODO: Err
throw new NotSupportedException();
}
static IPhpArray EnsureItemArray(IPhpArray array, IntStringKey key)
{
if (key.Equals(IntStringKey.EmptyStringKey))
{
var newarr = new PhpArray();
array.AddValue(PhpValue.Create(newarr));
return(newarr);
}
else
{
return(array.EnsureItemArray(key));
}
}
/// <summary>
/// Provides utilities for converting razor data to twig comprehensable format
/// </summary>
public static PhpArray DataToPhp <T>(IntStringKey key, KeyValuePair <int, T>[] value) where T : struct
{
PhpArray val = new PhpArray(value.Length);
foreach (var v in value)
{
val.Add(v.Key, v.Value);
}
PhpArray res = new PhpArray(1);
res.Add(key, val);
return(res);
}
public static PhpArray EnsureItemArray(PhpArray array, IntStringKey key)
{
PhpArray result;
if (key.IsEmpty)
{
result = new PhpArray();
array.Add(result);
}
else
{
if (array.TryGetValue(key, out var value) && value.IsPhpArray(out var tmp) && tmp != null)
{
result = tmp;
}
/// <summary>
/// Adds a form file to the <c>$_FILES</c> array.
/// </summary>
/// <param name="files">The $_FILES array.</param>
/// <param name="field_name">Form field name.</param>
/// <param name="file_name">Original file name, without the directory name.</param>
/// <param name="type">Content type.</param>
/// <param name="tmp_name">Local full file path where is the uploaded file temporarily stored.</param>
/// <param name="error">Error code number.</param>
/// <param name="file_length">Uploaded file size in bytes.</param>
public static void AddFormFile(PhpArray /*!*/ files, string field_name, string file_name, string type, string tmp_name, int error, long file_length)
{
// field_name
// field_name[]
// field_name[key]
var left = field_name.IndexOf('[');
if (left > 0 && left < field_name.Length - 1)
{
var right = field_name.IndexOf(']', left + 1);
if (right > 0)
{
// keyed file entry:
// the variable name is a key to the "array", dots are replaced by underscores in top-level name:
var field_name_key = new IntStringKey(NameValueCollectionUtils.EncodeTopLevelName(field_name.Substring(0, left)));
var file_entry = NameValueCollectionUtils.EnsureItemArray(files, field_name_key);
// file entry key,
// can be a string, empty or a number
var key = Convert.StringToArrayKey(field_name.Substring(left + 1, right - left - 1));
NameValueCollectionUtils.EnsureItemArray(file_entry, "name", key, file_name);
NameValueCollectionUtils.EnsureItemArray(file_entry, "type", key, type);
NameValueCollectionUtils.EnsureItemArray(file_entry, "tmp_name", key, tmp_name);
NameValueCollectionUtils.EnsureItemArray(file_entry, "error", key, error);
NameValueCollectionUtils.EnsureItemArray(file_entry, "size", key, file_length);
//
return;
}
}
// not keyed:
AddVariable(files, field_name, new PhpArray(5)
{
{ "name", file_name },
{ "type", type },
{ "tmp_name", tmp_name },
{ "error", error },
{ "size", file_length },
});
}
/// <summary>
/// Tries conversion to an array key.
/// </summary>
public static bool TryToIntStringKey(PhpValue value, out IntStringKey key)
{
switch (value.TypeCode)
{
case PhpTypeCode.Int32:
case PhpTypeCode.Long:
case PhpTypeCode.Double:
case PhpTypeCode.String:
case PhpTypeCode.WritableString:
case PhpTypeCode.Boolean:
key = value.ToIntStringKey();
return(true);
case PhpTypeCode.Alias:
return(TryToIntStringKey(value.Alias.Value, out key));
default:
key = default(IntStringKey);
return(false);
}
}
public override PhpValue GetArrayItem(ref PhpValue me, IntStringKey key, bool quiet)
{
// IPhpArray[]
var arr = me.Object as IPhpArray;
if (arr != null)
{
return(arr.GetItemValue(key));
}
// ArrayAccess.offsetGet()
var arracces = me.Object as ArrayAccess;
if (arracces != null)
{
return(arracces.offsetGet(PhpValue.Create(key)));
}
// TODO
throw new NotImplementedException();
}
static PhpArray EnsureItemArray(PhpArray array, IntStringKey key)
{
PhpArray result;
if (key.IsEmpty)
{
result = new PhpArray();
array.AddValue(result);
}
else
{
if (!array.TryGetValue(key, out var value) || (result = value.AsArray()) == null)
{
result = new PhpArray();
array.SetItemValue(key, result);
}
}
//
return(result);
}
/// <summary>
/// Gets descriptor representing a runtime field.
/// Can be <c>null</c> if type does not support runtime fields.
/// </summary>
public static PhpPropertyInfo GetRuntimeProperty(this PhpTypeInfo tinfo, string propertyName, object instance)
{
if (tinfo.RuntimeFieldsHolder != null)
{
var key = new IntStringKey(propertyName);
if (instance != null)
{
var runtimefields = tinfo.GetRuntimeFields(instance);
if (runtimefields == null || runtimefields.Count == 0 || !runtimefields.ContainsKey(key))
{
return(null);
}
}
return(new PhpPropertyInfo.RuntimeProperty(tinfo, key));
}
else
{
return(null);
}
}
/// <summary>
/// Accesses the value as an array and gets item at given index.
/// Gets <c>void</c> value in case the key is not found.
/// Raises PHP exception in case the value cannot be accessed as an array.
/// </summary>
public PhpValue this[IntStringKey key]
{
get { return(GetArrayItem(Create(key), false)); }
}
public IPhpArray EnsureItemArray(IntStringKey key) => table._ensure_item_array(ref key, this);
public PhpAlias EnsureItemAlias(IntStringKey key) => table._ensure_item_alias(ref key, this);
public IPhpArray EnsureItemArray(IntStringKey key) => table._ensure_item_array(ref key, this);
/// <summary>
/// Sets value at specific index. Value must not be an alias.
/// </summary>
void IPhpArray.SetItemValue(IntStringKey key, PhpValue value)
{
int index = key.IsInteger ? key.Integer : (int)Convert.StringToLongInteger(key.String);
char ch;
switch (value.TypeCode)
{
case PhpTypeCode.Long:
ch = (char)value.Long;
break;
case PhpTypeCode.String:
ch = (value.String.Length != 0) ? value.String[0] : '\0';
break;
case PhpTypeCode.WritableString:
ch = value.WritableString[0];
break;
// TODO: other types
default:
throw new NotSupportedException(value.TypeCode.ToString());
}
this[key.Integer] = ch;
}
public PhpValue GetItemValue(IntStringKey key) => table._get(ref key);
static PhpReference GetRefMemberNotFound(DObject self, string name, DTypeDesc caller)
{
PhpReference reference;
bool getter_exists;
// search in RT fields
if (self.RuntimeFields != null && self.RuntimeFields.ContainsKey(name))
{
var namekey = new IntStringKey(name);
return self.RuntimeFields.table._ensure_item_ref(ref namekey, self.RuntimeFields);
}
// property is not present -> try to invoke __get
reference = self.InvokeGetterRef(name, caller, out getter_exists);
if (getter_exists) return (reference == null) ? new PhpReference() : reference;
// (no notice/warning/error thrown by PHP)
// add the field
reference = new PhpReference();
if (self.RuntimeFields == null) self.RuntimeFields = new PhpArray();
self.RuntimeFields[name] = reference;
return reference;
}
public void SetItemAlias(IntStringKey key, PhpAlias alias)
{
this.EnsureWritable();
table._add_or_update(ref key, PhpValue.Create(alias));
this.KeyAdded(ref key);
}
public void SetItemValue(IntStringKey key, PhpValue value)
{
this.EnsureWritable();
table._add_or_update_preserve_ref(ref key, value);
this.KeyAdded(ref key);
}
public PhpAlias EnsureItemAlias(IntStringKey key) => table._ensure_item_alias(ref key, this);
public PhpHashEntryDebugView(IntStringKey key, object value)
{
this.key = key;
this.value = value;
}
public object EnsureItemObject(IntStringKey key) => table._ensure_item_object(ref key, this);
public static PhpValue Create(IntStringKey value) => value.IsInteger ? Create(value.Integer) : Create(value.String);
private DynamicMetaObject/*!*/ FallbackInvokeMember(DynamicMetaObject target/*!*/, DynamicMetaObject/*!*/[]/*!*/ args)
{
// determine run time values and additional restrictions:
DTypeDesc classContext = this._classContext;
string fieldName = this._fieldName;
BindingRestrictions restrictions = BindingRestrictions.GetTypeRestriction(target.Expression, target.LimitType); //target.Restrictions;
int currentArg = 0;
if (!ClassContextIsKnown)
{
Debug.Assert(args.Length > currentArg, "Not enough arguments!");
Debug.Assert(args[currentArg].Value == null || Types.DTypeDesc[0].IsAssignableFrom(args[currentArg].LimitType), "Wrong class context type!");
classContext = (DTypeDesc)args[currentArg].Value;
Debug.Assert(classContext == null || !classContext.IsUnknown, "Class context should be known at run time!");
restrictions = restrictions.Merge(BindingRestrictions.GetInstanceRestriction(args[currentArg].Expression, classContext));
currentArg++;
}
if (IsIndirect)
{
Debug.Assert(args.Length > currentArg, "Not enough arguments!");
Debug.Assert(Types.String[0].IsAssignableFrom(args[currentArg].LimitType), "Wrong field name type!");
fieldName = (string)args[currentArg].Value;
restrictions = restrictions.Merge(
BindingRestrictions.GetExpressionRestriction(
Expression.Equal(
args[currentArg].Expression,
Expression.Constant(fieldName, Types.String[0]))));
currentArg++;
}
//
////Debug.Assert(!(var is PhpReference) && name != null);
Debug.Assert(target.HasValue && target.LimitType != Types.PhpReference[0], "Target should not be PhpReference!");
////if (ReferenceEquals(obj, ScriptContext.SetterChainSingletonObject))
////{
//// ScriptContext.CurrentContext.AbortSetterChain(false);
//// return new PhpReference();
////}
if (WantReference && ReferenceEquals(target.Value, ScriptContext.SetterChainSingletonObject))
{
// GetObjectPropertyRef:
Func<PhpReference> abortSetterChain = () =>
{
ScriptContext.CurrentContext.AbortSetterChain(false);
return new PhpReference();
};
return new DynamicMetaObject(
Expression.Call(abortSetterChain.Method),
BindingRestrictions.GetInstanceRestriction(target.Expression, ScriptContext.SetterChainSingletonObject)
);
}
DObject obj;
////// a property of a DObject:
if ((obj = target.Value as DObject) != null)
{
if (obj is ClrObject /*|| obj is IClrValue // IClrValue -> ClrValue<T> -> already in restriction */)
{
// ((DObject)target).RealType == <obj>.RealType
restrictions = restrictions.Merge(
BindingRestrictions.GetInstanceRestriction(
Expression.Property(Expression.Convert(target.Expression, Types.DObject[0]), Properties.DObject_RealType),
obj.RealType));
}
//// return GetObjectProperty(obj, name, caller, quiet);
DPropertyDesc property;
GetMemberResult result = obj.TypeDesc.GetInstanceProperty(new VariableName(fieldName), classContext, out property);
switch (result)
{
case GetMemberResult.OK:
////object value = property.Get(this);
////PhpReference reference = value as PhpReference;
if (property.Member is PhpField || property.Member is PhpVisibleProperty)
{
var realType = property.DeclaringType.RealType;
FieldInfo realField = (property.Member is PhpField) ? property.PhpField.RealField : null;
PropertyInfo realProperty = (property.Member is PhpVisibleProperty) ? ((PhpVisibleProperty)property.Member).RealProperty : null;
Debug.Assert(realField != null ^ realProperty != null);
MemberExpression getter = null;
if (realField != null)
getter = Expression.Field(Expression.Convert(target.Expression, realType), realField);
else if (realProperty != null)
getter = Expression.Property(Expression.Convert(target.Expression, realType), realProperty);
if (Types.PhpReference[0].IsAssignableFrom(getter.Type))
{
var reference = Expression.Variable(Types.PhpReference[0]);
var assignment = Expression.Assign(reference, getter);
if (WantReference)
{
////value = property.Get(this);
////reference = value as PhpReference;
var returnLabel = Expression.Label(this._returnType);
////if (reference != null && reference.IsSet)
////{
//// reference.IsAliased = true;
//// return reference;
////}
var isset = Expression.IfThen(
Expression.Property(assignment, Properties.PhpReference_IsSet),
Expression.Block(
Expression.Assign(Expression.Property(reference, Properties.PhpReference_IsAliased), Expression.Constant(true)),
Expression.Return(returnLabel, reference)));
////// the CT property has been unset -> try to invoke __get
////PhpReference get_ref = InvokeGetterRef(name, caller, out getter_exists);
////if (getter_exists) return (get_ref == null ? new PhpReference() : get_ref);
////if (reference == null)
////{
//// reference = new PhpReference(value);
//// property.Set(this, reference);
////}
////else
////{
//// reference.IsAliased = true;
//// reference.IsSet = true;
////}
Func<DObject, string, DTypeDesc, PhpReference, PhpReference> notsetOperation = (self, name, caller, refrnc) =>
{
bool getter_exists;
// the CT property has been unset -> try to invoke __get
PhpReference get_ref = self.InvokeGetterRef(name, caller, out getter_exists);
if (getter_exists) return get_ref ?? new PhpReference();
Debug.Assert(refrnc != null);
refrnc.IsAliased = true;
refrnc.IsSet = true;
return refrnc;
};
////return reference;
return new DynamicMetaObject(
Expression.Block(this._returnType,
new[]{reference},
new Expression[]{
isset,
Expression.Label(returnLabel,
Expression.Call(null, notsetOperation.Method, Expression.Convert(target.Expression, Types.DObject[0]), Expression.Constant(fieldName), Expression.Constant(classContext, Types.DTypeDesc[0]), reference))
}),
restrictions);
}
else
{
////if (reference != null && !reference.IsSet)
////{
//// // the property is CT but has been unset
//// if (issetSemantics)
//// {
//// bool handled;
//// return PropertyIssetHandler(name, caller, out handled);
//// }
//// else return GetRuntimeField(name, caller);
////}
////else return value;
Func<DObject, string, DTypeDesc, object> notsetOperation;
if (_issetSemantics) notsetOperation = (self, name, caller) =>
{
return PhpVariable.Dereference(self.GetRuntimeField(name, caller));
};
else notsetOperation = (self, name, caller) =>
{
bool handled;
return PhpVariable.Dereference(self.PropertyIssetHandler(name, caller, out handled));
};
var value =
Expression.Block(this._returnType,
new[] { reference },
Expression.Condition(
Expression.Property(assignment, Properties.PhpReference_IsSet),
Expression.Field(reference, Fields.PhpReference_Value),
Expression.Call(null, notsetOperation.Method, Expression.Convert(target.Expression, Types.DObject[0]), Expression.Constant(fieldName), Expression.Constant(classContext, Types.DTypeDesc[0]))
));
return new DynamicMetaObject(value, restrictions);
}
}
else
{
if (WantReference)
{
return new DynamicMetaObject(
Expression.New(Constructors.PhpReference_Object, Expression.Convert(getter, Types.Object[0])),
restrictions);
}
else
{
return new DynamicMetaObject(
Expression.Call(Methods.PhpVariable.Dereference, Expression.Convert(getter, Types.Object[0])),
restrictions);
}
}
}
else if (property.Member is ClrProperty)
{
var realType = property.DeclaringType.RealType;
var realProperty = property.ClrProperty.RealProperty;
// (target.{RealObject|realValue}).<realProperty>
Expression value = Expression.Convert(
BinderHelper.ClrObjectWrapDynamic(
Expression.Property(
BinderHelper.ClrRealObject(target, realType),
realProperty)),
Types.Object[0]);
if (WantReference) value = BinderHelper.MakePhpReference(value);
return new DynamicMetaObject(value, restrictions);
}
else if (property.Member is ClrField)
{
var realType = property.DeclaringType.RealType;
var realField = property.ClrField.FieldInfo;
// (target.{RealObject|realValue}).<realField>
Expression value = Expression.Convert(
BinderHelper.ClrObjectWrapDynamic(
Expression.Field(
BinderHelper.ClrRealObject(target, realType),
realField)),
Types.Object[0]);
if (WantReference) value = BinderHelper.MakePhpReference(value);
return new DynamicMetaObject(value, restrictions);
}
else if (property.Member is ClrEvent)
{
var clrEvent = (ClrEvent)property.Member;
var realType = property.DeclaringType.RealType;
// emit stub that Wraps event as [ ClrEventObject<handlerType>.Wrap(<SC>, <event name>, <addMethod>, <removeMethod>) ]
var stub = new System.Reflection.Emit.DynamicMethod(
string.Format("event<{0}>",fieldName),
Types.DObject[0], new[] { realType }, realType);
var il = new ILEmitter(stub);
clrEvent.EmitGetEventObject(
il,
new Place(null, Properties.ScriptContext_CurrentContext),
new IndexedPlace(PlaceHolder.Argument, 0),
false);
il.Emit(System.Reflection.Emit.OpCodes.Ret);
Expression value = Expression.Call(stub, BinderHelper.ClrRealObject(target, realType));
if (WantReference) value = BinderHelper.MakePhpReference(value);
return new DynamicMetaObject(value, restrictions);
}
else
throw new NotImplementedException();
case GetMemberResult.NotFound:
if (WantReference)
{
Func<DObject, string, DTypeDesc, PhpReference> op = (self, name, caller) =>
{
PhpReference reference;
bool getter_exists;
// search in RT fields
if (self.RuntimeFields != null && self.RuntimeFields.ContainsKey(name))
{
var namekey = new IntStringKey(name);
return self.RuntimeFields.table._ensure_item_ref(ref namekey, self.RuntimeFields);
}
// property is not present -> try to invoke __get
reference = self.InvokeGetterRef(name, caller, out getter_exists);
if (getter_exists) return (reference == null) ? new PhpReference() : reference;
// (no notice/warning/error thrown by PHP)
// add the field
reference = new PhpReference();
if (self.RuntimeFields == null) self.RuntimeFields = new PhpArray();
self.RuntimeFields[name] = reference;
return reference;
};
return new DynamicMetaObject(
Expression.Call(null, op.Method, Expression.Convert(target.Expression, Types.DObject[0]), Expression.Constant(fieldName), Expression.Constant(classContext, Types.DTypeDesc[0])),
restrictions);
}
else
{
////if (issetSemantics)
////{
//// OrderedHashtable<string>.Element element;
//// if (RuntimeFields != null && (element = RuntimeFields.GetElement(name)) != null)
//// {
//// return element.Value;
//// }
//// else
//// {
//// bool handled;
//// return PropertyIssetHandler(name, caller, out handled);
//// }
////}
////else return GetRuntimeField(name, caller);
if (_issetSemantics)
{
Func<DObject, string, DTypeDesc, object> notsetOperation = (self, name, caller) =>
{
if (self.RuntimeFields != null)
{
object value;
if (self.RuntimeFields.TryGetValue(name, out value))
return value;
}
bool handled;
return self.PropertyIssetHandler(name, caller, out handled);
};
return new DynamicMetaObject(
Expression.Call(Methods.PhpVariable.Dereference,
Expression.Call(null, notsetOperation.Method, Expression.Convert(target.Expression, Types.DObject[0]), Expression.Constant(fieldName), Expression.Constant(classContext, Types.DTypeDesc[0]))),
restrictions);
}
else
{
return new DynamicMetaObject(
Expression.Call(
Methods.PhpVariable.Dereference,
Expression.Call(
Expression.Convert(target.Expression, Types.DObject[0]),
Methods.DObject_GetRuntimeField, Expression.Constant(fieldName), Expression.Constant(classContext, Types.DTypeDesc[0]))),
restrictions);
};
}
case GetMemberResult.BadVisibility:
{
////PhpException.PropertyNotAccessible(
//// property.DeclaringType.MakeFullName(),
//// name.ToString(),
//// (caller == null ? String.Empty : caller.MakeFullName()),
//// property.IsProtected);
string stringResourceKey = property.IsProtected ? "protected_property_accessed" : "private_property_accessed";
return new DynamicMetaObject(
Expression.Block(this._returnType,
Expression.Call(null, Methods.PhpException.Throw,
Expression.Constant(PhpError.Error, Types.PhpError_String[0]),
Expression.Constant(CoreResources.GetString(stringResourceKey, property.DeclaringType.MakeFullName(), fieldName, (classContext == null ? String.Empty : classContext.MakeFullName())))),
WantReference ? (Expression)Expression.New(Constructors.PhpReference_Void) : Expression.Constant(null)
),
restrictions);
}
}
}
////// warnings:
////if (!quiet) // not in isset() operator only
////{
if (!_issetSemantics)
{
//// if (PhpVariable.IsEmpty(var))
//// // empty:
//// PhpException.Throw(PhpError.Notice, CoreResources.GetString("empty_used_as_object"));
//// else
//// // PhpArray, string, scalar type:
//// PhpException.VariableMisusedAsObject(var, false);
Action<object> error = (var) =>
{
if (PhpVariable.IsEmpty(var))
// empty:
PhpException.Throw(PhpError.Notice, CoreResources.GetString("empty_used_as_object"));
else
// PhpArray, string, scalar type:
PhpException.VariableMisusedAsObject(var, false);
};
return new DynamicMetaObject(
Expression.Block(this._returnType,
Expression.Call(error.Method, target.Expression),
WantReference ? (Expression)Expression.New(Constructors.PhpReference_Void) : Expression.Constant(null)),
(target.HasValue && target.Value == null) ?
BindingRestrictions.GetInstanceRestriction(target.Expression, null) :
BindingRestrictions.GetTypeRestriction(target.Expression, target.LimitType));
}
////}
////// property does not exist
////return null;
return new DynamicMetaObject(
Expression.Constant(null),
(target.HasValue && target.Value == null) ?
BindingRestrictions.GetInstanceRestriction(target.Expression, null) :
BindingRestrictions.GetTypeRestriction(target.Expression, target.LimitType));
}
private PhpReference/*!*/ GetArrayItemRef(IntStringKey key)
{
return this.table._ensure_item_ref(ref key, this);
}
/// <summary>
/// Removes a value matching given key.
/// In case the value is not found, the method does nothing.
/// </summary>
void IPhpArray.RemoveKey(IntStringKey key) { throw new NotSupportedException(); }
private void SetArrayItem(IntStringKey key, object value)
{
Debug.Assert(this.GetType() == typeof(PhpArray));
this.EnsureWritable();
this.table._add_or_update_preserve_ref(this, ref key, value);
}
/// <summary>
/// Ensures the item at given index is array.
/// </summary>
IPhpArray IPhpArray.EnsureItemArray(IntStringKey key) { throw new NotSupportedException(); }
/// <summary>
/// Gets value at given index.
/// Gets <c>void</c> value in case the key is not found.
/// </summary>
PhpValue IPhpArray.GetItemValue(IntStringKey key)
{
int index = key.IsInteger ? key.Integer : (int)Convert.StringToLongInteger(key.String);
return (index >= 0 && index < this.Length)
? PhpValue.Create(this[index].ToString())
: PhpValue.Create(string.Empty);
}
public void SetItemValue(IntStringKey key, PhpValue value)
{
this.EnsureWritable();
table._add_or_update_preserve_ref(ref key, value);
this.KeyAdded(ref key);
}
/// <summary>
/// Writes aliased value at given index.
/// </summary>
void IPhpArray.SetItemAlias(IntStringKey key, PhpAlias alias) { throw new NotSupportedException(); }
public void RemoveKey(IntStringKey key) => this.Remove(key);
/// <summary>
/// Ensures the item at given index is class object.
/// </summary>
object IPhpArray.EnsureItemObject(IntStringKey key) { throw new NotSupportedException(); }
public override bool Remove(IntStringKey key)
{
state.Remove(key.ToString());
return true;
}
public static DObject EnsurePropertyIsObject(DObject obj, string name, DTypeDesc caller,
ScriptContext context)
{
Debug.Assert(name != null);
if (ReferenceEquals(obj, ScriptContext.SetterChainSingletonObject))
{
// extend the setter chain if one already exists
context.ExtendSetterChain(new RuntimeChainProperty(name));
return ScriptContext.SetterChainSingletonObject;
}
// search in CT properties
DPropertyDesc property;
GetMemberResult get_res =
obj.TypeDesc.GetProperty(new VariableName(name), caller, out property);
if (get_res == GetMemberResult.BadVisibility)
{
DObject.ThrowPropertyVisibilityError(name, property, caller);
return null;
}
DObject ret_val;
object old_val, value;
// was a CT property found?
if (get_res == GetMemberResult.OK)
{
old_val = property.Get(obj);
value = old_val;
ret_val = EnsurePropertyIsObjectInternal(obj, name, caller, ref value, context);
if (!Object.ReferenceEquals(value, old_val)) property.Set(obj, value);
}
else
{
// search in RT fields
var namekey = new IntStringKey(name);
if (obj.RuntimeFields != null && obj.RuntimeFields.TryGetValue(namekey, out old_val))
{
//old_val = element.Value;
}
else
{
PhpReference reference = new PhpSmartReference();
reference.IsSet = false;
old_val = reference;
}
value = old_val;
ret_val = EnsurePropertyIsObjectInternal(obj, name, caller, ref value, context);
if (!Object.ReferenceEquals(value, old_val))
{
if (obj.RuntimeFields == null) obj.RuntimeFields = new PhpArray();
obj.RuntimeFields[name] = value;
}
}
return ret_val;
}
/// <summary>
/// Checks if a key exists in the array.
/// </summary>
/// <param name="key">The key to be searched for.</param>
/// <param name="array">The array where to search for the key.</param>
/// <returns>Whether the <paramref name="key"/> exists in the <paramref name="array"/>.</returns>
/// <remarks><paramref name="key"/> is converted before the search.</remarks>
/// <exception cref="PhpException"><paramref name="array"/> argument is a <B>null</B> reference (Warning).</exception>
/// <exception cref="PhpException"><paramref name="key"/> has type which is illegal for array key.</exception>
public static bool array_key_exists(IntStringKey key, PhpArray array)
{
if (array == null)
{
// TODO: PhpException.ArgumentNull("array");
return false;
}
return array.ContainsKey(key);
//if (Core.Convert.ObjectToArrayKey(key, out array_key))
// return array.ContainsKey(array_key);
//PhpException.Throw(PhpError.Warning, CoreResources.GetString("illegal_offset_type"));
//return false;
}
public void SetItemAlias(IntStringKey key, PhpAlias alias)
{
this.EnsureWritable();
table._add_or_update(ref key, PhpValue.Create(alias));
this.KeyAdded(ref key);
}
/// <summary> /// Alias of <see cref="array_key_exists"/>. /// </summary> public static bool key_exists(IntStringKey key, PhpArray array) => array_key_exists(key, array);
public object EnsureItemObject(IntStringKey key) => table._ensure_item_object(ref key, this);
/// <summary>
/// Creates a new <see cref="RuntimeChainItem"/> with a given key.
/// </summary>
public RuntimeChainItem(IntStringKey key)
{
this.key = key;
}
public void RemoveKey(IntStringKey key) => this.Remove(key);
public PhpHashEntryDebugView(IntStringKey key, PhpValue value)
{
_key = key;
_value = value;
}
public bool TryToIntStringKey(out IntStringKey key) => _type.TryToIntStringKey(ref this, out key);
/// <summary>
/// Tries conversion to an array key.
/// </summary>
public static bool TryToIntStringKey(PhpValue value, out IntStringKey key)
{
switch (value.TypeCode)
{
case PhpTypeCode.Int32:
case PhpTypeCode.Long:
case PhpTypeCode.Double:
case PhpTypeCode.String:
case PhpTypeCode.WritableString:
case PhpTypeCode.Boolean:
key = value.ToIntStringKey();
return true;
case PhpTypeCode.Alias:
return TryToIntStringKey(value.Alias.Value, out key);
default:
key = default(IntStringKey);
return false;
}
}
public RuntimeProperty(PhpTypeInfo tinfo, IntStringKey name)
: base(tinfo)
{
_name = name;
}
/// <summary>
/// Moves to the next entry.
/// </summary>
/// <returns>Whether we can continue.</returns>
public bool MoveNext()
{
bool hasMore;
if (enumerator.CurrentKey.Equals(ref currentKey))
{
// advance to the next position
hasMore = enumerator.MoveNext();
}
else
{
hasMore = !enumerator.AtEnd; // user deleted current entry and enumerator was already advanced to the next position
}
this.currentKey = enumerator.CurrentKey;
if (!hasMore)
this.Dispose(); // dispose underlaying Enumerator so it can be unregistered from active enumerators list
return hasMore;
}
