dymokomi/luce-js
Source of release 0.6.0
0.6.0 / src / engine / weakref.lucb
#==============================================================================================
#
# weakref - WeakRef and FinalizationRegistry
#
# DESCRIPTION:
# Port of quickjs.c "WeakRef" (lines 61134-61424): the WeakRef objects, the
# FinalizationRegistry objects with their entries and cleanup jobs, and
# JS_AddIntrinsicWeakRef. Both kinds of holder are in the runtime's weakref_list;
# the collector calls weakref_delete_weakref / finrec_delete_weakref on them once
# it has found the dead targets (gc_remove_weak_objects). The weak reference
# primitives (js_weakref_new, js_weakref_is_live, js_weakref_free) are with WeakMap.
#
#==============================================================================================
# mark: WeakRef =================================================================================
## The data of a WeakRef object (JSWeakRefData).
struct WeakRefData:
var weakref_header: WeakRefHeader
var target: Value
## Finalizer of ClassId.weak_ref.
func js_weakref_finalizer(rt: Runtime*, val: Value):
let raw = js_get_opaque(val, (u32)ClassId.weak_ref) else return
let wrd = (WeakRefData*)raw
js_weakref_free(rt, wrd.target)
cutils.list_del(&wrd.weakref_header.link)
js_free_rt(rt, wrd)
## Called by the collector: forget the target once it is dead.
func weakref_delete_weakref(rt: Runtime*, wh: WeakRefHeader*):
let wrd = (WeakRefData*)((u8*)wh - memory.offset_of(WeakRefData, weakref_header))
if not js_weakref_is_live(wrd.target):
js_weakref_free(rt, wrd.target)
wrd.target = js_undefined()
## new WeakRef(target).
func js_weakref_constructor(ctx: Context*, new_target: Value, argc: i32, argv: Value*) -> Value!:
if js_is_undefined(new_target):
try js_throw_type_error(ctx, "constructor requires 'new'")
let arg = argv[0]
if not js_weakref_is_target(arg):
try js_throw_type_error(ctx, "invalid target")
let obj = try js_create_from_ctor(ctx, new_target, (u32)ClassId.weak_ref)
errdefer js_free_value(ctx, obj)
let wrd = (WeakRefData*)(try js_mallocz(ctx, memory.size_of(WeakRefData)))
wrd.target = js_weakref_new(ctx, arg)
wrd.weakref_header.weakref_type = WeakRefHeaderType.weakref
cutils.list_add_tail(&wrd.weakref_header.link, &ctx.rt.weakref_list)
js_set_opaque(obj, wrd)
return obj
## WeakRef.prototype.deref(): the target, or undefined once it was collected.
func js_weakref_deref(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
let wrd = (WeakRefData*)(try js_get_opaque2(ctx, this_val, (u32)ClassId.weak_ref))
if js_weakref_is_live(wrd.target):
return js_dup_value(ctx, wrd.target)
else:
return js_undefined()
let js_weakref_proto_funcs = [
CFunctionListEntry(name = "deref", def_type = def_cfunc, length = 0, generic = js_weakref_deref),
CFunctionListEntry(name = "[Symbol.toStringTag]", prop_flags = 1, def_type = def_prop_string, string_value = "WeakRef"),
]
let js_weakref_class_def: ClassShortDef[1] = [
ClassShortDef(atom_WeakRef, js_weakref_finalizer, none), # ClassId.weak_ref
]
# mark: FinalizationRegistry ====================================================================
## A registration of a FinalizationRegistry (JSFinRecEntry).
struct FinRecEntry:
var link: cutils.ListHead
## Weak.
var target: Value
var held_val: Value
## Weak; undefined when there is no unregister token.
var token: Value
## The data of a FinalizationRegistry object (JSFinalizationRegistryData).
struct FinalizationRegistryData:
var weakref_header: WeakRefHeader
## List of FinRecEntry.link.
var entries: cutils.ListHead
var realm: Context*
var cb: Value
# The FinRecEntry of the link `el`.
func finrec_entry(el: cutils.ListHead*) -> FinRecEntry*:
return (FinRecEntry*)((u8*)el - memory.offset_of(FinRecEntry, link))
## Finalizer of ClassId.finalization_registry.
func js_finrec_finalizer(rt: Runtime*, val: Value):
let raw = js_get_opaque(val, (u32)ClassId.finalization_registry) else return
let frd = (FinalizationRegistryData*)raw
var el = frd.entries.next else trap("js_finrec_finalizer: unlinked list")
while el != &frd.entries:
let el1 = el.next else trap("js_finrec_finalizer: unlinked list")
let fre = finrec_entry(el)
js_weakref_free(rt, fre.target)
js_weakref_free(rt, fre.token)
js_free_value_rt(rt, fre.held_val)
js_free_rt(rt, fre)
el = el1
js_free_value_rt(rt, frd.cb)
js_free_context(frd.realm)
cutils.list_del(&frd.weakref_header.link)
js_free_rt(rt, frd)
## Marking function of ClassId.finalization_registry: the held values, the callback and
## the realm are strong references.
func js_finrec_mark(rt: Runtime*, val: Value, mark_func: MarkFunc):
let raw = js_get_opaque(val, (u32)ClassId.finalization_registry) else return
let frd = (FinalizationRegistryData*)raw
var el = frd.entries.next else trap("js_finrec_mark: unlinked list")
while el != &frd.entries:
let fre = finrec_entry(el)
js_mark_value(rt, fre.held_val, mark_func)
el = el.next else trap("js_finrec_mark: unlinked list")
js_mark_value(rt, frd.cb, mark_func)
mark_func(rt, &frd.realm.header)
## The cleanup job of a dead target: `argv[0](argv[1])`.
func js_finrec_job(ctx: Context*, argc: i32, argv: Value*) -> Value!:
return try js_call(ctx, argv[0], js_undefined(), 1, &argv[1])
## Called by the collector: forget the dead unregister tokens, and queue the cleanup job
## of every entry whose target is dead.
func finrec_delete_weakref(rt: Runtime*, wh: WeakRefHeader*):
let frd = (FinalizationRegistryData*)((u8*)wh - memory.offset_of(FinalizationRegistryData, weakref_header))
var el = frd.entries.next else trap("finrec_delete_weakref: unlinked list")
while el != &frd.entries:
let el1 = el.next else trap("finrec_delete_weakref: unlinked list")
let fre = finrec_entry(el)
if not js_weakref_is_live(fre.token):
js_weakref_free(rt, fre.token)
fre.token = js_undefined()
if not js_weakref_is_live(fre.target):
var args: Value[2] = ---
args[0] = frd.cb
args[1] = fre.held_val
# no exception is raised to avoid recursing into the GC
js_enqueue_job2(frd.realm, js_finrec_job, 2, &args[0], true) catch: recover ()
js_weakref_free(rt, fre.target)
js_weakref_free(rt, fre.token)
js_free_value_rt(rt, fre.held_val)
cutils.list_del(&fre.link)
js_free_rt(rt, fre)
el = el1
## new FinalizationRegistry(callback).
func js_finrec_constructor(ctx: Context*, new_target: Value, argc: i32, argv: Value*) -> Value!:
if js_is_undefined(new_target):
try js_throw_type_error(ctx, "constructor requires 'new'")
let cb = argv[0]
if not js_is_function(ctx, cb):
try js_throw_type_error(ctx, "argument must be a function")
let obj = try js_create_from_ctor(ctx, new_target, (u32)ClassId.finalization_registry)
errdefer js_free_value(ctx, obj)
let frd = (FinalizationRegistryData*)(try js_mallocz(ctx, memory.size_of(FinalizationRegistryData)))
frd.weakref_header.weakref_type = WeakRefHeaderType.finrec
cutils.list_add_tail(&frd.weakref_header.link, &ctx.rt.weakref_list)
cutils.init_list_head(&frd.entries)
frd.realm = js_dup_context(ctx)
frd.cb = js_dup_value(ctx, cb)
js_set_opaque(obj, frd)
return obj
## FinalizationRegistry.prototype.register(target, heldValue[, unregisterToken]).
func js_finrec_register(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
let frd = (FinalizationRegistryData*)(try js_get_opaque2(ctx, this_val, (u32)ClassId.finalization_registry))
let target = argv[0]
let held_val = argv[1]
let token = argv[2] if argc > 2 else js_undefined()
if not js_weakref_is_target(target):
try js_throw_type_error(ctx, "invalid target")
if js_same_value(ctx, target, held_val):
try js_throw_type_error(ctx, "held value cannot be the target")
if not js_is_undefined(token) and not js_weakref_is_target(token):
try js_throw_type_error(ctx, "invalid unregister token")
let fre = (FinRecEntry*)(try js_malloc(ctx, memory.size_of(FinRecEntry)))
fre.target = js_weakref_new(ctx, target)
fre.held_val = js_dup_value(ctx, held_val)
fre.token = js_weakref_new(ctx, token)
cutils.list_add_tail(&fre.link, &frd.entries)
return js_undefined()
## FinalizationRegistry.prototype.unregister(token): remove the registrations made with
## `token`; whether there was one.
func js_finrec_unregister(ctx: Context*, this_val: Value, argc: i32, argv: Value*) -> Value!:
let frd = (FinalizationRegistryData*)(try js_get_opaque2(ctx, this_val, (u32)ClassId.finalization_registry))
let token = argv[0]
if not js_weakref_is_target(token):
try js_throw_type_error(ctx, "invalid unregister token")
var removed = false
var el = frd.entries.next else trap("js_finrec_unregister: unlinked list")
while el != &frd.entries:
let el1 = el.next else trap("js_finrec_unregister: unlinked list")
let fre = finrec_entry(el)
if js_weakref_is_live(fre.token) and js_same_value(ctx, fre.token, token):
js_weakref_free(ctx.rt, fre.target)
js_weakref_free(ctx.rt, fre.token)
js_free_value(ctx, fre.held_val)
cutils.list_del(&fre.link)
js_free(ctx, fre)
removed = true
el = el1
return js_new_bool(removed)
let js_finrec_proto_funcs = [
CFunctionListEntry(name = "register", def_type = def_cfunc, length = 2, generic = js_finrec_register),
CFunctionListEntry(name = "unregister", def_type = def_cfunc, length = 1, generic = js_finrec_unregister),
CFunctionListEntry(name = "[Symbol.toStringTag]", prop_flags = 1, def_type = def_prop_string, string_value = "FinalizationRegistry"),
]
let js_finrec_class_def: ClassShortDef[1] = [
ClassShortDef(atom_FinalizationRegistry, js_finrec_finalizer, js_finrec_mark), # ClassId.finalization_registry
]
# mark: The intrinsics ==========================================================================
## Add WeakRef and FinalizationRegistry to the global object, declaring their classes on
## first use (JS_AddIntrinsicWeakRef).
pub func js_add_intrinsic_weak_ref(ctx: Context*) -> !:
let rt = ctx.rt
# WeakRef
if not js_is_registered_class(rt, (u32)ClassId.weak_ref):
if init_class_range(rt, js_weakref_class_def, (i32)ClassId.weak_ref) != 0:
error(exception, "") # C returns -1 with no exception pending
var obj = try js_new_c_constructor_tables(ctx, (i32)ClassId.weak_ref, "WeakRef",
js_weakref_constructor, 1, CFunctionEnum.constructor_or_func, 0,
js_undefined(),
none,
js_weakref_proto_funcs,
0)
js_free_value(ctx, obj)
# FinalizationRegistry
if not js_is_registered_class(rt, (u32)ClassId.finalization_registry):
if init_class_range(rt, js_finrec_class_def, (i32)ClassId.finalization_registry) != 0:
error(exception, "") # C returns -1 with no exception pending
obj = try js_new_c_constructor_tables(ctx, (i32)ClassId.finalization_registry, "FinalizationRegistry",
js_finrec_constructor, 1, CFunctionEnum.constructor_or_func, 0,
js_undefined(),
none,
js_finrec_proto_funcs,
0)
js_free_value(ctx, obj)