diff --git a/Libraries/LibJS/Forward.h b/Libraries/LibJS/Forward.h index 35ebe608a5..53edcc48e4 100644 --- a/Libraries/LibJS/Forward.h +++ b/Libraries/LibJS/Forward.h @@ -69,6 +69,7 @@ class PrimitiveString; class ScopeNode; class Shape; class Statement; +class Uint8ClampedArray; class Value; enum class DeclarationKind; diff --git a/Libraries/LibJS/Makefile b/Libraries/LibJS/Makefile index 1434b82f84..7b84c3c845 100644 --- a/Libraries/LibJS/Makefile +++ b/Libraries/LibJS/Makefile @@ -43,6 +43,7 @@ OBJS = \ Runtime/StringConstructor.o \ Runtime/StringObject.o \ Runtime/StringPrototype.o \ + Runtime/Uint8ClampedArray.o \ Runtime/Value.o \ Token.o diff --git a/Libraries/LibJS/Runtime/Object.h b/Libraries/LibJS/Runtime/Object.h index 219e27e97f..c1f59e19b5 100644 --- a/Libraries/LibJS/Runtime/Object.h +++ b/Libraries/LibJS/Runtime/Object.h @@ -46,11 +46,11 @@ public: Shape& shape() { return *m_shape; } const Shape& shape() const { return *m_shape; } - Optional get_by_index(i32 property_index) const; + virtual Optional get_by_index(i32 property_index) const; Optional get(const FlyString& property_name) const; Optional get(PropertyName) const; - void put_by_index(i32 property_index, Value); + virtual void put_by_index(i32 property_index, Value); void put(const FlyString& property_name, Value); void put(PropertyName, Value); diff --git a/Libraries/LibJS/Runtime/Uint8ClampedArray.cpp b/Libraries/LibJS/Runtime/Uint8ClampedArray.cpp new file mode 100644 index 0000000000..5ae13688c3 --- /dev/null +++ b/Libraries/LibJS/Runtime/Uint8ClampedArray.cpp @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2020, Andreas Kling + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include + +namespace JS { + +Uint8ClampedArray* Uint8ClampedArray::create(GlobalObject& global_object, i32 length) +{ + ASSERT(length >= 0); + auto& interpreter = global_object.interpreter(); + return interpreter.heap().allocate(length, *global_object.array_prototype()); +} + +Uint8ClampedArray::Uint8ClampedArray(i32 length, Object& prototype) + : Object(&prototype) + , m_length(length) +{ + ASSERT(m_length >= 0); + put_native_property("length", length_getter, nullptr); + m_data = new u8[m_length]; +} + +Uint8ClampedArray::~Uint8ClampedArray() +{ + ASSERT(m_data); + delete[] m_data; + m_data = nullptr; +} + +Value Uint8ClampedArray::length_getter(Interpreter& interpreter) +{ + auto* this_object = interpreter.this_value().to_object(interpreter.heap()); + if (!this_object) + return {}; + if (StringView(this_object->class_name()) != "Uint8ClampedArray") + return interpreter.throw_exception("Not a Uint8ClampedArray"); + return Value(static_cast(this_object)->length()); +} + +void Uint8ClampedArray::put_by_index(i32 property_index, Value value) +{ + ASSERT(property_index >= 0); + ASSERT(property_index < m_length); + m_data[property_index] = clamp(value.to_i32(), 0, 255); +} + +Optional Uint8ClampedArray::get_by_index(i32 property_index) const +{ + ASSERT(property_index >= 0); + ASSERT(property_index < m_length); + return Value((i32)m_data[property_index]); +} + +} diff --git a/Libraries/LibJS/Runtime/Uint8ClampedArray.h b/Libraries/LibJS/Runtime/Uint8ClampedArray.h new file mode 100644 index 0000000000..393fa4d8ce --- /dev/null +++ b/Libraries/LibJS/Runtime/Uint8ClampedArray.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2020, Andreas Kling + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +#include + +namespace JS { + +class Uint8ClampedArray final : public Object { +public: + static Uint8ClampedArray* create(GlobalObject&, i32 length); + + Uint8ClampedArray(i32 length, Object& prototype); + virtual ~Uint8ClampedArray() override; + + i32 length() const { return m_length; } + + virtual void put_by_index(i32 property_index, Value value) override; + virtual Optional get_by_index(i32 property_index) const override; + + u8* data() { return m_data; } + const u8* data() const { return m_data; } + +private: + virtual const char* class_name() const override { return "Uint8ClampedArray"; } + virtual bool is_array() const override { return true; } + + static Value length_getter(Interpreter&); + + u8* m_data { nullptr }; + i32 m_length { 0 }; +}; + +}