diff options
Diffstat (limited to 'deps/v8/src/builtins/data-view.tq')
| -rw-r--r-- | deps/v8/src/builtins/data-view.tq | 951 |
1 files changed, 427 insertions, 524 deletions
diff --git a/deps/v8/src/builtins/data-view.tq b/deps/v8/src/builtins/data-view.tq index 874c122995..1e86f88d83 100644 --- a/deps/v8/src/builtins/data-view.tq +++ b/deps/v8/src/builtins/data-view.tq @@ -3,15 +3,14 @@ // found in the LICENSE file. module data_view { - extern operator '.buffer' - macro LoadArrayBufferViewBuffer(JSArrayBufferView): JSArrayBuffer; + macro LoadJSArrayBufferViewBuffer(JSArrayBufferView): JSArrayBuffer; extern operator '.byte_length' - macro LoadDataViewByteLength(JSDataView): Number; + macro LoadJSArrayBufferViewByteLength(JSArrayBufferView): uintptr; extern operator '.byte_offset' - macro LoadDataViewByteOffset(JSDataView): Number; + macro LoadJSArrayBufferViewByteOffset(JSArrayBufferView): uintptr; extern operator '.backing_store' - macro LoadArrayBufferBackingStore(JSArrayBuffer): RawPtr; + macro LoadJSArrayBufferBackingStore(JSArrayBuffer): RawPtr; macro MakeDataViewGetterNameString(kind: constexpr ElementsKind): String { if constexpr (kind == UINT8_ELEMENTS) { @@ -69,10 +68,10 @@ module data_view { return IsDetachedBuffer(view.buffer); } - macro ValidateDataView(context: Context, - o: Object, method: String): JSDataView { + macro ValidateDataView( + context: Context, o: Object, method: String): JSDataView { try { - return cast<JSDataView>(o) otherwise CastError; + return Cast<JSDataView>(o) otherwise CastError; } label CastError { ThrowTypeError(context, kIncompatibleMethodReceiver, method); @@ -82,35 +81,35 @@ module data_view { // ES6 section 24.2.4.1 get DataView.prototype.buffer javascript builtin DataViewPrototypeGetBuffer( context: Context, receiver: Object, ...arguments): JSArrayBuffer { - let data_view: JSDataView = ValidateDataView( - context, receiver, 'get DataView.prototype.buffer'); - return data_view.buffer; + let dataView: JSDataView = + ValidateDataView(context, receiver, 'get DataView.prototype.buffer'); + return dataView.buffer; } // ES6 section 24.2.4.2 get DataView.prototype.byteLength javascript builtin DataViewPrototypeGetByteLength( context: Context, receiver: Object, ...arguments): Number { - let data_view: JSDataView = ValidateDataView( + let dataView: JSDataView = ValidateDataView( context, receiver, 'get DataView.prototype.byte_length'); - if (WasNeutered(data_view)) { + if (WasNeutered(dataView)) { // TODO(bmeurer): According to the ES6 spec, we should throw a TypeError - // here if the JSArrayBuffer of the {data_view} was neutered. + // here if the JSArrayBuffer of the {dataView} was neutered. return 0; } - return data_view.byte_length; + return Convert<Number>(dataView.byte_length); } // ES6 section 24.2.4.3 get DataView.prototype.byteOffset javascript builtin DataViewPrototypeGetByteOffset( context: Context, receiver: Object, ...arguments): Number { - let data_view: JSDataView = ValidateDataView( + let dataView: JSDataView = ValidateDataView( context, receiver, 'get DataView.prototype.byte_offset'); - if (WasNeutered(data_view)) { + if (WasNeutered(dataView)) { // TODO(bmeurer): According to the ES6 spec, we should throw a TypeError - // here if the JSArrayBuffer of the {data_view} was neutered. + // here if the JSArrayBuffer of the {dataView} was neutered. return 0; } - return data_view.byte_offset; + return Convert<Number>(dataView.byte_offset); } extern macro BitcastInt32ToFloat32(uint32): float32; @@ -120,109 +119,110 @@ module data_view { extern macro Float64InsertLowWord32(float64, uint32): float64; extern macro Float64InsertHighWord32(float64, uint32): float64; - extern macro LoadUint8(RawPtr, intptr): uint32; - extern macro LoadInt8(RawPtr, intptr): int32; + extern macro LoadUint8(RawPtr, uintptr): uint32; + extern macro LoadInt8(RawPtr, uintptr): int32; - macro LoadDataView8(buffer: JSArrayBuffer, offset: intptr, - signed: constexpr bool): Smi { + macro LoadDataView8( + buffer: JSArrayBuffer, offset: uintptr, signed: constexpr bool): Smi { if constexpr (signed) { - return convert<Smi>(LoadInt8(buffer.backing_store, offset)); + return Convert<Smi>(LoadInt8(buffer.backing_store, offset)); } else { - return convert<Smi>(LoadUint8(buffer.backing_store, offset)); + return Convert<Smi>(LoadUint8(buffer.backing_store, offset)); } } - macro LoadDataView16(buffer: JSArrayBuffer, offset: intptr, - requested_little_endian: bool, - signed: constexpr bool): Number { - let data_pointer: RawPtr = buffer.backing_store; + macro LoadDataView16( + buffer: JSArrayBuffer, offset: uintptr, requestedLittleEndian: bool, + signed: constexpr bool): Number { + let dataPointer: RawPtr = buffer.backing_store; let b0: int32; let b1: int32; let result: int32; // Sign-extend the most significant byte by loading it as an Int8. - if (requested_little_endian) { - b0 = Signed(LoadUint8(data_pointer, offset)); - b1 = LoadInt8(data_pointer, offset + 1); + if (requestedLittleEndian) { + b0 = Signed(LoadUint8(dataPointer, offset)); + b1 = LoadInt8(dataPointer, offset + 1); result = (b1 << 8) + b0; } else { - b0 = LoadInt8(data_pointer, offset); - b1 = Signed(LoadUint8(data_pointer, offset + 1)); + b0 = LoadInt8(dataPointer, offset); + b1 = Signed(LoadUint8(dataPointer, offset + 1)); result = (b0 << 8) + b1; } if constexpr (signed) { - return convert<Smi>(result); + return Convert<Smi>(result); } else { // Bit-mask the higher bits to prevent sign extension if we're unsigned. - return convert<Smi>(result & 0xFFFF); + return Convert<Smi>(result & 0xFFFF); } } - macro LoadDataView32(buffer: JSArrayBuffer, offset: intptr, - requested_little_endian: bool, - kind: constexpr ElementsKind): Number { - let data_pointer: RawPtr = buffer.backing_store; + macro LoadDataView32( + buffer: JSArrayBuffer, offset: uintptr, requestedLittleEndian: bool, + kind: constexpr ElementsKind): Number { + let dataPointer: RawPtr = buffer.backing_store; - let b0: uint32 = LoadUint8(data_pointer, offset); - let b1: uint32 = LoadUint8(data_pointer, offset + 1); - let b2: uint32 = LoadUint8(data_pointer, offset + 2); - let b3: uint32 = LoadUint8(data_pointer, offset + 3); + let b0: uint32 = LoadUint8(dataPointer, offset); + let b1: uint32 = LoadUint8(dataPointer, offset + 1); + let b2: uint32 = LoadUint8(dataPointer, offset + 2); + let b3: uint32 = LoadUint8(dataPointer, offset + 3); let result: uint32; - if (requested_little_endian) { + if (requestedLittleEndian) { result = (b3 << 24) | (b2 << 16) | (b1 << 8) | b0; } else { result = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3; } if constexpr (kind == INT32_ELEMENTS) { - return convert<Number>(Signed(result)); + return Convert<Number>(Signed(result)); } else if constexpr (kind == UINT32_ELEMENTS) { - return convert<Number>(result); + return Convert<Number>(result); } else if constexpr (kind == FLOAT32_ELEMENTS) { - let float_res: float64 = convert<float64>(BitcastInt32ToFloat32(result)); - return convert<Number>(float_res); + let floatRes: float64 = Convert<float64>(BitcastInt32ToFloat32(result)); + return Convert<Number>(floatRes); } else { unreachable; } } - macro LoadDataViewFloat64(buffer: JSArrayBuffer, offset: intptr, - requested_little_endian: bool): Number { - let data_pointer: RawPtr = buffer.backing_store; - - let b0: uint32 = LoadUint8(data_pointer, offset); - let b1: uint32 = LoadUint8(data_pointer, offset + 1); - let b2: uint32 = LoadUint8(data_pointer, offset + 2); - let b3: uint32 = LoadUint8(data_pointer, offset + 3); - let b4: uint32 = LoadUint8(data_pointer, offset + 4); - let b5: uint32 = LoadUint8(data_pointer, offset + 5); - let b6: uint32 = LoadUint8(data_pointer, offset + 6); - let b7: uint32 = LoadUint8(data_pointer, offset + 7); - let low_word: uint32; - let high_word: uint32; - - if (requested_little_endian) { - low_word = (b3 << 24) | (b2 << 16) | (b1 << 8) | b0; - high_word = (b7 << 24) | (b6 << 16) | (b5 << 8) | b4; + macro LoadDataViewFloat64( + buffer: JSArrayBuffer, offset: uintptr, + requestedLittleEndian: bool): Number { + let dataPointer: RawPtr = buffer.backing_store; + + let b0: uint32 = LoadUint8(dataPointer, offset); + let b1: uint32 = LoadUint8(dataPointer, offset + 1); + let b2: uint32 = LoadUint8(dataPointer, offset + 2); + let b3: uint32 = LoadUint8(dataPointer, offset + 3); + let b4: uint32 = LoadUint8(dataPointer, offset + 4); + let b5: uint32 = LoadUint8(dataPointer, offset + 5); + let b6: uint32 = LoadUint8(dataPointer, offset + 6); + let b7: uint32 = LoadUint8(dataPointer, offset + 7); + let lowWord: uint32; + let highWord: uint32; + + if (requestedLittleEndian) { + lowWord = (b3 << 24) | (b2 << 16) | (b1 << 8) | b0; + highWord = (b7 << 24) | (b6 << 16) | (b5 << 8) | b4; } else { - high_word = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3; - low_word = (b4 << 24) | (b5 << 16) | (b6 << 8) | b7; + highWord = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3; + lowWord = (b4 << 24) | (b5 << 16) | (b6 << 8) | b7; } let result: float64 = 0; - result = Float64InsertLowWord32(result, low_word); - result = Float64InsertHighWord32(result, high_word); + result = Float64InsertLowWord32(result, lowWord); + result = Float64InsertHighWord32(result, highWord); - return convert<Number>(result); + return Convert<Number>(result); } extern macro AllocateBigInt(intptr): BigInt; extern macro StoreBigIntBitfield(BigInt, intptr): void; extern macro StoreBigIntDigit(BigInt, constexpr int31, uintptr): void; - extern macro DataViewEncodeBigIntBits(constexpr bool, - constexpr int31): intptr; + extern macro DataViewEncodeBigIntBits( + constexpr bool, constexpr int31): intptr; const kPositiveBigInt: constexpr bool = false; const kNegativeBigInt: constexpr bool = true; @@ -230,173 +230,168 @@ module data_view { const kOneDigitBigInt: constexpr int31 = 1; const kTwoDigitBigInt: constexpr int31 = 2; - macro CreateEmptyBigInt(is_positive: bool, length: constexpr int31): BigInt { + macro CreateEmptyBigInt(isPositive: bool, length: constexpr int31): BigInt { // Allocate a BigInt with the desired length (number of digits). let result: BigInt = AllocateBigInt(length); // Write the desired sign and length to the BigInt bitfield. - if (is_positive) { - StoreBigIntBitfield(result, - DataViewEncodeBigIntBits(kPositiveBigInt, length)); + if (isPositive) { + StoreBigIntBitfield( + result, DataViewEncodeBigIntBits(kPositiveBigInt, length)); } else { - StoreBigIntBitfield(result, - DataViewEncodeBigIntBits(kNegativeBigInt, length)); + StoreBigIntBitfield( + result, DataViewEncodeBigIntBits(kNegativeBigInt, length)); } return result; } // Create a BigInt on a 64-bit architecture from two 32-bit values. - macro MakeBigIntOn64Bit(low_word: uint32, high_word: uint32, - signed: constexpr bool): BigInt { - + macro MakeBigIntOn64Bit( + lowWord: uint32, highWord: uint32, signed: constexpr bool): BigInt { // 0n is represented by a zero-length BigInt. - if (low_word == 0 && high_word == 0) { + if (lowWord == 0 && highWord == 0) { return AllocateBigInt(kZeroDigitBigInt); } - let is_positive: bool = true; - let high_part: intptr = Signed(convert<uintptr>(high_word)); - let low_part: intptr = Signed(convert<uintptr>(low_word)); - let raw_value: intptr = (high_part << 32) + low_part; + let isPositive: bool = true; + let highPart: intptr = Signed(Convert<uintptr>(highWord)); + let lowPart: intptr = Signed(Convert<uintptr>(lowWord)); + let rawValue: intptr = (highPart << 32) + lowPart; if constexpr (signed) { - if (raw_value < 0) { - is_positive = false; - // We have to store the absolute value of raw_value in the digit. - raw_value = 0 - raw_value; + if (rawValue < 0) { + isPositive = false; + // We have to store the absolute value of rawValue in the digit. + rawValue = 0 - rawValue; } } // Allocate the BigInt and store the absolute value. - let result: BigInt = CreateEmptyBigInt(is_positive, kOneDigitBigInt); + let result: BigInt = CreateEmptyBigInt(isPositive, kOneDigitBigInt); - StoreBigIntDigit(result, 0, Unsigned(raw_value)); + StoreBigIntDigit(result, 0, Unsigned(rawValue)); return result; } // Create a BigInt on a 32-bit architecture from two 32-bit values. - macro MakeBigIntOn32Bit(low_word: uint32, high_word: uint32, - signed: constexpr bool): BigInt { - + macro MakeBigIntOn32Bit( + lowWord: uint32, highWord: uint32, signed: constexpr bool): BigInt { // 0n is represented by a zero-length BigInt. - if (low_word == 0 && high_word == 0) { + if (lowWord == 0 && highWord == 0) { return AllocateBigInt(kZeroDigitBigInt); } // On a 32-bit platform, we might need 1 or 2 digits to store the number. - let need_two_digits: bool = false; - let is_positive: bool = true; + let needTwoDigits: bool = false; + let isPositive: bool = true; - // We need to do some math on low_word and high_word, - // so convert them to int32. - let low_part: int32 = Signed(low_word); - let high_part: int32 = Signed(high_word); + // We need to do some math on lowWord and highWord, + // so Convert them to int32. + let lowPart: int32 = Signed(lowWord); + let highPart: int32 = Signed(highWord); - // If high_word == 0, the number is positive, and we only need 1 digit, + // If highWord == 0, the number is positive, and we only need 1 digit, // so we don't have anything to do. // Otherwise, all cases are possible. - if (high_word != 0) { + if (highWord != 0) { if constexpr (signed) { - - // If high_part < 0, the number is always negative. - if (high_part < 0) { - is_positive = false; + // If highPart < 0, the number is always negative. + if (highPart < 0) { + isPositive = false; // We have to compute the absolute value by hand. // There will be a negative carry from the low word // to the high word iff low != 0. - high_part = 0 - high_part; - if (low_part != 0) { - high_part = high_part - 1; + highPart = 0 - highPart; + if (lowPart != 0) { + highPart = highPart - 1; } - low_part = 0 - low_part; + lowPart = 0 - lowPart; - // Here, high_part could be 0 again so we might have 1 or 2 digits. - if (high_part != 0) { - need_two_digits = true; + // Here, highPart could be 0 again so we might have 1 or 2 digits. + if (highPart != 0) { + needTwoDigits = true; } } else { // In this case, the number is positive, and we need 2 digits. - need_two_digits = true; + needTwoDigits = true; } } else { // In this case, the number is positive (unsigned), // and we need 2 digits. - need_two_digits = true; + needTwoDigits = true; } } // Allocate the BigInt with the right sign and length. let result: BigInt; - if (need_two_digits) { - result = CreateEmptyBigInt(is_positive, kTwoDigitBigInt); + if (needTwoDigits) { + result = CreateEmptyBigInt(isPositive, kTwoDigitBigInt); } else { - result = CreateEmptyBigInt(is_positive, kOneDigitBigInt); + result = CreateEmptyBigInt(isPositive, kOneDigitBigInt); } // Finally, write the digit(s) to the BigInt. - StoreBigIntDigit(result, 0, Unsigned(convert<intptr>(low_part))); + StoreBigIntDigit(result, 0, Unsigned(Convert<intptr>(lowPart))); - if (need_two_digits) { - StoreBigIntDigit(result, 1, Unsigned(convert<intptr>(high_part))); + if (needTwoDigits) { + StoreBigIntDigit(result, 1, Unsigned(Convert<intptr>(highPart))); } return result; } - macro MakeBigInt(low_word: uint32, high_word: uint32, - signed: constexpr bool): BigInt { + macro MakeBigInt( + lowWord: uint32, highWord: uint32, signed: constexpr bool): BigInt { // A BigInt digit has the platform word size, so we only need one digit // on 64-bit platforms but may need two on 32-bit. if constexpr (Is64()) { - return MakeBigIntOn64Bit(low_word, high_word, signed); + return MakeBigIntOn64Bit(lowWord, highWord, signed); } else { - return MakeBigIntOn32Bit(low_word, high_word, signed); + return MakeBigIntOn32Bit(lowWord, highWord, signed); } } - macro LoadDataViewBigInt(buffer: JSArrayBuffer, offset: intptr, - requested_little_endian: bool, - signed: constexpr bool): BigInt { - let data_pointer: RawPtr = buffer.backing_store; - - let b0: uint32 = LoadUint8(data_pointer, offset); - let b1: uint32 = LoadUint8(data_pointer, offset + 1); - let b2: uint32 = LoadUint8(data_pointer, offset + 2); - let b3: uint32 = LoadUint8(data_pointer, offset + 3); - let b4: uint32 = LoadUint8(data_pointer, offset + 4); - let b5: uint32 = LoadUint8(data_pointer, offset + 5); - let b6: uint32 = LoadUint8(data_pointer, offset + 6); - let b7: uint32 = LoadUint8(data_pointer, offset + 7); - let low_word: uint32; - let high_word: uint32; - - if (requested_little_endian) { - low_word = (b3 << 24) | (b2 << 16) | (b1 << 8) | b0; - high_word = (b7 << 24) | (b6 << 16) | (b5 << 8) | b4; + macro LoadDataViewBigInt( + buffer: JSArrayBuffer, offset: uintptr, requestedLittleEndian: bool, + signed: constexpr bool): BigInt { + let dataPointer: RawPtr = buffer.backing_store; + + let b0: uint32 = LoadUint8(dataPointer, offset); + let b1: uint32 = LoadUint8(dataPointer, offset + 1); + let b2: uint32 = LoadUint8(dataPointer, offset + 2); + let b3: uint32 = LoadUint8(dataPointer, offset + 3); + let b4: uint32 = LoadUint8(dataPointer, offset + 4); + let b5: uint32 = LoadUint8(dataPointer, offset + 5); + let b6: uint32 = LoadUint8(dataPointer, offset + 6); + let b7: uint32 = LoadUint8(dataPointer, offset + 7); + let lowWord: uint32; + let highWord: uint32; + + if (requestedLittleEndian) { + lowWord = (b3 << 24) | (b2 << 16) | (b1 << 8) | b0; + highWord = (b7 << 24) | (b6 << 16) | (b5 << 8) | b4; } else { - high_word = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3; - low_word = (b4 << 24) | (b5 << 16) | (b6 << 8) | b7; + highWord = (b0 << 24) | (b1 << 16) | (b2 << 8) | b3; + lowWord = (b4 << 24) | (b5 << 16) | (b6 << 8) | b7; } - return MakeBigInt(low_word, high_word, signed); + return MakeBigInt(lowWord, highWord, signed); } - extern macro ToSmiIndex(Object, Context): Smi labels RangeError; + extern macro ToSmiIndex(Object, Context): Smi + labels RangeError; extern macro DataViewElementSize(constexpr ElementsKind): constexpr int31; - macro DataViewGet(context: Context, - receiver: Object, - offset: Object, - requested_little_endian: Object, - kind: constexpr ElementsKind): Numeric { - - let data_view: JSDataView = ValidateDataView( - context, receiver, MakeDataViewGetterNameString(kind)); + macro DataViewGet( + context: Context, receiver: Object, offset: Object, + requestedLittleEndian: Object, kind: constexpr ElementsKind): Numeric { + let dataView: JSDataView = + ValidateDataView(context, receiver, MakeDataViewGetterNameString(kind)); let getIndex: Number; try { @@ -406,28 +401,26 @@ module data_view { ThrowRangeError(context, kInvalidDataViewAccessorOffset); } - let littleEndian: bool = ToBoolean(requested_little_endian); - let buffer: JSArrayBuffer = data_view.buffer; + let littleEndian: bool = ToBoolean(requestedLittleEndian); + let buffer: JSArrayBuffer = dataView.buffer; if (IsDetachedBuffer(buffer)) { - ThrowTypeError(context, kDetachedOperation, - MakeDataViewGetterNameString(kind)); + ThrowTypeError( + context, kDetachedOperation, MakeDataViewGetterNameString(kind)); } - let viewOffset: Number = data_view.byte_offset; - let viewSize: Number = data_view.byte_length; - let elementSize: Number = DataViewElementSize(kind); + let getIndexFloat: float64 = Convert<float64>(getIndex); + let getIndexWord: uintptr = Convert<uintptr>(getIndexFloat); - if (getIndex + elementSize > viewSize) { + let viewOffsetWord: uintptr = dataView.byte_offset; + let viewSizeFloat: float64 = Convert<float64>(dataView.byte_length); + let elementSizeFloat: float64 = Convert<float64>(DataViewElementSize(kind)); + + if (getIndexFloat + elementSizeFloat > viewSizeFloat) { ThrowRangeError(context, kInvalidDataViewAccessorOffset); } - let getIndexFloat: float64 = convert<float64>(getIndex); - let getIndexIntptr: intptr = Signed(convert<uintptr>(getIndexFloat)); - let viewOffsetFloat: float64 = convert<float64>(viewOffset); - let viewOffsetIntptr: intptr = Signed(convert<uintptr>(viewOffsetFloat)); - - let bufferIndex: intptr = getIndexIntptr + viewOffsetIntptr; + let bufferIndex: uintptr = getIndexWord + viewOffsetWord; if constexpr (kind == UINT8_ELEMENTS) { return LoadDataView8(buffer, bufferIndex, false); @@ -455,201 +448,173 @@ module data_view { } javascript builtin DataViewPrototypeGetUint8( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - return DataViewGet(context, receiver, offset, Undefined, UINT8_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + return DataViewGet(context, receiver, offset, Undefined, UINT8_ELEMENTS); + } javascript builtin DataViewPrototypeGetInt8( context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; return DataViewGet(context, receiver, offset, Undefined, INT8_ELEMENTS); } javascript builtin DataViewPrototypeGetUint16( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let is_little_endian : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - return DataViewGet(context, receiver, offset, is_little_endian, - UINT16_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let isLittleEndian: Object = + arguments.length > 1 ? arguments[1] : Undefined; + return DataViewGet( + context, receiver, offset, isLittleEndian, UINT16_ELEMENTS); + } javascript builtin DataViewPrototypeGetInt16( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let is_little_endian : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - return DataViewGet(context, receiver, offset, is_little_endian, - INT16_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let isLittleEndian: Object = + arguments.length > 1 ? arguments[1] : Undefined; + return DataViewGet( + context, receiver, offset, isLittleEndian, INT16_ELEMENTS); + } javascript builtin DataViewPrototypeGetUint32( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let is_little_endian : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - return DataViewGet(context, receiver, offset, is_little_endian, - UINT32_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let isLittleEndian: Object = + arguments.length > 1 ? arguments[1] : Undefined; + return DataViewGet( + context, receiver, offset, isLittleEndian, UINT32_ELEMENTS); + } javascript builtin DataViewPrototypeGetInt32( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let is_little_endian : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - return DataViewGet(context, receiver, offset, is_little_endian, - INT32_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let isLittleEndian: Object = + arguments.length > 1 ? arguments[1] : Undefined; + return DataViewGet( + context, receiver, offset, isLittleEndian, INT32_ELEMENTS); + } javascript builtin DataViewPrototypeGetFloat32( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let is_little_endian : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - return DataViewGet(context, receiver, offset, is_little_endian, - FLOAT32_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let isLittleEndian: Object = + arguments.length > 1 ? arguments[1] : Undefined; + return DataViewGet( + context, receiver, offset, isLittleEndian, FLOAT32_ELEMENTS); + } javascript builtin DataViewPrototypeGetFloat64( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let is_little_endian : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - return DataViewGet(context, receiver, offset, is_little_endian, - FLOAT64_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let isLittleEndian: Object = + arguments.length > 1 ? arguments[1] : Undefined; + return DataViewGet( + context, receiver, offset, isLittleEndian, FLOAT64_ELEMENTS); + } javascript builtin DataViewPrototypeGetBigUint64( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let is_little_endian : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - return DataViewGet(context, receiver, offset, is_little_endian, - BIGUINT64_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let isLittleEndian: Object = + arguments.length > 1 ? arguments[1] : Undefined; + return DataViewGet( + context, receiver, offset, isLittleEndian, BIGUINT64_ELEMENTS); + } javascript builtin DataViewPrototypeGetBigInt64( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let is_little_endian : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - return DataViewGet(context, receiver, offset, is_little_endian, - BIGINT64_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let isLittleEndian: Object = + arguments.length > 1 ? arguments[1] : Undefined; + return DataViewGet( + context, receiver, offset, isLittleEndian, BIGINT64_ELEMENTS); + } extern macro ToNumber(Context, Object): Number; extern macro ToBigInt(Context, Object): BigInt; extern macro TruncateFloat64ToFloat32(float64): float32; extern macro TruncateFloat64ToWord32(float64): uint32; - extern macro StoreWord8(RawPtr, intptr, uint32): void; + extern macro StoreWord8(RawPtr, uintptr, uint32): void; - macro StoreDataView8(buffer: JSArrayBuffer, offset: intptr, - value: uint32) { + macro StoreDataView8(buffer: JSArrayBuffer, offset: uintptr, value: uint32) { StoreWord8(buffer.backing_store, offset, value & 0xFF); } - macro StoreDataView16(buffer: JSArrayBuffer, offset: intptr, value: uint32, - requested_little_endian: bool) { - let data_pointer: RawPtr = buffer.backing_store; + macro StoreDataView16( + buffer: JSArrayBuffer, offset: uintptr, value: uint32, + requestedLittleEndian: bool) { + let dataPointer: RawPtr = buffer.backing_store; let b0: uint32 = value & 0xFF; let b1: uint32 = (value >>> 8) & 0xFF; - if (requested_little_endian) { - StoreWord8(data_pointer, offset, b0); - StoreWord8(data_pointer, offset + 1, b1); + if (requestedLittleEndian) { + StoreWord8(dataPointer, offset, b0); + StoreWord8(dataPointer, offset + 1, b1); } else { - StoreWord8(data_pointer, offset, b1); - StoreWord8(data_pointer, offset + 1, b0); + StoreWord8(dataPointer, offset, b1); + StoreWord8(dataPointer, offset + 1, b0); } } - macro StoreDataView32(buffer: JSArrayBuffer, offset: intptr, value: uint32, - requested_little_endian: bool) { - let data_pointer: RawPtr = buffer.backing_store; + macro StoreDataView32( + buffer: JSArrayBuffer, offset: uintptr, value: uint32, + requestedLittleEndian: bool) { + let dataPointer: RawPtr = buffer.backing_store; let b0: uint32 = value & 0xFF; let b1: uint32 = (value >>> 8) & 0xFF; let b2: uint32 = (value >>> 16) & 0xFF; - let b3: uint32 = value >>> 24; // We don't need to mask here. + let b3: uint32 = value >>> 24; // We don't need to mask here. - if (requested_little_endian) { - StoreWord8(data_pointer, offset, b0); - StoreWord8(data_pointer, offset + 1, b1); - StoreWord8(data_pointer, offset + 2, b2); - StoreWord8(data_pointer, offset + 3, b3); + if (requestedLittleEndian) { + StoreWord8(dataPointer, offset, b0); + StoreWord8(dataPointer, offset + 1, b1); + StoreWord8(dataPointer, offset + 2, b2); + StoreWord8(dataPointer, offset + 3, b3); } else { - StoreWord8(data_pointer, offset, b3); - StoreWord8(data_pointer, offset + 1, b2); - StoreWord8(data_pointer, offset + 2, b1); - StoreWord8(data_pointer, offset + 3, b0); - } - } - - macro StoreDataView64(buffer: JSArrayBuffer, offset: intptr, - low_word: uint32, high_word: uint32, - requested_little_endian: bool) { - let data_pointer: RawPtr = buffer.backing_store; - - let b0: uint32 = low_word & 0xFF; - let b1: uint32 = (low_word >>> 8) & 0xFF; - let b2: uint32 = (low_word >>> 16) & 0xFF; - let b3: uint32 = low_word >>> 24; - - let b4: uint32 = high_word & 0xFF; - let b5: uint32 = (high_word >>> 8) & 0xFF; - let b6: uint32 = (high_word >>> 16) & 0xFF; - let b7: uint32 = high_word >>> 24; - - - if (requested_little_endian) { - StoreWord8(data_pointer, offset, b0); - StoreWord8(data_pointer, offset + 1, b1); - StoreWord8(data_pointer, offset + 2, b2); - StoreWord8(data_pointer, offset + 3, b3); - StoreWord8(data_pointer, offset + 4, b4); - StoreWord8(data_pointer, offset + 5, b5); - StoreWord8(data_pointer, offset + 6, b6); - StoreWord8(data_pointer, offset + 7, b7); + StoreWord8(dataPointer, offset, b3); + StoreWord8(dataPointer, offset + 1, b2); + StoreWord8(dataPointer, offset + 2, b1); + StoreWord8(dataPointer, offset + 3, b0); + } + } + + macro StoreDataView64( + buffer: JSArrayBuffer, offset: uintptr, lowWord: uint32, highWord: uint32, + requestedLittleEndian: bool) { + let dataPointer: RawPtr = buffer.backing_store; + + let b0: uint32 = lowWord & 0xFF; + let b1: uint32 = (lowWord >>> 8) & 0xFF; + let b2: uint32 = (lowWord >>> 16) & 0xFF; + let b3: uint32 = lowWord >>> 24; + + let b4: uint32 = highWord & 0xFF; + let b5: uint32 = (highWord >>> 8) & 0xFF; + let b6: uint32 = (highWord >>> 16) & 0xFF; + let b7: uint32 = highWord >>> 24; + + if (requestedLittleEndian) { + StoreWord8(dataPointer, offset, b0); + StoreWord8(dataPointer, offset + 1, b1); + StoreWord8(dataPointer, offset + 2, b2); + StoreWord8(dataPointer, offset + 3, b3); + StoreWord8(dataPointer, offset + 4, b4); + StoreWord8(dataPointer, offset + 5, b5); + StoreWord8(dataPointer, offset + 6, b6); + StoreWord8(dataPointer, offset + 7, b7); } else { - StoreWord8(data_pointer, offset, b7); - StoreWord8(data_pointer, offset + 1, b6); - StoreWord8(data_pointer, offset + 2, b5); - StoreWord8(data_pointer, offset + 3, b4); - StoreWord8(data_pointer, offset + 4, b3); - StoreWord8(data_pointer, offset + 5, b2); - StoreWord8(data_pointer, offset + 6, b1); - StoreWord8(data_pointer, offset + 7, b0); + StoreWord8(dataPointer, offset, b7); + StoreWord8(dataPointer, offset + 1, b6); + StoreWord8(dataPointer, offset + 2, b5); + StoreWord8(dataPointer, offset + 3, b4); + StoreWord8(dataPointer, offset + 4, b3); + StoreWord8(dataPointer, offset + 5, b2); + StoreWord8(dataPointer, offset + 6, b1); + StoreWord8(dataPointer, offset + 7, b0); } } @@ -660,55 +625,48 @@ module data_view { // We might get here a BigInt that is bigger than 64 bits, but we're only // interested in the 64 lowest ones. This means the lowest BigInt digit // on 64-bit platforms, and the 2 lowest BigInt digits on 32-bit ones. - macro StoreDataViewBigInt(buffer: JSArrayBuffer, offset: intptr, - bigint_value: BigInt, - requested_little_endian: bool) { - - let length: uintptr = DataViewDecodeBigIntLength(bigint_value); - let sign: uintptr = DataViewDecodeBigIntSign(bigint_value); + macro StoreDataViewBigInt( + buffer: JSArrayBuffer, offset: uintptr, bigIntValue: BigInt, + requestedLittleEndian: bool) { + let length: uintptr = DataViewDecodeBigIntLength(bigIntValue); + let sign: uintptr = DataViewDecodeBigIntSign(bigIntValue); // The 32-bit words that will hold the BigInt's value in // two's complement representation. - let low_word: uint32 = 0; - let high_word: uint32 = 0; + let lowWord: uint32 = 0; + let highWord: uint32 = 0; // The length is nonzero if and only if the BigInt's value is nonzero. if (length != 0) { if constexpr (Is64()) { // There is always exactly 1 BigInt digit to load in this case. - let value: uintptr = LoadBigIntDigit(bigint_value, 0); - low_word = convert<uint32>(value); // Truncates value to 32 bits. - high_word = convert<uint32>(value >>> 32); - } - else { // There might be either 1 or 2 BigInt digits we need to load. - low_word = convert<uint32>(LoadBigIntDigit(bigint_value, 0)); - if (length >= 2) { // Only load the second digit if there is one. - high_word = convert<uint32>(LoadBigIntDigit(bigint_value, 1)); + let value: uintptr = LoadBigIntDigit(bigIntValue, 0); + lowWord = Convert<uint32>(value); // Truncates value to 32 bits. + highWord = Convert<uint32>(value >>> 32); + } else { // There might be either 1 or 2 BigInt digits we need to load. + lowWord = Convert<uint32>(LoadBigIntDigit(bigIntValue, 0)); + if (length >= 2) { // Only load the second digit if there is one. + highWord = Convert<uint32>(LoadBigIntDigit(bigIntValue, 1)); } } } - if (sign != 0) { // The number is negative, convert it. - high_word = Unsigned(0 - Signed(high_word)); - if (low_word != 0) { - high_word = Unsigned(Signed(high_word) - 1); + if (sign != 0) { // The number is negative, Convert it. + highWord = Unsigned(0 - Signed(highWord)); + if (lowWord != 0) { + highWord = Unsigned(Signed(highWord) - 1); } - low_word = Unsigned(0 - Signed(low_word)); + lowWord = Unsigned(0 - Signed(lowWord)); } - StoreDataView64(buffer, offset, low_word, high_word, - requested_little_endian); + StoreDataView64(buffer, offset, lowWord, highWord, requestedLittleEndian); } - macro DataViewSet(context: Context, - receiver: Object, - offset: Object, - value: Object, - requested_little_endian: Object, - kind: constexpr ElementsKind): Object { - - let data_view: JSDataView = ValidateDataView( - context, receiver, MakeDataViewSetterNameString(kind)); + macro DataViewSet( + context: Context, receiver: Object, offset: Object, value: Object, + requestedLittleEndian: Object, kind: constexpr ElementsKind): Object { + let dataView: JSDataView = + ValidateDataView(context, receiver, MakeDataViewSetterNameString(kind)); let getIndex: Number; try { @@ -718,215 +676,160 @@ module data_view { ThrowRangeError(context, kInvalidDataViewAccessorOffset); } - let littleEndian: bool = ToBoolean(requested_little_endian); - let buffer: JSArrayBuffer = data_view.buffer; + let littleEndian: bool = ToBoolean(requestedLittleEndian); + let buffer: JSArrayBuffer = dataView.buffer; - let bigint_value: BigInt; - let num_value: Number; + let bigIntValue: BigInt; + let numValue: Number; // According to ES6 section 24.2.1.2 SetViewValue, we must perform // the conversion before doing the bounds check. if constexpr (kind == BIGUINT64_ELEMENTS || kind == BIGINT64_ELEMENTS) { - bigint_value = ToBigInt(context, value); + bigIntValue = ToBigInt(context, value); } else { - num_value = ToNumber(context, value); + numValue = ToNumber(context, value); } if (IsDetachedBuffer(buffer)) { - ThrowTypeError(context, kDetachedOperation, - MakeDataViewSetterNameString(kind)); + ThrowTypeError( + context, kDetachedOperation, MakeDataViewSetterNameString(kind)); } - let viewOffset: Number = data_view.byte_offset; - let viewSize: Number = data_view.byte_length; - let elementSize: Number = DataViewElementSize(kind); + let getIndexFloat: float64 = Convert<float64>(getIndex); + let getIndexWord: uintptr = Convert<uintptr>(getIndexFloat); + + let viewOffsetWord: uintptr = dataView.byte_offset; + let viewSizeFloat: float64 = Convert<float64>(dataView.byte_length); + let elementSizeFloat: float64 = Convert<float64>(DataViewElementSize(kind)); - if (getIndex + elementSize > viewSize) { + if (getIndexFloat + elementSizeFloat > viewSizeFloat) { ThrowRangeError(context, kInvalidDataViewAccessorOffset); } - let getIndexFloat: float64 = convert<float64>(getIndex); - let getIndexIntptr: intptr = Signed(convert<uintptr>(getIndexFloat)); - let viewOffsetFloat: float64 = convert<float64>(viewOffset); - let viewOffsetIntptr: intptr = Signed(convert<uintptr>(viewOffsetFloat)); - - let bufferIndex: intptr = getIndexIntptr + viewOffsetIntptr; + let bufferIndex: uintptr = getIndexWord + viewOffsetWord; if constexpr (kind == BIGUINT64_ELEMENTS || kind == BIGINT64_ELEMENTS) { - StoreDataViewBigInt(buffer, bufferIndex, bigint_value, - littleEndian); - } - else { - let double_value: float64 = ChangeNumberToFloat64(num_value); + StoreDataViewBigInt(buffer, bufferIndex, bigIntValue, littleEndian); + } else { + let doubleValue: float64 = ChangeNumberToFloat64(numValue); if constexpr (kind == UINT8_ELEMENTS || kind == INT8_ELEMENTS) { - StoreDataView8(buffer, bufferIndex, - TruncateFloat64ToWord32(double_value)); - } - else if constexpr (kind == UINT16_ELEMENTS || kind == INT16_ELEMENTS) { - StoreDataView16(buffer, bufferIndex, - TruncateFloat64ToWord32(double_value), littleEndian); - } - else if constexpr (kind == UINT32_ELEMENTS || kind == INT32_ELEMENTS) { - StoreDataView32(buffer, bufferIndex, - TruncateFloat64ToWord32(double_value), littleEndian); - } - else if constexpr (kind == FLOAT32_ELEMENTS) { - let float_value: float32 = TruncateFloat64ToFloat32(double_value); - StoreDataView32(buffer, bufferIndex, - BitcastFloat32ToInt32(float_value), littleEndian); - } - else if constexpr (kind == FLOAT64_ELEMENTS) { - let low_word: uint32 = Float64ExtractLowWord32(double_value); - let high_word: uint32 = Float64ExtractHighWord32(double_value); - StoreDataView64(buffer, bufferIndex, low_word, high_word, - littleEndian); + StoreDataView8( + buffer, bufferIndex, TruncateFloat64ToWord32(doubleValue)); + } else if constexpr (kind == UINT16_ELEMENTS || kind == INT16_ELEMENTS) { + StoreDataView16( + buffer, bufferIndex, TruncateFloat64ToWord32(doubleValue), + littleEndian); + } else if constexpr (kind == UINT32_ELEMENTS || kind == INT32_ELEMENTS) { + StoreDataView32( + buffer, bufferIndex, TruncateFloat64ToWord32(doubleValue), + littleEndian); + } else if constexpr (kind == FLOAT32_ELEMENTS) { + let floatValue: float32 = TruncateFloat64ToFloat32(doubleValue); + StoreDataView32( + buffer, bufferIndex, BitcastFloat32ToInt32(floatValue), + littleEndian); + } else if constexpr (kind == FLOAT64_ELEMENTS) { + let lowWord: uint32 = Float64ExtractLowWord32(doubleValue); + let highWord: uint32 = Float64ExtractHighWord32(doubleValue); + StoreDataView64(buffer, bufferIndex, lowWord, highWord, littleEndian); } } return Undefined; } javascript builtin DataViewPrototypeSetUint8( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let value : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - return DataViewSet(context, receiver, offset, value, Undefined, - UINT8_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let value: Object = arguments.length > 1 ? arguments[1] : Undefined; + return DataViewSet( + context, receiver, offset, value, Undefined, UINT8_ELEMENTS); + } javascript builtin DataViewPrototypeSetInt8( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let value : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - return DataViewSet(context, receiver, offset, value, Undefined, - INT8_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let value: Object = arguments.length > 1 ? arguments[1] : Undefined; + return DataViewSet( + context, receiver, offset, value, Undefined, INT8_ELEMENTS); + } javascript builtin DataViewPrototypeSetUint16( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let value : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - let is_little_endian : Object = arguments.length > 2 ? - arguments[2] : - Undefined; - return DataViewSet(context, receiver, offset, value, - is_little_endian, UINT16_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let value: Object = arguments.length > 1 ? arguments[1] : Undefined; + let isLittleEndian: Object = + arguments.length > 2 ? arguments[2] : Undefined; + return DataViewSet( + context, receiver, offset, value, isLittleEndian, UINT16_ELEMENTS); + } javascript builtin DataViewPrototypeSetInt16( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let value : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - let is_little_endian : Object = arguments.length > 2 ? - arguments[2] : - Undefined; - return DataViewSet(context, receiver, offset, value, - is_little_endian, INT16_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let value: Object = arguments.length > 1 ? arguments[1] : Undefined; + let isLittleEndian: Object = + arguments.length > 2 ? arguments[2] : Undefined; + return DataViewSet( + context, receiver, offset, value, isLittleEndian, INT16_ELEMENTS); + } javascript builtin DataViewPrototypeSetUint32( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let value : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - let is_little_endian : Object = arguments.length > 2 ? - arguments[2] : - Undefined; - return DataViewSet(context, receiver, offset, value, - is_little_endian, UINT32_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let value: Object = arguments.length > 1 ? arguments[1] : Undefined; + let isLittleEndian: Object = + arguments.length > 2 ? arguments[2] : Undefined; + return DataViewSet( + context, receiver, offset, value, isLittleEndian, UINT32_ELEMENTS); + } javascript builtin DataViewPrototypeSetInt32( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let value : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - let is_little_endian : Object = arguments.length > 2 ? - arguments[2] : - Undefined; - return DataViewSet(context, receiver, offset, value, - is_little_endian, INT32_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let value: Object = arguments.length > 1 ? arguments[1] : Undefined; + let isLittleEndian: Object = + arguments.length > 2 ? arguments[2] : Undefined; + return DataViewSet( + context, receiver, offset, value, isLittleEndian, INT32_ELEMENTS); + } javascript builtin DataViewPrototypeSetFloat32( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let value : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - let is_little_endian : Object = arguments.length > 2 ? - arguments[2] : - Undefined; - return DataViewSet(context, receiver, offset, value, - is_little_endian, FLOAT32_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let value: Object = arguments.length > 1 ? arguments[1] : Undefined; + let isLittleEndian: Object = + arguments.length > 2 ? arguments[2] : Undefined; + return DataViewSet( + context, receiver, offset, value, isLittleEndian, FLOAT32_ELEMENTS); + } javascript builtin DataViewPrototypeSetFloat64( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let value : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - let is_little_endian : Object = arguments.length > 2 ? - arguments[2] : - Undefined; - return DataViewSet(context, receiver, offset, value, - is_little_endian, FLOAT64_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let value: Object = arguments.length > 1 ? arguments[1] : Undefined; + let isLittleEndian: Object = + arguments.length > 2 ? arguments[2] : Undefined; + return DataViewSet( + context, receiver, offset, value, isLittleEndian, FLOAT64_ELEMENTS); + } javascript builtin DataViewPrototypeSetBigUint64( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let value : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - let is_little_endian : Object = arguments.length > 2 ? - arguments[2] : - Undefined; - return DataViewSet(context, receiver, offset, value, - is_little_endian, BIGUINT64_ELEMENTS); - } + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let value: Object = arguments.length > 1 ? arguments[1] : Undefined; + let isLittleEndian: Object = + arguments.length > 2 ? arguments[2] : Undefined; + return DataViewSet( + context, receiver, offset, value, isLittleEndian, BIGUINT64_ELEMENTS); + } javascript builtin DataViewPrototypeSetBigInt64( - context: Context, receiver: Object, ...arguments): Object { - let offset: Object = arguments.length > 0 ? - arguments[0] : - Undefined; - let value : Object = arguments.length > 1 ? - arguments[1] : - Undefined; - let is_little_endian : Object = arguments.length > 2 ? - arguments[2] : - Undefined; - return DataViewSet(context, receiver, offset, value, - is_little_endian, BIGINT64_ELEMENTS); - } - + context: Context, receiver: Object, ...arguments): Object { + let offset: Object = arguments.length > 0 ? arguments[0] : Undefined; + let value: Object = arguments.length > 1 ? arguments[1] : Undefined; + let isLittleEndian: Object = + arguments.length > 2 ? arguments[2] : Undefined; + return DataViewSet( + context, receiver, offset, value, isLittleEndian, BIGINT64_ELEMENTS); + } } |