Libraries/jerryscript/src/include/Jerryscript/Types.h

Go to the documentation of this file.

/****
 * Sming Framework Project - Open Source framework for high efficiency native ESP8266 development.
 * Created 2015 by Skurydin Alexey
 * http://github.com/SmingHub/Sming
 * All files of the Sming Core are provided under the LGPL v3 license.
 *
 * Types.h
 *
 * @author: Dec 2021 - Mikee47 <mike@sillyhouse.net>
 *
 */
 
#pragma once
 
#include <include/jerryscript.h>
#include ".typemaps.h"
#include <WString.h>
#include <WVector.h>
 
namespace Jerryscript
{
enum class Type {
#define XX(jt, t) t = jt,
    JERRY_VALUE_TYPE_MAP(XX)
#undef XX
};
 
enum class ErrorType {
#define XX(jt, t) t = jt,
    JERRY_ERROR_TYPE_MAP(XX)
#undef XX
};
 
enum class ObjectType {
#define XX(jt, t) t = jt,
    JERRY_OBJECT_TYPE_MAP(XX)
#undef XX
};
 
enum class FunctionType {
#define XX(jt, t) t = jt,
    JERRY_FUNCTION_TYPE_MAP(XX)
#undef XX
};
 
enum class Feature {
#define XX(jt, t) t = jt,
    JERRY_FEATURE_MAP(XX)
#undef XX
};
 
// ECMA values used where simple assignment or check is all that is required
#define JERRY_ECMA_MAP(XX)                                                                                             \
    XX(VALUE_EMPTY, 0x08)                                                                                              \
    XX(VALUE_FALSE, 0x28)                                                                                              \
    XX(VALUE_TRUE, 0x38)                                                                                               \
    XX(VALUE_UNDEFINED, 0x48)                                                                                          \
    XX(VALUE_NULL, 0x58)                                                                                               \
    XX(VALUE_TYPE_MASK, 0x07)                                                                                          \
    XX(TYPE_ERROR, 0x07)                                                                                               \
    XX(TYPE_OBJECT, 0x03)
 
enum class Ecma {
#define XX(name, value) name = value,
    JERRY_ECMA_MAP(XX)
#undef XX
};
 
struct OwnedValue {
    jerry_value_t value;
};
 
struct CopyValue {
    jerry_value_t value;
};
 
struct StringValue {
    jerry_value_t value;
};
 
struct Undefined {
    Undefined()
    {
    }
 
    const jerry_value_t value = jerry_value_t(Ecma::VALUE_UNDEFINED);
};
 
struct Null {
    Null()
    {
    }
 
    const jerry_value_t value = jerry_value_t(Ecma::VALUE_NULL);
};
 
class Object;
class Array;
class Callable;
 
class Value
{
public:
    using List = Vector<Value>;
 
    Value()
    {
    }
 
    Value(const OwnedValue& value) : value(value.value)
    {
    }
 
    Value(const CopyValue& value) : value(jerry_acquire_value(value.value))
    {
    }
 
    Value(const StringValue& value) : value(jerry_value_to_string(value.value))
    {
    }
 
    Value(const Undefined& value) : value(value.value)
    {
    }
 
    Value(const Null& value) : value(value.value)
    {
    }
 
    Value(const Value& value) : Value(CopyValue{value.value})
    {
    }
 
    Value(Value&& value)
    {
        reset();
        std::swap(this->value, value.value);
    }
 
    Value(int value);
 
    Value(unsigned value);
 
    Value(double value) : value(jerry_create_number(value))
    {
    }
 
    Value(bool value) : value(jerry_create_boolean(value))
    {
    }
 
    Value(const String& s) : value(jerry_create_string_sz(reinterpret_cast<const jerry_char_t*>(s.c_str()), s.length()))
    {
    }
 
    Value(const char* s) : value(jerry_create_string(reinterpret_cast<const jerry_char_t*>(s)))
    {
    }
 
    Value(const FSTR::String& s) : Value(String(s))
    {
    }
    ~Value()
    {
        reset();
    }
 
    Value& operator=(const Value& value)
    {
        *this = CopyValue{value.value};
        return *this;
    }
 
    Value& operator=(Value&& value)
    {
        if(this != &value) {
            reset();
            std::swap(this->value, value.value);
        }
        return *this;
    }
 
    Value& reset(jerry_value_t value = jerry_value_t(Ecma::VALUE_EMPTY))
    {
        if(!isEmpty()) {
            jerry_release_value(this->value);
        }
        this->value = value;
        return *this;
    }
 
    const jerry_value_t& get() const
    {
        return value;
    }
 
    jerry_value_t& get()
    {
        return value;
    }
    jerry_value_t release()
    {
        auto res = value;
        value = jerry_value_t(Ecma::VALUE_EMPTY);
        return res;
    }
 
    bool isCallable() const
    {
        return jerry_value_is_function(value);
    }
 
    bool isArray() const
    {
        return jerry_value_is_array(value);
    }
 
    bool isError() const
    {
        return ecmaType() == Ecma::TYPE_ERROR;
    }
 
    bool isEmpty() const
    {
        return Ecma(value) == Ecma::VALUE_EMPTY;
    }
 
    bool isDefined() const
    {
        return Ecma(value) != Ecma::VALUE_UNDEFINED;
    }
 
    bool isBoolean() const
    {
        return jerry_value_is_boolean(value);
    }
 
    bool isFalse() const
    {
        return Ecma(value) == Ecma::VALUE_FALSE;
    }
 
    bool isTrue() const
    {
        return Ecma(value) == Ecma::VALUE_TRUE;
    }
 
    bool isNull() const
    {
        return Ecma(value) == Ecma::VALUE_NULL;
    }
 
    bool isString() const
    {
        return jerry_value_is_string(value);
    }
 
    bool isObject() const
    {
        return ecmaType() == Ecma::TYPE_OBJECT;
    }
 
    bool isNumber() const
    {
        return jerry_value_is_number(value);
    }
    Type type() const
    {
        return Type(jerry_value_get_type(value));
    }
 
    Object toObject() const;
 
    Value toString() const
    {
        return StringValue{value};
    }
 
    size_t readString(unsigned offset, char* buffer, size_t length) const;
 
    String subString(unsigned offset, size_t length) const;
 
    operator String() const;
 
    struct As {
        const Value& v;
 
        operator bool() const
        {
            return v.isTrue();
        }
 
        operator int() const
        {
            return jerry_value_as_int32(v.get());
        }
 
        operator unsigned() const
        {
            return jerry_value_as_uint32(v.get());
        }
 
        operator float() const
        {
            return jerry_get_number_value(v.get());
        }
 
        operator double() const
        {
            return jerry_get_number_value(v.get());
        }
 
        operator String() const
        {
            return String(v);
        }
    };
 
    template <typename T> T as() const
    {
        return T(As{*this});
    }
 
private:
    Ecma ecmaType() const
    {
        return Ecma(value & unsigned(Ecma::VALUE_TYPE_MASK));
    }
 
    jerry_value_t value{jerry_value_t(Ecma::VALUE_EMPTY)};
};
 
class ExternalFunction : public Value
{
public:
    ExternalFunction(jerry_external_handler_t handler) : Value(OwnedValue{jerry_create_external_function(handler)})
    {
    }
};
 
class Object : public Value
{
public:
    using List = Vector<Object>;
 
    struct NamedItem {
    public:
        const String& name() const
        {
            return mName;
        }
 
        operator Value() const
        {
            return mObject.getProperty(mName);
        }
 
        operator String() const
        {
            return operator Value();
        }
 
        NamedItem& operator=(const Value& value)
        {
            mObject.setProperty(mName, value);
            return *this;
        }
 
    private:
        friend class Object;
 
        NamedItem(Object& object, const String& name) : mObject(object), mName(name)
        {
        }
 
        Object& mObject;
        String mName;
    };
 
    using Value::Value;
 
    Object() : Value(OwnedValue{jerry_create_object()})
    {
    }
 
    Object(const Value& value) : Value(value)
    {
    }
 
    Object(Value&& value) : Value(std::move(value))
    {
    }
 
    NamedItem operator[](const String& name)
    {
        return NamedItem(*this, name);
    }
 
    const Value operator[](const String& name) const
    {
        return getProperty(name);
    }
 
    Value setProperty(const Value& name, const Value& value)
    {
        return OwnedValue{jerry_set_property(get(), name.get(), value.get())};
    }
 
    Value getProperty(const Value& name) const
    {
        return OwnedValue{jerry_get_property(get(), name.get())};
    }
 
    bool hasProperty(const Value& name) const
    {
        return jerry_has_property(get(), name.get());
    }
 
    bool removeProperty(const Value& name)
    {
        return jerry_delete_property(get(), name.get());
    }
    Array keys() const;
 
    Value runFunction(const String& name, Value& arg);
 
    Value runFunction(const String& name, std::initializer_list<Value> args = {});
 
    bool registerFunction(const String& name, jerry_external_handler_t handler)
    {
        auto res = setProperty(name, ExternalFunction(handler));
        return !res.isError();
    }
 
    bool unregisterFunction(const String& name)
    {
        return removeProperty(name);
    }
 
    Callable getFunction(const String& name);
};
 
class Error : public Value
{
public:
    using Value::Value;
 
    Error(ErrorType type) : Value(OwnedValue{jerry_create_error_sz(jerry_error_t(type), nullptr, 0)})
    {
    }
 
    Error(ErrorType type, const String& message)
        : Value(OwnedValue{jerry_create_error_sz(
              jerry_error_t(type), reinterpret_cast<const jerry_char_t*>(message.c_str()), message.length())})
    {
    }
    Error(const Value& value) : Value(value)
    {
    }
 
    Error(Value&& value) : Value(std::move(value))
    {
    }
 
    ErrorType errorType() const
    {
        return ErrorType(jerry_get_error_type(get()));
    }
 
    Value message() const;
 
    operator String() const;
};
 
class ArgumentError : public Error
{
public:
    ArgumentError(const String& functionName) : Error(ErrorType::Type, functionName + F(": Invalid arguments"))
    {
    }
};
 
class Array : public Object
{
public:
    class Iterator;
 
    struct IndexedItem {
    public:
        unsigned index() const
        {
            return mIndex;
        }
 
        operator Value() const
        {
            return mArray.getProperty(mIndex);
        }
 
        operator String() const
        {
            return operator Value();
        }
 
        IndexedItem& operator=(const Value& value)
        {
            mArray.setProperty(mIndex, value);
            return *this;
        }
 
        bool operator==(const IndexedItem& rhs) const
        {
            return &mArray == &rhs.mArray && mIndex == rhs.mIndex;
        }
 
    private:
        friend class Array;
        friend class Iterator;
 
        IndexedItem(Array& array, unsigned index) : mArray(array), mIndex(index)
        {
        }
 
        Array& mArray;
        unsigned mIndex;
    };
 
    class Iterator
    {
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type = IndexedItem;
        using difference_type = std::ptrdiff_t;
        using pointer = IndexedItem*;
        using reference = IndexedItem&;
 
        Iterator(const Iterator&) = default;
 
        Iterator(Array& array, unsigned index) : item(array, index)
        {
        }
 
        Iterator& operator++()
        {
            ++item.mIndex;
            return *this;
        }
 
        Iterator operator++(int)
        {
            Iterator tmp(*this);
            ++item.mIndex;
            return tmp;
        }
 
        Iterator operator+=(size_t distance)
        {
            Iterator tmp(*this);
            item.mIndex += distance;
            return tmp;
        }
 
        bool operator==(const Iterator& rhs) const
        {
            return item == rhs.item;
        }
 
        bool operator!=(const Iterator& rhs) const
        {
            return !operator==(rhs);
        }
 
        IndexedItem operator*()
        {
            return item;
        }
 
    private:
        IndexedItem item;
    };
 
    using Object::Object;
 
    Array(size_t size) : Object(OwnedValue{jerry_create_array(size)})
    {
    }
 
    size_t count() const
    {
        return jerry_get_array_length(get());
    }
 
    Iterator begin()
    {
        return Iterator(*this, 0);
    }
 
    Iterator end()
    {
        return Iterator(*this, count());
    }
    IndexedItem operator[](unsigned index)
    {
        return IndexedItem(*this, index);
    }
 
    const Value operator[](unsigned index) const
    {
        return getProperty(index);
    }
 
    Value getProperty(unsigned index) const
    {
        return OwnedValue{jerry_get_property_by_index(get(), index)};
    }
 
    Value setProperty(unsigned index, const Value& value)
    {
        return OwnedValue{jerry_set_property_by_index(get(), index, value.get())};
    }
};
 
class Callable : public Object
{
public:
    using List = Vector<Callable>;
 
    using Object::Object;
 
    Value call(const Object& thisValue, const Value& arg);
 
    Value call(const Object& thisValue, std::initializer_list<Value> args = {});
 
    FunctionType functionType() const
    {
        return FunctionType(jerry_function_get_type(get()));
    }
};
 
inline Object global()
{
    return OwnedValue{jerry_get_global_object()};
}
 
} // namespace Jerryscript
 
String toString(Jerryscript::Type type);
String toString(Jerryscript::ErrorType errorType);
String toString(Jerryscript::ObjectType objectType);
String toString(Jerryscript::FunctionType functionType);