mirror of
https://github.com/matrix-construct/construct
synced 2024-08-25 19:12:08 +02:00
411 lines
8.2 KiB
C++
411 lines
8.2 KiB
C++
// Matrix Construct
|
|
//
|
|
// Copyright (C) Matrix Construct Developers, Authors & Contributors
|
|
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
|
|
//
|
|
// Permission to use, copy, modify, and/or distribute this software for any
|
|
// purpose with or without fee is hereby granted, provided that the above
|
|
// copyright notice and this permission notice is present in all copies. The
|
|
// full license for this software is available in the LICENSE file.
|
|
|
|
#pragma once
|
|
#define HAVE_IRCD_JS_OBJECT_H
|
|
|
|
namespace ircd {
|
|
namespace js {
|
|
|
|
using object_handle = JS::Handle<JSObject *>;
|
|
using object_handle_mutable = JS::MutableHandle<JSObject *>;
|
|
|
|
// get()/set() et al overload on reserved{n} to manipulate reserved slot n
|
|
IRCD_STRONG_TYPEDEF(uint, reserved)
|
|
|
|
// Get the JSClass from which the trap can also be derived.
|
|
bool has_jsclass(const JSObject *const &);
|
|
const JSClass &jsclass(JSObject *const &);
|
|
|
|
// Get the flags from the object's JSClass or 0.
|
|
uint flags(const JSObject *const &);
|
|
|
|
// Get the `this` global from any object
|
|
JSObject *current_global(JSObject *const &);
|
|
|
|
// Misc utils
|
|
bool is_array(const object_handle &);
|
|
bool is_extensible(const object_handle &);
|
|
uint32_t size(const object_handle &);
|
|
bool deep_freeze(const object_handle &);
|
|
bool freeze(const object_handle &);
|
|
size_t bytecodes(const object_handle &, uint8_t *const &buf, const size_t &size);
|
|
|
|
struct object
|
|
:root<JSObject *>
|
|
{
|
|
IRCD_OVERLOAD(json)
|
|
IRCD_OVERLOAD(array)
|
|
IRCD_OVERLOAD(uninitialized)
|
|
|
|
using handle = object_handle;
|
|
using handle_mutable = object_handle_mutable;
|
|
|
|
explicit operator JSString *() const;
|
|
explicit operator JS::Value() const;
|
|
operator value() const;
|
|
|
|
object constructor() const; // Get the constructor
|
|
object prototype() const; // Get the prototype
|
|
void prototype(object::handle); // Set the prototype
|
|
|
|
bool is_array() const;
|
|
uint32_t size() const; // Number elements in array object
|
|
void resize(const uint32_t &); // Set the number of elements in array object
|
|
|
|
object clone() const; // Copy the object and prototype
|
|
|
|
// new object
|
|
object(const JSClass *const &, const handle &ctor, const JS::HandleValueArray &args);
|
|
object(const JSClass *const &, const JS::CallArgs &args);
|
|
object(const JSClass *const &, const object &proto);
|
|
object(const JSClass *const &);
|
|
|
|
object(const uint8_t *const &bytecode, const size_t &size);
|
|
using root<JSObject *>::root;
|
|
template<class... args> object(json_t, args&&...);
|
|
object(array_t, const size_t &length);
|
|
object(const JS::HandleValueArray &);
|
|
object(std::initializer_list<std::pair<const char *, value>>);
|
|
object(const value &);
|
|
object(JSObject *const &);
|
|
object(JSObject &);
|
|
object(nullptr_t);
|
|
object(uninitialized_t);
|
|
object();
|
|
|
|
static object global(); // current_global(cx)
|
|
};
|
|
|
|
inline
|
|
object::object()
|
|
:object::root::type
|
|
{
|
|
JS_NewPlainObject(*cx)
|
|
}
|
|
{
|
|
if(unlikely(!this->get()))
|
|
throw internal_error("NULL object (plain)");
|
|
}
|
|
|
|
inline
|
|
object::object(uninitialized_t)
|
|
:object::root::type{}
|
|
{
|
|
}
|
|
|
|
inline
|
|
object::object(nullptr_t)
|
|
:object{value{nullptr}}
|
|
{
|
|
}
|
|
|
|
inline
|
|
object::object(JSObject &obj)
|
|
:object::root::type{&obj}
|
|
{
|
|
if(unlikely(!this->get()))
|
|
throw internal_error("NULL object (ref)");
|
|
}
|
|
|
|
inline
|
|
object::object(JSObject *const &obj)
|
|
:object::root::type{obj}
|
|
{
|
|
if(unlikely(!this->get()))
|
|
throw internal_error("NULL object");
|
|
}
|
|
|
|
inline
|
|
object::object(const value &val)
|
|
:object::root::type{}
|
|
{
|
|
if(!JS_ValueToObject(*cx, val, &(*this)))
|
|
throw type_error("Value is not an Object");
|
|
}
|
|
|
|
inline
|
|
object::object(std::initializer_list<std::pair<const char *, value>> list)
|
|
:object{}
|
|
{
|
|
for(const auto &pair : list)
|
|
{
|
|
const auto &key(pair.first);
|
|
const auto &val(pair.second);
|
|
if(!JS_SetProperty(*cx, *this, key, val))
|
|
throw jserror(jserror::pending);
|
|
}
|
|
}
|
|
|
|
inline
|
|
object::object(const JS::HandleValueArray &values)
|
|
:object::root::type
|
|
{
|
|
JS_NewArrayObject(*cx, values)
|
|
}
|
|
{
|
|
if(unlikely(!this->get()))
|
|
throw internal_error("NULL object (array)");
|
|
}
|
|
|
|
inline
|
|
object::object(array_t,
|
|
const size_t &length)
|
|
:object::root::type
|
|
{
|
|
JS_NewArrayObject(*cx, length)
|
|
}
|
|
{
|
|
if(unlikely(!this->get()))
|
|
throw internal_error("NULL object (array)");
|
|
}
|
|
|
|
template<class... args>
|
|
object::object(json_t,
|
|
args&&... a)
|
|
:object(js::json::parse(std::forward<args>(a)...))
|
|
{
|
|
}
|
|
|
|
inline
|
|
object::object(const JSClass *const &clasp)
|
|
:object::root::type
|
|
{
|
|
JS_NewObject(*cx, clasp)
|
|
}
|
|
{
|
|
if(unlikely(!this->get()))
|
|
throw internal_error("NULL object (clasp)");
|
|
}
|
|
|
|
inline
|
|
object::object(const JSClass *const &clasp,
|
|
const object &proto)
|
|
:object::root::type
|
|
{
|
|
JS_NewObjectWithGivenProto(*cx, clasp, proto)
|
|
}
|
|
{
|
|
if(unlikely(!this->get()))
|
|
throw internal_error("NULL object (with given proto)");
|
|
}
|
|
|
|
inline
|
|
object::object(const JSClass *const &clasp,
|
|
const JS::CallArgs &args)
|
|
:object::root::type
|
|
{
|
|
JS_NewObjectForConstructor(*cx, clasp, args)
|
|
}
|
|
{
|
|
if(unlikely(!this->get()))
|
|
throw internal_error("NULL object (for constructor)");
|
|
}
|
|
|
|
inline
|
|
object::object(const JSClass *const &clasp,
|
|
const object::handle &ctor,
|
|
const JS::HandleValueArray &args)
|
|
:object::root::type
|
|
{
|
|
JS_New(*cx, ctor, args)
|
|
}
|
|
{
|
|
if(unlikely(!this->get()))
|
|
throw internal_error("NULL object (new)");
|
|
}
|
|
|
|
inline
|
|
object::object(const uint8_t *const &bytecode,
|
|
const size_t &size)
|
|
:object::root::type
|
|
{
|
|
//JS_DecodeInterpretedFunction(*cx, bytecode, size)
|
|
}
|
|
{
|
|
if(unlikely(!this->get()))
|
|
throw jserror(jserror::pending);
|
|
}
|
|
|
|
inline object
|
|
object::global()
|
|
{
|
|
return current_global();
|
|
}
|
|
|
|
inline object
|
|
object::clone()
|
|
const
|
|
{
|
|
return JS_CloneObject(*cx, *this, prototype());
|
|
}
|
|
|
|
inline void
|
|
object::resize(const uint32_t &length)
|
|
{
|
|
if(!JS_SetArrayLength(*cx, *this, length))
|
|
throw internal_error("Failed to set array object length");
|
|
}
|
|
|
|
inline uint32_t
|
|
object::size()
|
|
const
|
|
{
|
|
return js::size(*this);
|
|
}
|
|
|
|
inline bool
|
|
object::is_array()
|
|
const
|
|
{
|
|
return js::is_array(handle(*this));
|
|
}
|
|
|
|
inline object
|
|
object::constructor()
|
|
const
|
|
{
|
|
return JS_GetConstructor(*cx, *this);
|
|
}
|
|
|
|
inline void
|
|
object::prototype(object::handle obj)
|
|
{
|
|
if(!JS_SetPrototype(*cx, *this, obj))
|
|
throw internal_error("Failed to set prototype for object");
|
|
}
|
|
|
|
inline object
|
|
object::prototype()
|
|
const
|
|
{
|
|
object ret;
|
|
if(!JS_GetPrototype(*cx, *this, &ret))
|
|
throw internal_error("Failed to get prototype for object");
|
|
|
|
return ret;
|
|
}
|
|
|
|
inline
|
|
object::operator value()
|
|
const
|
|
{
|
|
return static_cast<JS::Value>(*this);
|
|
}
|
|
|
|
inline
|
|
object::operator JS::Value()
|
|
const
|
|
{
|
|
assert(this->get());
|
|
return JS::ObjectValue(*this->get());
|
|
}
|
|
|
|
inline
|
|
object::operator JSString *()
|
|
const
|
|
{
|
|
assert(this->get());
|
|
return JS_BasicObjectToString(*cx, *this);
|
|
}
|
|
|
|
inline size_t
|
|
bytecodes(const object_handle &obj,
|
|
uint8_t *const &buf,
|
|
const size_t &size)
|
|
{
|
|
uint32_t ret;
|
|
const custom_ptr<void> ptr
|
|
{
|
|
//JS_EncodeInterpretedFunction(*cx, obj, &ret), js_free
|
|
};
|
|
|
|
const auto cpsz(std::min(size_t(ret), size));
|
|
memcpy(buf, ptr.get(), cpsz);
|
|
return cpsz;
|
|
}
|
|
|
|
inline bool
|
|
freeze(const object_handle &obj)
|
|
{
|
|
return JS_FreezeObject(*cx, obj);
|
|
}
|
|
|
|
inline bool
|
|
deep_freeze(const object_handle &obj)
|
|
{
|
|
return JS_DeepFreezeObject(*cx, obj);
|
|
}
|
|
|
|
inline uint32_t
|
|
size(const object_handle &obj)
|
|
{
|
|
uint32_t ret;
|
|
if(!JS_GetArrayLength(*cx, obj, &ret))
|
|
throw internal_error("Failed to get array object length");
|
|
|
|
return ret;
|
|
}
|
|
|
|
inline bool
|
|
is_array(const object &obj)
|
|
{
|
|
return is_array(object::handle(obj));
|
|
}
|
|
|
|
inline bool
|
|
is_array(const object_handle &obj)
|
|
{
|
|
bool ret;
|
|
if(!JS_IsArrayObject(*cx, obj, &ret))
|
|
throw internal_error("Failed to query if object is array");
|
|
|
|
return ret;
|
|
}
|
|
|
|
inline bool
|
|
is_extensible(const object_handle &obj)
|
|
{
|
|
bool ret;
|
|
if(!JS_IsExtensible(*cx, obj, &ret))
|
|
throw internal_error("Failed to query object extensibility");
|
|
|
|
return ret;
|
|
}
|
|
|
|
inline JSObject *
|
|
current_global(JSObject *const &obj)
|
|
{
|
|
return JS_GetGlobalForObject(*cx, obj);
|
|
}
|
|
|
|
inline uint
|
|
flags(const JSObject *const &obj)
|
|
{
|
|
return has_jsclass(obj)? jsclass(const_cast<JSObject *>(obj)).flags : 0;
|
|
}
|
|
|
|
inline const JSClass &
|
|
jsclass(JSObject *const &obj)
|
|
{
|
|
assert(has_jsclass(obj));
|
|
const auto jsc(JS_GetClass(obj));
|
|
return *const_cast<JSClass *>(jsc);
|
|
}
|
|
|
|
inline bool
|
|
has_jsclass(const JSObject *const &obj)
|
|
{
|
|
assert(obj);
|
|
return JS_GetClass(const_cast<JSObject *>(obj)) != nullptr;
|
|
}
|
|
|
|
} // namespace js
|
|
} // namespace ircd
|