Var JavascriptGeneratorFunction::NewInstance(RecyclableObject* function, CallInfo callInfo, ...) { // Get called when creating a new generator function through the constructor (e.g. gf.__proto__.constructor) and sets EntryGeneratorFunctionImplementation as the entrypoint PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); return JavascriptFunction::NewInstanceHelper(function->GetScriptContext(), function, callInfo, args, FunctionKind::Generator); }
Var JavascriptError::NewWinRTErrorInstance(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); JavascriptError* pError = scriptContext->GetHostScriptContext()->CreateWinRTError(nullptr, nullptr); return JavascriptError::NewInstance(function, pError, callInfo, args); }
Var JavascriptWeakSet::NewInstance(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); JavascriptLibrary* library = scriptContext->GetLibrary(); Var newTarget = callInfo.Flags & CallFlags_NewTarget ? args.Values[args.Info.Count] : args[0]; bool isCtorSuperCall = (callInfo.Flags & CallFlags_New) && newTarget != nullptr && !JavascriptOperators::IsUndefined(newTarget); Assert(isCtorSuperCall || !(callInfo.Flags & CallFlags_New) || args[0] == nullptr); CHAKRATEL_LANGSTATS_INC_BUILTINCOUNT(WeakSetCount); JavascriptWeakSet* weakSetObject = nullptr; if (callInfo.Flags & CallFlags_New) { weakSetObject = library->CreateWeakSet(); } else { JavascriptError::ThrowTypeErrorVar(scriptContext, JSERR_NeedObjectOfType, _u("WeakSet"), _u("WeakSet")); } Assert(weakSetObject != nullptr); Var iterable = (args.Info.Count > 1) ? args[1] : library->GetUndefined(); RecyclableObject* iter = nullptr; RecyclableObject* adder = nullptr; if (JavascriptConversion::CheckObjectCoercible(iterable, scriptContext)) { iter = JavascriptOperators::GetIterator(iterable, scriptContext); Var adderVar = JavascriptOperators::GetProperty(weakSetObject, PropertyIds::add, scriptContext); if (!JavascriptConversion::IsCallable(adderVar)) { JavascriptError::ThrowTypeError(scriptContext, JSERR_NeedFunction); } adder = RecyclableObject::FromVar(adderVar); } if (iter != nullptr) { Var nextItem; while (JavascriptOperators::IteratorStepAndValue(iter, scriptContext, &nextItem)) { CALL_FUNCTION(adder, CallInfo(CallFlags_Value, 2), weakSetObject, nextItem); } } return isCtorSuperCall ? JavascriptOperators::OrdinaryCreateFromConstructor(RecyclableObject::FromVar(newTarget), weakSetObject, nullptr, scriptContext) : weakSetObject; }
Var JavascriptStringIterator::EntryNext(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); JavascriptLibrary* library = scriptContext->GetLibrary(); Assert(!(callInfo.Flags & CallFlags_New)); Var thisObj = args[0]; if (!JavascriptStringIterator::Is(thisObj)) { JavascriptError::ThrowTypeError(scriptContext, JSERR_This_NeedStringIterator, L"String Iterator.prototype.next"); } JavascriptStringIterator* iterator = JavascriptStringIterator::FromVar(thisObj); JavascriptString* string = iterator->m_string; if (string == nullptr) { return library->CreateIteratorResultObjectUndefinedTrue(); } charcount_t length = string->GetLength(); charcount_t index = iterator->m_nextIndex; if (index >= length) { // Nulling out the m_string field is important so that the iterator // does not keep the string alive after iteration is completed. iterator->m_string = nullptr; return library->CreateIteratorResultObjectUndefinedTrue(); } wchar_t chFirst = string->GetItem(index); Var result; if (index + 1 == string->GetLength() || !NumberUtilities::IsSurrogateLowerPart(chFirst) || !NumberUtilities::IsSurrogateUpperPart(string->GetItem(index + 1))) { result = scriptContext->GetLibrary()->GetCharStringCache().GetStringForChar(chFirst); iterator->m_nextIndex += 1; } else { result = JavascriptString::SubstringCore(string, index, 2, scriptContext); iterator->m_nextIndex += 2; } return library->CreateIteratorResultObjectValueFalse(result); }
Var JavascriptGeneratorFunction::NewInstanceRestrictedMode(RecyclableObject* function, CallInfo callInfo, ...) { ScriptContext* scriptContext = function->GetScriptContext(); scriptContext->CheckEvalRestriction(); PROBE_STACK(scriptContext, Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); return JavascriptFunction::NewInstanceHelper(scriptContext, function, callInfo, args, FunctionKind::Generator); }
Var JavascriptError::NewWinRTErrorInstance(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); JavascriptError* pError = scriptContext->GetHostScriptContext()->CreateWinRTError(nullptr, nullptr); Var newTarget = callInfo.Flags & CallFlags_NewTarget ? args.Values[args.Info.Count] : args[0]; Var message = args.Info.Count > 1 ? args[1] : scriptContext->GetLibrary()->GetUndefined(); return JavascriptError::NewInstance(function, pError, callInfo, newTarget, message); }
Var SIMDUint16x8Lib::EntryLoad(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'"); Assert(!(callInfo.Flags & CallFlags_New)); return SIMD128TypedArrayLoad<JavascriptSIMDUint16x8>(args[1], args[2], 8 * INT16_SIZE, scriptContext); }
Var SIMDFloat64x2Lib::EntryZero(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'"); Assert(!(callInfo.Flags & CallFlags_New)); SIMDValue lanes = SIMDFloat64x2Operation::OpZero(); return JavascriptSIMDFloat64x2::New(&lanes, scriptContext); }
Var SIMDInt8x16Lib::EntryCheck(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'"); if (args.Info.Count >= 2 && JavascriptSIMDInt8x16::Is(args[1])) { return args[1]; } JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt8x16TypeMismatch, L"Int8x16"); }
Var JavascriptMapIterator::EntryNext(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); JavascriptLibrary* library = scriptContext->GetLibrary(); Assert(!(callInfo.Flags & CallFlags_New)); Var thisObj = args[0]; if (!JavascriptMapIterator::Is(thisObj)) { JavascriptError::ThrowTypeError(scriptContext, JSERR_This_NeedMapIterator, L"Map Iterator.prototype.next"); } JavascriptMapIterator* iterator = JavascriptMapIterator::FromVar(thisObj); JavascriptMap* map = iterator->m_map; auto& mapIterator = iterator->m_mapIterator; if (map == nullptr || !mapIterator.Next()) { iterator->m_map = nullptr; return library->CreateIteratorResultObjectUndefinedTrue(); } auto entry = mapIterator.Current(); Var result; if (iterator->m_kind == JavascriptMapIteratorKind::KeyAndValue) { JavascriptArray* keyValueTuple = library->CreateArray(2); keyValueTuple->SetItem(0, entry.Key(), PropertyOperation_None); keyValueTuple->SetItem(1, entry.Value(), PropertyOperation_None); result = keyValueTuple; } else if (iterator->m_kind == JavascriptMapIteratorKind::Key) { result = entry.Key(); } else { Assert(iterator->m_kind == JavascriptMapIteratorKind::Value); result = entry.Value(); } return library->CreateIteratorResultObjectValueFalse(result); }
Var SIMDInt32x4Lib::EntryCheck(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'"); Assert(!(callInfo.Flags & CallFlags_New)); //comment out due to -ls -stress run if (args.Info.Count >= 2 && JavascriptSIMDInt32x4::Is(args[1])) { return args[1]; } JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("int32x4")); }
Var JavascriptMap::EntryValues(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); if (!JavascriptMap::Is(args[0])) { JavascriptError::ThrowTypeErrorVar(scriptContext, JSERR_NeedObjectOfType, _u("Map.prototype.values"), _u("Map")); } JavascriptMap* map = JavascriptMap::FromVar(args[0]); return scriptContext->GetLibrary()->CreateMapIterator(map, JavascriptMapIteratorKind::Value); }
Var JavascriptError::NewErrorInstance(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); JavascriptError* pError = scriptContext->GetLibrary()->CreateError(); // Process the arguments for IE specific behaviors for numbers and description JavascriptString* descriptionString = nullptr; bool hasNumber = false; double number = 0; if (args.Info.Count >= 3) { hasNumber = true; number = JavascriptConversion::ToNumber(args[1], scriptContext); // Get rid of this arg. NewInstance only expects a message arg. args.Values++; args.Info.Count--; descriptionString = JavascriptConversion::ToString(args[1], scriptContext); } else if (args.Info.Count == 2) { if (!hasNumber) { descriptionString = JavascriptConversion::ToString(args[1], scriptContext); } } else { hasNumber = true; descriptionString = scriptContext->GetLibrary()->GetEmptyString(); } Assert(descriptionString != nullptr); if (hasNumber) { JavascriptOperators::InitProperty(pError, PropertyIds::number, JavascriptNumber::ToVarNoCheck(number, scriptContext)); pError->SetNotEnumerable(PropertyIds::number); } JavascriptOperators::SetProperty(pError, pError, PropertyIds::description, descriptionString, scriptContext); pError->SetNotEnumerable(PropertyIds::description); return JavascriptError::NewInstance(function, pError, callInfo, args); }
Var JavascriptReflect::EntryConstruct(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); Var undefinedValue = scriptContext->GetLibrary()->GetUndefined(); AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.construct")); AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'"); if (args.Info.Flags & CallFlags_New) { JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.construct")); } Var target = args.Info.Count > 1 ? args[1] : undefinedValue; if (!JavascriptOperators::IsConstructor(target)) { JavascriptError::ThrowTypeError(scriptContext, JSERR_NeedConstructor, _u("target")); } Var newTarget = nullptr; if (scriptContext->GetConfig()->IsES6ClassAndExtendsEnabled()) { if (args.Info.Count > 3) { newTarget = args[3]; if (!JavascriptOperators::IsConstructor(newTarget)) { JavascriptError::ThrowTypeError(scriptContext, JSERR_NeedConstructor, _u("newTarget")); } } else { newTarget = target; } } RecyclableObject* thisArg = RecyclableObject::FromVar(undefinedValue); if (newTarget != nullptr) { thisArg = JavascriptOperators::CreateFromConstructor(RecyclableObject::FromVar(newTarget), scriptContext); } Var argArray = args.Info.Count > 2 ? args[2] : undefinedValue; return JavascriptFunction::ConstructHelper(RecyclableObject::FromVar(target), thisArg, newTarget, argArray, scriptContext); }
Var SIMDInt8x16Lib::EntryFromUint8x16Bits(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'"); Assert(!(callInfo.Flags & CallFlags_New)); if (args.Info.Count >= 2 && JavascriptSIMDUint8x16::Is(args[1])) { JavascriptSIMDUint8x16 *instance = JavascriptSIMDUint8x16::FromVar(args[1]); return SIMDConvertTypeFromBits<JavascriptSIMDUint8x16, JavascriptSIMDInt8x16>(instance, scriptContext); } JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt8x16TypeMismatch, L"fromUint8x16Bits"); }
Var SIMDUint16x8Lib::EntrySplat(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'"); Assert(!(callInfo.Flags & CallFlags_New)); Var undefinedVar = scriptContext->GetLibrary()->GetUndefined(); uint16 value = JavascriptConversion::ToUInt16(args.Info.Count >= 2 ? args[1] : undefinedVar, scriptContext); SIMDValue lanes = SIMDInt16x8Operation::OpSplat(static_cast<int16>(value));; return JavascriptSIMDUint16x8::New(&lanes, scriptContext); }
Var JavascriptReflect::EntryDefineProperty(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); Var undefinedValue = scriptContext->GetLibrary()->GetUndefined(); AUTO_TAG_NATIVE_LIBRARY_ENTRY(function, callInfo, _u("Reflect.defineProperty")); AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'"); if (args.Info.Flags & CallFlags_New) { JavascriptError::ThrowTypeError(scriptContext, JSERR_ErrorOnNew, _u("Reflect.defineProperty")); } Var propertyKey, attributes; if (args.Info.Count < 2 || !JavascriptOperators::IsObject(args[1])) { JavascriptError::ThrowTypeError(scriptContext, JSERR_FunctionArgument_NeedObject, _u("Reflect.defineProperty")); } Var target = args[1]; propertyKey = args.Info.Count > 2 ? args[2] : undefinedValue; PropertyRecord const * propertyRecord; JavascriptConversion::ToPropertyKey(propertyKey, scriptContext, &propertyRecord); attributes = args.Info.Count > 3 ? args[3] : undefinedValue; PropertyDescriptor propertyDescriptor; if (!JavascriptOperators::ToPropertyDescriptor(attributes, &propertyDescriptor, scriptContext)) { JavascriptError::ThrowTypeError(scriptContext, JSERR_PropertyDescriptor_Invalid, scriptContext->GetPropertyName(propertyRecord->GetPropertyId())->GetBuffer()); } // If the object is HostDispatch try to invoke the operation remotely BOOL defineResult; if (JavascriptOperators::GetTypeId(target) == TypeIds_HostDispatch) { defineResult = RecyclableObject::FromVar(target)->InvokeBuiltInOperationRemotely(EntryDefineProperty, args, nullptr); } else { defineResult = JavascriptObject::DefineOwnPropertyHelper(RecyclableObject::FromVar(target), propertyRecord->GetPropertyId(), propertyDescriptor, scriptContext, false); } return scriptContext->GetLibrary()->GetTrueOrFalse(defineResult); }
// SharedArrayBuffer.prototype.byteLength Var SharedArrayBuffer::EntryGetterByteLength(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); Assert(!(callInfo.Flags & CallFlags_New)); if (args.Info.Count == 0 || !SharedArrayBuffer::Is(args[0])) { JavascriptError::ThrowTypeError(scriptContext, JSERR_NeedSharedArrayBufferObject); } SharedArrayBuffer* sharedArrayBuffer = SharedArrayBuffer::FromVar(args[0]); return JavascriptNumber::ToVar(sharedArrayBuffer->GetByteLength(), scriptContext); }
Var JavascriptError::NewErrorInstance(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); JavascriptError* pError = scriptContext->GetLibrary()->CreateError(); // Process the arguments for IE specific behaviors for numbers and description JavascriptString* descriptionString = nullptr; Var message; bool hasNumber = false; double number = 0; if (args.Info.Count >= 3) { hasNumber = true; number = JavascriptConversion::ToNumber(args[1], scriptContext); message = args[2]; descriptionString = JavascriptConversion::ToString(message, scriptContext); } else if (args.Info.Count == 2) { message = args[1]; descriptionString = JavascriptConversion::ToString(message, scriptContext); } else { hasNumber = true; message = scriptContext->GetLibrary()->GetUndefined(); descriptionString = scriptContext->GetLibrary()->GetEmptyString(); } Assert(descriptionString != nullptr); if (hasNumber) { JavascriptOperators::InitProperty(pError, PropertyIds::number, JavascriptNumber::ToVarNoCheck(number, scriptContext)); pError->SetNotEnumerable(PropertyIds::number); } JavascriptOperators::SetProperty(pError, pError, PropertyIds::description, descriptionString, scriptContext); pError->SetNotEnumerable(PropertyIds::description); Var newTarget = callInfo.Flags & CallFlags_NewTarget ? args.Values[args.Info.Count] : args[0]; return JavascriptError::NewInstance(function, pError, callInfo, newTarget, message); }
Var SIMDUint16x8Lib::EntryStore(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'"); Assert(!(callInfo.Flags & CallFlags_New)); if (args.Info.Count >= 4 && JavascriptSIMDUint16x8::Is(args[3])) { SIMD128TypedArrayStore<JavascriptSIMDUint16x8>(args[1], args[2], args[3], 8 * INT16_SIZE, scriptContext); return NULL; } JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInvalidArgType, _u("SIMD.Uint16x8.store")); }
Var WebAssemblyTable::EntryGetterLength(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); Assert(!(callInfo.Flags & CallFlags_New)); if (args.Info.Count == 0 || !WebAssemblyTable::Is(args[0])) { JavascriptError::ThrowTypeError(scriptContext, WASMERR_NeedTableObject); } WebAssemblyTable * table = WebAssemblyTable::FromVar(args[0]); return JavascriptNumber::ToVar(table->m_currentLength, scriptContext); }
Var SIMDInt32x4Lib::EntryFromFloat64x2(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'"); Assert(!(callInfo.Flags & CallFlags_New)); if (args.Info.Count >= 2 && JavascriptSIMDFloat64x2::Is(args[1])) { JavascriptSIMDFloat64x2 *instance = JavascriptSIMDFloat64x2::FromVar(args[1]); Assert(instance); return JavascriptSIMDInt32x4::FromFloat64x2(instance, scriptContext); } JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdInt32x4TypeMismatch, _u("fromFloat64x2")); }
Var SIMDFloat64x2Lib::EntryFloat64x2(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'"); Assert(!(callInfo.Flags & CallFlags_New)); // comment out to satisfy languager service -ls -stress run Var undefinedVar = scriptContext->GetLibrary()->GetUndefined(); double dSIMDX = JavascriptConversion::ToNumber(args.Info.Count >= 2 ? args[1] : undefinedVar, scriptContext); double dSIMDY = JavascriptConversion::ToNumber(args.Info.Count >= 3 ? args[2] : undefinedVar, scriptContext); SIMDValue lanes = SIMDFloat64x2Operation::OpFloat64x2(dSIMDX, dSIMDY); return JavascriptSIMDFloat64x2::New(&lanes, scriptContext); }
Var JavascriptSet::EntryClear(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); if (!JavascriptSet::Is(args[0])) { JavascriptError::ThrowTypeErrorVar(scriptContext, JSERR_NeedObjectOfType, _u("Set.prototype.clear"), _u("Set")); } JavascriptSet* set = JavascriptSet::FromVar(args[0]); set->Clear(); return scriptContext->GetLibrary()->GetUndefined(); }
Var JavascriptSet::EntrySizeGetter(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); if (!JavascriptSet::Is(args[0])) { JavascriptError::ThrowTypeErrorVar(scriptContext, JSERR_NeedObjectOfType, _u("Set.prototype.size"), _u("Set")); } JavascriptSet* set = JavascriptSet::FromVar(args[0]); int size = set->Size(); return JavascriptNumber::ToVar(size, scriptContext); }
Var ObjectPrototypeObject::Entry__proto__setter(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); Assert(!(callInfo.Flags & CallFlags_New)); ScriptContext* scriptContext = function->GetScriptContext(); // B.2.2.1.2 // set Object.prototype.__proto__ ( proto ) // The value of the [[Set]] attribute is a built-in function that takes an argument proto. It performs the following steps: #if !FLOATVAR // Mark temp number will stack allocate number that is used as the object ptr. // So we should box it before call ToObject on it. Var arg0 = JavascriptNumber::BoxStackNumber(args[0], scriptContext); #else Var arg0 = args[0]; #endif // 1. Let O be RequireObjectCoercible(this value). // 2. ReturnIfAbrupt(O). // 3. If Type(proto) is neither Object nor Null, return undefined. // 4. If Type(O) is not Object, return undefined. if (args.Info.Count < 1 || !JavascriptConversion::CheckObjectCoercible(arg0, scriptContext)) { JavascriptError::ThrowTypeError(scriptContext, JSERR_This_NeedObject, _u("Object.prototype.__proto__")); } else if (args.Info.Count < 2 || !JavascriptOperators::IsObjectOrNull(args[1]) || !JavascriptOperators::IsObject(arg0)) { return scriptContext->GetLibrary()->GetUndefined(); } RecyclableObject* object = RecyclableObject::FromVar(arg0); RecyclableObject* newPrototype = RecyclableObject::FromVar(args[1]); // 5. Let status be O.[[SetPrototypeOf]](proto). // 6. ReturnIfAbrupt(status). // 7. If status is false, throw a TypeError exception. JavascriptObject::ChangePrototype(object, newPrototype, /*shouldThrow*/true, scriptContext); // 8. Return undefined. return scriptContext->GetLibrary()->GetUndefined(); }
//Lane Access Var SIMDBool8x16Lib::EntryExtractLane(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'"); Assert(!(callInfo.Flags & CallFlags_New)); if (args.Info.Count >= 3 && JavascriptSIMDBool8x16::Is(args[1])) { // if value arg is missing, then it is undefined. Var laneVar = args.Info.Count >= 3 ? args[2] : scriptContext->GetLibrary()->GetUndefined(); bool result = (SIMDUtils::SIMD128ExtractLane<JavascriptSIMDBool8x16, 16, int8>(args[1], laneVar, scriptContext)) ? true : false; return JavascriptBoolean::ToVar(result, scriptContext); } JavascriptError::ThrowTypeError(scriptContext, JSERR_SimdBool8x16TypeMismatch, _u("ExtractLane")); }
Var JavascriptGeneratorFunction::EntryAsyncFunctionImplementation(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(stackArgs, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); JavascriptLibrary* library = scriptContext->GetLibrary(); RecyclableObject* prototype = scriptContext->GetLibrary()->GetNull(); // InterpreterStackFrame takes a pointer to the args, so copy them to the recycler heap // and use that buffer for this InterpreterStackFrame. Var* argsHeapCopy = RecyclerNewArray(scriptContext->GetRecycler(), Var, stackArgs.Info.Count); js_memcpy_s(argsHeapCopy, sizeof(Var) * stackArgs.Info.Count, stackArgs.Values, sizeof(Var) * stackArgs.Info.Count); Arguments heapArgs(callInfo, argsHeapCopy); JavascriptExceptionObject* e = nullptr; JavascriptPromiseResolveOrRejectFunction* resolve; JavascriptPromiseResolveOrRejectFunction* reject; JavascriptPromiseAsyncSpawnExecutorFunction* executor = library->CreatePromiseAsyncSpawnExecutorFunction( JavascriptPromise::EntryJavascriptPromiseAsyncSpawnExecutorFunction, scriptContext->GetLibrary()->CreateGenerator(heapArgs, JavascriptAsyncFunction::FromVar(function)->GetGeneratorVirtualScriptFunction(), prototype), stackArgs[0]); JavascriptPromise* promise = library->CreatePromise(); JavascriptPromise::InitializePromise(promise, &resolve, &reject, scriptContext); try { CALL_FUNCTION(executor, CallInfo(CallFlags_Value, 3), library->GetUndefined(), resolve, reject); } catch (JavascriptExceptionObject* ex) { e = ex; } if (e != nullptr) { JavascriptPromise::TryRejectWithExceptionObject(e, reject, scriptContext); } return promise; }
Var SIMDInt32x4Lib::EntryInt32x4(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); AssertMsg(args.Info.Count > 0, "Should always have implicit 'this'"); Assert(!(callInfo.Flags & CallFlags_New)); //comment out due to -ls -stress run Var undefinedVar = scriptContext->GetLibrary()->GetUndefined(); int intSIMDX = JavascriptConversion::ToInt32(args.Info.Count >= 2 ? args[1] : undefinedVar, scriptContext); int intSIMDY = JavascriptConversion::ToInt32(args.Info.Count >= 3 ? args[2] : undefinedVar, scriptContext); int intSIMDZ = JavascriptConversion::ToInt32(args.Info.Count >= 4 ? args[3] : undefinedVar, scriptContext); int intSIMDW = JavascriptConversion::ToInt32(args.Info.Count >= 5 ? args[4] : undefinedVar, scriptContext); SIMDValue lanes = SIMDInt32x4Operation::OpInt32x4(intSIMDX, intSIMDY, intSIMDZ, intSIMDW); return JavascriptSIMDInt32x4::New(&lanes, scriptContext); }
Var WebAssemblyMemory::EntryGetterBuffer(RecyclableObject* function, CallInfo callInfo, ...) { PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault); ARGUMENTS(args, callInfo); ScriptContext* scriptContext = function->GetScriptContext(); Assert(!(callInfo.Flags & CallFlags_New)); if (args.Info.Count == 0 || !WebAssemblyMemory::Is(args[0])) { JavascriptError::ThrowTypeError(scriptContext, WASMERR_NeedMemoryObject); } WebAssemblyMemory* memory = WebAssemblyMemory::FromVar(args[0]); Assert(ArrayBuffer::Is(memory->m_buffer)); return memory->m_buffer; }