private void WritePropertyValue(TextWriter writer, Stack <RuntimeObject> stack, EcmaValue value)
{
switch (value.Type)
{
case EcmaValueType.Null:
writer.Write("null");
break;
case EcmaValueType.Boolean:
writer.Write(value.ToBoolean() ? "true" : "false");
break;
case EcmaValueType.Number:
writer.Write(value.IsFinite ? value.ToString() : "null");
break;
case EcmaValueType.String:
WriteString(writer, value.ToString());
break;
case EcmaValueType.Object:
if (!value.IsCallable)
{
if (EcmaArray.IsArray(value))
{
SerializeJsonArray(writer, stack, value.ToObject());
}
else
{
SerializeJsonObject(writer, stack, value.ToObject());
}
}
break;
}
}
public static EcmaValue GetOwnPropertyDescriptor(EcmaValue target, EcmaValue property)
{
EcmaPropertyDescriptor descriptor = target.ToObject().GetOwnProperty(EcmaPropertyKey.FromValue(property));
if (descriptor == null)
{
return(default);
public static EcmaValue DefineProperty(EcmaValue target, EcmaValue property, EcmaValue attributes)
{
Guard.ArgumentIsObject(target);
RuntimeObject obj = target.ToObject();
obj.DefinePropertyOrThrow(EcmaPropertyKey.FromValue(property), EcmaPropertyDescriptor.FromValue(attributes));
return(target);
}
public static EcmaValue Entries(EcmaValue target)
{
List <EcmaValue> arr = new List <EcmaValue>();
foreach (EcmaPropertyEntry e in target.ToObject().GetEnumerableOwnProperties(false))
{
arr.Add(e.ToValue());
}
return(new EcmaArray(arr));
}
public static EcmaValue Freeze(EcmaValue obj)
{
if (obj.Type == EcmaValueType.Object)
{
if (!obj.ToObject().SetIntegrityLevel(RuntimeObjectIntegrityLevel.Frozen))
{
throw new EcmaTypeErrorException(InternalString.Error.PreventExtensionFailed);
}
}
return(obj);
}
public static EcmaValue DefineProperties(EcmaValue target, EcmaValue properties)
{
Guard.ArgumentIsObject(target);
RuntimeObject dst = target.ToObject();
foreach (EcmaPropertyEntry e in properties.ToObject().GetEnumerableOwnProperties(true))
{
dst.DefinePropertyOrThrow(e.Key, EcmaPropertyDescriptor.FromValue(e.Value));
}
return(target);
}
public static EcmaValue Create(EcmaValue proto, EcmaValue properties)
{
if (proto.Type != EcmaValueType.Object && proto.Type != EcmaValueType.Null)
{
throw new EcmaTypeErrorException(InternalString.Error.PrototypeMustBeObjectOrNull);
}
RuntimeObject obj = Create(proto == EcmaValue.Null ? null : proto.ToObject());
if (properties == default)
{
return(obj);
}
return(DefineProperties(obj, properties));
}
public static bool InstanceOf(this EcmaValue thisValue, EcmaValue constructor)
{
if (constructor.Type != EcmaValueType.Object)
{
throw new EcmaTypeErrorException(InternalString.Error.NotFunction);
}
RuntimeObject obj = constructor.ToObject();
RuntimeObject instOfHandler = obj.GetMethod(Symbol.HasInstance);
if (instOfHandler != null)
{
return(instOfHandler.Call(constructor, thisValue).ToBoolean());
}
if (!constructor.IsCallable)
{
throw new EcmaTypeErrorException(InternalString.Error.NotFunction);
}
return(obj.HasInstance(thisValue.ToObject()));
}
public static EcmaValue CloneValue(EcmaValue value, EcmaValue[] transfer, RuntimeRealm targetRealm)
{
Guard.ArgumentNotNull(targetRealm, "targetRealm");
bool isPrimitive = value.Type != EcmaValueType.Object;
RuntimeObject[] transferList = transfer != null?transfer.Select(v => v.ToObject()).ToArray() : new RuntimeObject[0];
RuntimeObject obj;
if (isPrimitive)
{
obj = new EcmaObject();
obj[""] = value;
}
else
{
obj = value.ToObject();
}
obj = obj.Clone(targetRealm, transferList);
return(isPrimitive ? obj[""] : obj);
}
private static EcmaValue InternalizeJsonProperty(RuntimeObject holder, EcmaPropertyKey property, EcmaValue reviver)
{
EcmaValue value = holder.Get(property);
if (value.Type == EcmaValueType.Object)
{
RuntimeObject obj = value.ToObject();
if (EcmaArray.IsArray(value))
{
for (long i = 0, length = value[WellKnownProperty.Length].ToLength(); i < length; i++)
{
EcmaValue newValue = InternalizeJsonProperty(obj, i, reviver);
if (newValue.Type == EcmaValueType.Undefined)
{
obj.Delete(i);
}
else
{
obj.CreateDataProperty(i, newValue);
}
}
}
else
{
foreach (EcmaPropertyKey key in obj.GetEnumerableOwnPropertyKeys().ToArray())
{
EcmaValue newValue = InternalizeJsonProperty(obj, key, reviver);
if (newValue.Type == EcmaValueType.Undefined)
{
obj.Delete(key);
}
else
{
obj.CreateDataProperty(key, newValue);
}
}
}
}
return(reviver.Call(holder, property.ToValue(), value));
}
public static EcmaValue Many(EcmaValue iterable)
{
RuntimeFunctionInvocation invocation = RuntimeFunctionInvocation.Current;
if (invocation == null || invocation.Generator == null)
{
throw new InvalidOperationException();
}
IGeneratorEnumerator other;
if (invocation.Generator.Kind == GeneratorKind.Async)
{
other = new RecursiveYieldAsyncEnumerator(iterable.ToObject().GetAsyncIterator());
}
else if (iterable.GetUnderlyingObject() is IGeneratorEnumerable iterator)
{
other = new RecursiveYieldEnumerator(iterator);
}
else
{
other = new RecursiveYieldEnumerator(new EcmaIteratorEnumerator(iterable));
}
GeneratorDelegateEnumerator.GetCurrent().PushStack(other);
return(default);
private void ResolveSelf(EcmaValue value, bool finalize)
{
if (value.Type == EcmaValueType.Object)
{
RuntimeObject obj = value.ToObject();
if (obj == this)
{
SetStateFinalize(PromiseState.Rejected, new EcmaTypeErrorException(InternalString.Error.PromiseSelfResolution).ToValue());
return;
}
try {
RuntimeObject then = obj.GetMethod(WellKnownProperty.Then);
if (then != null)
{
then.Call(value, (PromiseResolver)ResolveSelf, (PromiseResolver)RejectSelf);
return;
}
} catch (Exception ex) {
SetStateFinalize(PromiseState.Rejected, EcmaValueUtility.GetValueFromException(ex));
return;
}
}
SetState(PromiseState.Fulfilled, value, finalize);
}
internal AsyncFromSyncIterator(EcmaValue value)
: base(WellKnownObject.AsyncFromSyncIteratorPrototype)
{
this.target = value.ToObject();
this.iterator = new EcmaIteratorEnumerator(value);
}
public EcmaArrayIterator(EcmaValue target, EcmaIteratorResultKind kind)
: base(target.ToObject(), kind, WellKnownObject.ArrayIteratorPrototype)
{
}
