set.c File Reference

#include <assert.h>
#include <math.h>
#include "jscript.h"
#include "wine/rbtree.h"
#include "wine/debug.h"

Include dependency graph for set.c:

Go to the source code of this file.

Classes
struct	MapInstance
struct	jsval_map_entry
struct	WeakMapInstance

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (jscript)
static int	jsval_map_compare (const void *k, const struct wine_rb_entry *e)
static HRESULT	get_map_this (script_ctx_t *ctx, jsval_t vthis, MapInstance **ret)
static HRESULT	get_set_this (script_ctx_t *ctx, jsval_t vthis, MapInstance **ret)
static struct jsval_map_entry *	get_map_entry (MapInstance *map, jsval_t key)
static void	grab_map_entry (struct jsval_map_entry *entry)
static void	release_map_entry (struct jsval_map_entry *entry)
static void	delete_map_entry (MapInstance *map, struct jsval_map_entry *entry)
static HRESULT	set_map_entry (MapInstance *map, jsval_t key, jsval_t value, jsval_t *r)
static HRESULT	iterate_map (MapInstance *map, script_ctx_t *ctx, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	Map_clear (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	Map_delete (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	Map_forEach (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	Map_get (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	Map_set (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	Map_has (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	Map_get_size (script_ctx_t *ctx, jsdisp_t *jsthis, jsval_t *r)
static HRESULT	Map_value (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static void	Map_destructor (jsdisp_t *dispex)
static HRESULT	Map_gc_traverse (struct gc_ctx *gc_ctx, enum gc_traverse_op op, jsdisp_t *dispex)
static HRESULT	Map_constructor (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	Set_add (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	Set_clear (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	Set_delete (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	Set_forEach (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	Set_has (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	Set_value (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	Set_constructor (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static int	weakmap_compare (const void *k, const struct rb_entry *e)
static HRESULT	get_weakmap_this (script_ctx_t *ctx, jsval_t vthis, WeakMapInstance **ret)
static struct weakmap_entry *	get_weakmap_entry (WeakMapInstance *weakmap, jsdisp_t *key)
void	remove_weakmap_entry (struct weakmap_entry *entry)
static HRESULT	WeakMap_clear (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	WeakMap_delete (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	WeakMap_get (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	WeakMap_set (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	WeakMap_has (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static HRESULT	WeakMap_value (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
static void	WeakMap_destructor (jsdisp_t *dispex)
static HRESULT	WeakMap_gc_traverse (struct gc_ctx *gc_ctx, enum gc_traverse_op op, jsdisp_t *dispex)
static HRESULT	WeakMap_constructor (script_ctx_t *ctx, jsval_t vthis, WORD flags, unsigned argc, jsval_t *argv, jsval_t *r)
HRESULT	init_set_constructor (script_ctx_t *ctx)

Variables
static const builtin_prop_t	Map_prototype_props []
static const builtin_prop_t	Map_props []
static const builtin_info_t	Map_prototype_info
static const builtin_info_t	Map_info
static const builtin_prop_t	Set_prototype_props []
static const builtin_info_t	Set_prototype_info
static const builtin_info_t	Set_info
static const builtin_prop_t	WeakMap_prototype_props []
static const builtin_info_t	WeakMap_prototype_info
static const builtin_info_t	WeakMap_info

Function Documentation

delete_map_entry()

static void delete_map_entry ( MapInstance *  map, struct jsval_map_entry *  entry  )

static

Definition at line 145 of file set.c.

{
    map->size--;
    wine_rb_remove(&map->map, &entry->entry);
    entry->deleted = TRUE;
    release_map_entry(entry);
}

Referenced by Map_clear(), Map_delete(), Set_clear(), and Set_delete().

get_map_entry()

static struct jsval_map_entry * get_map_entry ( MapInstance *  map, jsval_t  key  )

static

Definition at line 124 of file set.c.

{
    struct wine_rb_entry *entry;
    if(!(entry = wine_rb_get(&map->map, &key))) return NULL;
    return CONTAINING_RECORD(entry, struct jsval_map_entry, entry);
}

Referenced by Map_delete(), Map_get(), Map_has(), Set_delete(), Set_has(), and set_map_entry().

get_map_this()

static HRESULT get_map_this ( script_ctx_t *  ctx, jsval_t  vthis, MapInstance **  ret  )

static

Definition at line 94 of file set.c.

{
    jsdisp_t *jsdisp;
 
    if(!is_object_instance(vthis))
        return JS_E_OBJECT_EXPECTED;
    if(!(jsdisp = to_jsdisp(get_object(vthis))) || !is_class(jsdisp, JSCLASS_MAP)) {
        WARN("not a Map object passed as 'this'\n");
        return throw_error(ctx, JS_E_WRONG_THIS, L"Map");
    }
 
    *ret = CONTAINING_RECORD(jsdisp, MapInstance, dispex);
    return S_OK;
}

Referenced by Map_clear(), Map_delete(), Map_forEach(), Map_get(), Map_has(), and Map_set().

get_set_this()

static HRESULT get_set_this ( script_ctx_t *  ctx, jsval_t  vthis, MapInstance **  ret  )

static

Definition at line 109 of file set.c.

{
    jsdisp_t *jsdisp;
 
    if(!is_object_instance(vthis))
        return JS_E_OBJECT_EXPECTED;
    if(!(jsdisp = to_jsdisp(get_object(vthis))) || !is_class(jsdisp, JSCLASS_SET)) {
        WARN("not a Set object passed as 'this'\n");
        return throw_error(ctx, JS_E_WRONG_THIS, L"Set");
    }
 
    *ret = CONTAINING_RECORD(jsdisp, MapInstance, dispex);
    return S_OK;
}

Referenced by Set_add(), Set_clear(), Set_delete(), Set_forEach(), and Set_has().

get_weakmap_entry()

static struct weakmap_entry * get_weakmap_entry ( WeakMapInstance *  weakmap, jsdisp_t *  key  )

static

Definition at line 635 of file set.c.

{
    struct rb_entry *entry;
    if(!(entry = rb_get(&weakmap->map, key))) return NULL;
    return CONTAINING_RECORD(entry, struct weakmap_entry, entry);
}

Referenced by WeakMap_delete(), WeakMap_get(), WeakMap_has(), and WeakMap_set().

get_weakmap_this()

static HRESULT get_weakmap_this ( script_ctx_t *  ctx, jsval_t  vthis, WeakMapInstance **  ret  )

static

Definition at line 619 of file set.c.

{
    jsdisp_t *jsdisp;
 
    if(!is_object_instance(vthis))
        return JS_E_OBJECT_EXPECTED;
    if(!(jsdisp = to_jsdisp(get_object(vthis))) || !is_class(jsdisp, JSCLASS_WEAKMAP)) {
        WARN("not a WeakMap object passed as 'this'\n");
        throw_error(ctx, JS_E_WRONG_THIS, L"WeakMap");
        return DISP_E_EXCEPTION;
    }
 
    *ret = CONTAINING_RECORD(jsdisp, WeakMapInstance, dispex);
    return S_OK;
}

Referenced by WeakMap_clear(), WeakMap_delete(), WeakMap_get(), WeakMap_has(), and WeakMap_set().

grab_map_entry()

static void grab_map_entry ( struct jsval_map_entry *  entry )

static

Definition at line 131 of file set.c.

{
    entry->ref++;
}

Referenced by iterate_map(), and set_map_entry().

init_set_constructor()

HRESULT init_set_constructor

(

script_ctx_t *

ctx

)

Definition at line 894 of file set.c.

{
    jsdisp_t *constructor;
    HRESULT hres;
 
    if(ctx->version < SCRIPTLANGUAGEVERSION_ES6)
        return S_OK;
 
    hres = create_dispex(ctx, &Set_prototype_info, ctx->object_prototype, &ctx->set_prototype);
    if(FAILED(hres))
        return hres;
 
    hres = create_builtin_constructor(ctx, Set_constructor, L"Set", NULL,
                                      PROPF_CONSTR, ctx->set_prototype, &constructor);
    if(FAILED(hres))
        return hres;
 
    hres = jsdisp_define_data_property(ctx->global, L"Set", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                       jsval_obj(constructor));
    jsdisp_release(constructor);
    if(FAILED(hres))
        return hres;
 
    hres = create_dispex(ctx, &Map_prototype_info, ctx->object_prototype, &ctx->map_prototype);
    if(FAILED(hres))
        return hres;
 
    hres = create_builtin_constructor(ctx, Map_constructor, L"Map", NULL,
                                      PROPF_CONSTR, ctx->map_prototype, &constructor);
    if(FAILED(hres))
        return hres;
 
    hres = jsdisp_define_data_property(ctx->global, L"Map", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                       jsval_obj(constructor));
    jsdisp_release(constructor);
    if(FAILED(hres))
        return hres;
 
    hres = create_dispex(ctx, &WeakMap_prototype_info, ctx->object_prototype, &ctx->weakmap_prototype);
    if(FAILED(hres))
        return hres;
 
    hres = create_builtin_constructor(ctx, WeakMap_constructor, L"WeakMap", NULL,
                                      PROPF_CONSTR, ctx->weakmap_prototype, &constructor);
    if(FAILED(hres))
        return hres;
 
    hres = jsdisp_define_data_property(ctx->global, L"WeakMap", PROPF_CONFIGURABLE | PROPF_WRITABLE,
                                       jsval_obj(constructor));
    jsdisp_release(constructor);
    return hres;
}

Referenced by init_global().

iterate_map()

static HRESULT iterate_map ( MapInstance *  map, script_ctx_t *  ctx, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 189 of file set.c.

{
    struct list *iter = list_head(&map->entries);
    jsval_t context_this = jsval_undefined();
    HRESULT hres;
 
    if(!argc || !is_object_instance(argv[0])) {
        FIXME("invalid callback %s\n", debugstr_jsval(argc ? argv[0] : jsval_undefined()));
        return E_FAIL;
    }
 
    if(argc > 1)
        context_this = argv[1];
 
    while(iter) {
        struct jsval_map_entry *entry = LIST_ENTRY(iter, struct jsval_map_entry, list_entry);
        jsval_t args[3], v;
 
        if(entry->deleted) {
            iter = list_next(&map->entries, iter);
            continue;
        }
 
        args[0] = entry->value;
        args[1] = entry->key;
        args[2] = jsval_obj(&map->dispex);
        grab_map_entry(entry);
        hres = disp_call_value(ctx, get_object(argv[0]), context_this, DISPATCH_METHOD, ARRAY_SIZE(args), args, &v);
        iter = list_next(&map->entries, iter);
        release_map_entry(entry);
        if(FAILED(hres))
            return hres;
        jsval_release(v);
    }
 
    if(r) *r = jsval_undefined();
    return S_OK;
}

Referenced by Map_forEach(), and Set_forEach().

jsval_map_compare()

static int jsval_map_compare ( const void *  k, const struct wine_rb_entry *  e  )

static

Definition at line 56 of file set.c.

{
    const struct jsval_map_entry *entry = WINE_RB_ENTRY_VALUE(e, const struct jsval_map_entry, entry);
    const jsval_t *key = k;
    union {
        double d;
        INT64 n;
    } bits1, bits2;
 
    if(jsval_type(entry->key) != jsval_type(*key))
        return (int)jsval_type(entry->key) - (int)jsval_type(*key);
 
    switch(jsval_type(*key)) {
    case JSV_UNDEFINED:
    case JSV_NULL:
        return 0;
    case JSV_OBJECT:
        if(get_object(*key) == get_object(entry->key)) return 0;
        return get_object(*key) < get_object(entry->key) ? -1 : 1;
    case JSV_STRING:
        return jsstr_cmp(get_string(*key), get_string(entry->key));
    case JSV_NUMBER:
        if(isnan(get_number(*key))) return isnan(get_number(entry->key)) ? 0 : -1;
        if(isnan(get_number(entry->key))) return 1;
 
        /* native treats -0 differently than 0, so need to compare bitwise */
        bits1.d = get_number(*key);
        bits2.d = get_number(entry->key);
        return (bits1.n == bits2.n) ? 0 : (bits1.n < bits2.n ? -1 : 1);
    case JSV_BOOL:
        if(get_bool(*key) == get_bool(entry->key)) return 0;
        return get_bool(*key) ? 1 : -1;
    default:
        assert(0);
        return 0;
    }
}

Referenced by Map_constructor(), and Set_constructor().

Map_clear()

static HRESULT Map_clear ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 228 of file set.c.

{
    struct jsval_map_entry *entry, *entry2;
    MapInstance *map;
    HRESULT hres;
 
    hres = get_map_this(ctx, vthis, &map);
    if(FAILED(hres))
        return hres;
 
    TRACE("%p\n", map);
 
    LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &map->entries, struct jsval_map_entry, list_entry)
        delete_map_entry(map, entry);
 
    if(r) *r = jsval_undefined();
    return S_OK;
}

Map_constructor()

static HRESULT Map_constructor ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 422 of file set.c.

{
    MapInstance *map;
    HRESULT hres;
 
    switch(flags) {
    case DISPATCH_CONSTRUCT:
        TRACE("\n");
 
        if(!r)
            return S_OK;
        if(!(map = calloc(1, sizeof(*map))))
            return E_OUTOFMEMORY;
 
        hres = init_dispex(&map->dispex, ctx, &Map_info, ctx->map_prototype);
        if(FAILED(hres))
            return hres;
 
        wine_rb_init(&map->map, jsval_map_compare);
        list_init(&map->entries);
        *r = jsval_obj(&map->dispex);
        return S_OK;
 
    case DISPATCH_METHOD:
        return throw_error(ctx, JS_E_WRONG_THIS, L"Map");
 
    default:
        FIXME("unimplemented flags %x\n", flags);
        return E_NOTIMPL;
    }
}

Referenced by init_set_constructor().

Map_delete()

static HRESULT Map_delete ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 248 of file set.c.

{
    jsval_t key = argc >= 1 ? argv[0] : jsval_undefined();
    struct jsval_map_entry *entry;
    MapInstance *map;
    HRESULT hres;
 
    hres = get_map_this(ctx, vthis, &map);
    if(FAILED(hres))
        return hres;
 
    TRACE("%p (%s)\n", map, debugstr_jsval(key));
 
    if((entry = get_map_entry(map, key))) delete_map_entry(map, entry);
    if(r) *r = jsval_bool(!!entry);
    return S_OK;
}

Map_destructor()

static void Map_destructor ( jsdisp_t *  dispex )

static

Definition at line 357 of file set.c.

{
    MapInstance *map = (MapInstance*)dispex;
 
    while(!list_empty(&map->entries)) {
        struct jsval_map_entry *entry = LIST_ENTRY(list_head(&map->entries),
                                                   struct jsval_map_entry, list_entry);
        assert(!entry->deleted);
        release_map_entry(entry);
    }
}

Map_forEach()

static HRESULT Map_forEach ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 267 of file set.c.

{
    MapInstance *map;
    HRESULT hres;
 
    hres = get_map_this(ctx, vthis, &map);
    if(FAILED(hres))
        return hres;
 
    TRACE("%p (%s)\n", map, debugstr_jsval(argc >= 1 ? argv[0] : jsval_undefined()));
 
    return iterate_map(map, ctx, argc, argv, r);
}

Map_gc_traverse()

static HRESULT Map_gc_traverse ( struct gc_ctx *  gc_ctx, enum gc_traverse_op  op, jsdisp_t *  dispex  )

static

Definition at line 369 of file set.c.

{
    MapInstance *map = (MapInstance*)dispex;
    struct jsval_map_entry *entry, *entry2;
    HRESULT hres;
 
    if(op == GC_TRAVERSE_UNLINK) {
        LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &map->entries, struct jsval_map_entry, list_entry)
            release_map_entry(entry);
        wine_rb_destroy(&map->map, NULL, NULL);
        return S_OK;
    }
 
    LIST_FOR_EACH_ENTRY(entry, &map->entries, struct jsval_map_entry, list_entry) {
        hres = gc_process_linked_val(gc_ctx, op, dispex, &entry->key);
        if(FAILED(hres))
            return hres;
        hres = gc_process_linked_val(gc_ctx, op, dispex, &entry->value);
        if(FAILED(hres))
            return hres;
    }
    return S_OK;
}

Map_get()

static HRESULT Map_get ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 282 of file set.c.

{
    jsval_t key = argc >= 1 ? argv[0] : jsval_undefined();
    struct jsval_map_entry *entry;
    MapInstance *map;
    HRESULT hres;
 
    hres = get_map_this(ctx, vthis, &map);
    if(FAILED(hres))
        return hres;
 
    TRACE("%p (%s)\n", map, debugstr_jsval(key));
 
    if(!(entry = get_map_entry(map, key))) {
        if(r) *r = jsval_undefined();
        return S_OK;
    }
 
    return r ? jsval_copy(entry->value, r) : S_OK;
}

Map_get_size()

static HRESULT Map_get_size ( script_ctx_t *  ctx, jsdisp_t *  jsthis, jsval_t *  r  )

static

Definition at line 340 of file set.c.

{
    MapInstance *map = (MapInstance*)jsthis;
 
    TRACE("%p\n", map);
 
    *r = jsval_number(map->size);
    return S_OK;
}

Map_has()

static HRESULT Map_has ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 321 of file set.c.

{
    jsval_t key = argc >= 1 ? argv[0] : jsval_undefined();
    struct jsval_map_entry *entry;
    MapInstance *map;
    HRESULT hres;
 
    hres = get_map_this(ctx, vthis, &map);
    if(FAILED(hres))
        return hres;
 
    TRACE("%p (%s)\n", map, debugstr_jsval(key));
 
    entry = get_map_entry(map, key);
    if(r) *r = jsval_bool(!!entry);
    return S_OK;
}

Map_set()

static HRESULT Map_set ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 304 of file set.c.

{
    jsval_t key = argc >= 1 ? argv[0] : jsval_undefined();
    jsval_t value = argc >= 2 ? argv[1] : jsval_undefined();
    MapInstance *map;
    HRESULT hres;
 
    hres = get_map_this(ctx, vthis, &map);
    if(FAILED(hres))
        return hres;
 
    TRACE("%p (%s %s)\n", map, debugstr_jsval(key), debugstr_jsval(value));
 
    return set_map_entry(map, key, value, r);
}

Map_value()

static HRESULT Map_value ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 350 of file set.c.

{
    FIXME("\n");
    return E_NOTIMPL;
}

release_map_entry()

static void release_map_entry ( struct jsval_map_entry *  entry )

static

Definition at line 136 of file set.c.

{
    if(--entry->ref) return;
    jsval_release(entry->key);
    jsval_release(entry->value);
    list_remove(&entry->list_entry);
    free(entry);
}

Referenced by delete_map_entry(), iterate_map(), Map_destructor(), and Map_gc_traverse().

remove_weakmap_entry()

void remove_weakmap_entry

(

struct weakmap_entry *

entry

)

Definition at line 642 of file set.c.

{
    WeakMapInstance *weakmap = (WeakMapInstance*)entry->weakmap;
    struct list *next = entry->weak_refs_entry.next;
 
    if(next->next != &entry->weak_refs_entry)
        list_remove(&entry->weak_refs_entry);
    else {
        struct weak_refs_entry *weak_refs_entry = LIST_ENTRY(next, struct weak_refs_entry, list);
        entry->key->has_weak_refs = FALSE;
        rb_remove(&entry->key->ctx->thread_data->weak_refs, &weak_refs_entry->entry);
        free(weak_refs_entry);
    }
    rb_remove(&weakmap->map, &entry->entry);
    jsval_release(entry->value);
    free(entry);
}

Referenced by jsdisp_free(), WeakMap_clear(), WeakMap_delete(), WeakMap_destructor(), and WeakMap_gc_traverse().

Set_add()

static HRESULT Set_add ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 455 of file set.c.

{
    jsval_t key = argc ? argv[0] : jsval_undefined();
    MapInstance *set;
    HRESULT hres;
 
    hres = get_set_this(ctx, vthis, &set);
    if(FAILED(hres))
        return hres;
 
    TRACE("%p (%s)\n", set, debugstr_jsval(key));
 
    return set_map_entry(set, key, key, r);
}

Set_clear()

static HRESULT Set_clear ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 471 of file set.c.

{
    struct jsval_map_entry *entry, *entry2;
    MapInstance *set;
    HRESULT hres;
 
    hres = get_set_this(ctx, vthis, &set);
    if(FAILED(hres))
        return hres;
 
    TRACE("%p\n", set);
 
    LIST_FOR_EACH_ENTRY_SAFE(entry, entry2, &set->entries, struct jsval_map_entry, list_entry)
        delete_map_entry(set, entry);
 
    if(r) *r = jsval_undefined();
    return S_OK;
}

Set_constructor()

static HRESULT Set_constructor ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 575 of file set.c.

{
    MapInstance *set;
    HRESULT hres;
 
    switch(flags) {
    case DISPATCH_CONSTRUCT:
        TRACE("\n");
 
        if(!r)
            return S_OK;
        if(!(set = calloc(1, sizeof(*set))))
            return E_OUTOFMEMORY;
 
        hres = init_dispex(&set->dispex, ctx, &Set_info, ctx->set_prototype);
        if(FAILED(hres))
            return hres;
 
        wine_rb_init(&set->map, jsval_map_compare);
        list_init(&set->entries);
        *r = jsval_obj(&set->dispex);
        return S_OK;
 
    case DISPATCH_METHOD:
        return throw_error(ctx, JS_E_WRONG_THIS, L"Set");
 
    default:
        FIXME("unimplemented flags %x\n", flags);
        return E_NOTIMPL;
    }
}

Referenced by init_set_constructor().

Set_delete()

static HRESULT Set_delete ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 491 of file set.c.

{
    jsval_t key = argc ? argv[0] : jsval_undefined();
    struct jsval_map_entry *entry;
    MapInstance *set;
    HRESULT hres;
 
    hres = get_set_this(ctx, vthis, &set);
    if(FAILED(hres))
        return hres;
 
    TRACE("%p (%s)\n", set, debugstr_jsval(key));
 
    if((entry = get_map_entry(set, key))) delete_map_entry(set, entry);
    if(r) *r = jsval_bool(!!entry);
    return S_OK;
}

Set_forEach()

static HRESULT Set_forEach ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 510 of file set.c.

{
    MapInstance *set;
    HRESULT hres;
 
    hres = get_set_this(ctx, vthis, &set);
    if(FAILED(hres))
        return hres;
 
    TRACE("%p (%s)\n", set, debugstr_jsval(argc ? argv[0] : jsval_undefined()));
 
    return iterate_map(set, ctx, argc, argv, r);
}

Set_has()

static HRESULT Set_has ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 525 of file set.c.

{
    jsval_t key = argc ? argv[0] : jsval_undefined();
    struct jsval_map_entry *entry;
    MapInstance *set;
    HRESULT hres;
 
    hres = get_set_this(ctx, vthis, &set);
    if(FAILED(hres))
        return hres;
 
    TRACE("%p (%s)\n", set, debugstr_jsval(key));
 
    entry = get_map_entry(set, key);
    if(r) *r = jsval_bool(!!entry);
    return S_OK;
}

set_map_entry()

static HRESULT set_map_entry ( MapInstance *  map, jsval_t  key, jsval_t  value, jsval_t *  r  )

static

Definition at line 153 of file set.c.

{
    struct jsval_map_entry *entry;
    HRESULT hres;
 
    if((entry = get_map_entry(map, key))) {
        jsval_t val;
        hres = jsval_copy(value, &val);
        if(FAILED(hres))
            return hres;
 
        jsval_release(entry->value);
        entry->value = val;
    }else {
        if(!(entry = calloc(1, sizeof(*entry)))) return E_OUTOFMEMORY;
 
        hres = jsval_copy(key, &entry->key);
        if(SUCCEEDED(hres)) {
            hres = jsval_copy(value, &entry->value);
            if(FAILED(hres))
                jsval_release(entry->key);
        }
        if(FAILED(hres)) {
            free(entry);
            return hres;
        }
        grab_map_entry(entry);
        wine_rb_put(&map->map, &entry->key, &entry->entry);
        list_add_tail(&map->entries, &entry->list_entry);
        map->size++;
    }
 
    if(r) *r = jsval_undefined();
    return S_OK;
}

Referenced by Map_set(), and Set_add().

Set_value()

static HRESULT Set_value ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 544 of file set.c.

{
    FIXME("\n");
    return E_NOTIMPL;
}

WeakMap_clear()

static HRESULT WeakMap_clear ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 660 of file set.c.

{
    WeakMapInstance *weakmap;
    HRESULT hres;
 
    hres = get_weakmap_this(ctx, vthis, &weakmap);
    if(FAILED(hres))
        return hres;
 
    TRACE("%p\n", weakmap);
 
    while(weakmap->map.root)
        remove_weakmap_entry(RB_ENTRY_VALUE(weakmap->map.root, struct weakmap_entry, entry));
 
    if(r) *r = jsval_undefined();
    return S_OK;
}

weakmap_compare()

static int weakmap_compare ( const void *  k, const struct rb_entry *  e  )

static

Definition at line 613 of file set.c.

{
    ULONG_PTR a = (ULONG_PTR)k, b = (ULONG_PTR)RB_ENTRY_VALUE(e, const struct weakmap_entry, entry)->key;
    return (a > b) - (a < b);
}

Referenced by WeakMap_constructor().

WeakMap_constructor()

static HRESULT WeakMap_constructor ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 862 of file set.c.

{
    WeakMapInstance *weakmap;
    HRESULT hres;
 
    switch(flags) {
    case DISPATCH_CONSTRUCT:
        TRACE("\n");
 
        if(!r)
            return S_OK;
        if(!(weakmap = calloc(1, sizeof(*weakmap))))
            return E_OUTOFMEMORY;
 
        hres = init_dispex(&weakmap->dispex, ctx, &WeakMap_info, ctx->weakmap_prototype);
        if(FAILED(hres))
            return hres;
 
        rb_init(&weakmap->map, weakmap_compare);
        *r = jsval_obj(&weakmap->dispex);
        return S_OK;
 
    case DISPATCH_METHOD:
        return throw_error(ctx, JS_E_WRONG_THIS, L"WeakMap");
 
    default:
        FIXME("unimplemented flags %x\n", flags);
        return E_NOTIMPL;
    }
}

Referenced by init_set_constructor().

WeakMap_delete()

static HRESULT WeakMap_delete ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 679 of file set.c.

{
    jsdisp_t *key = (argc >= 1 && is_object_instance(argv[0])) ? to_jsdisp(get_object(argv[0])) : NULL;
    struct weakmap_entry *entry;
    WeakMapInstance *weakmap;
    HRESULT hres;
 
    hres = get_weakmap_this(ctx, vthis, &weakmap);
    if(FAILED(hres))
        return hres;
 
    TRACE("%p (%p)\n", weakmap, key);
 
    if((entry = get_weakmap_entry(weakmap, key)))
        remove_weakmap_entry(entry);
    if(r) *r = jsval_bool(!!entry);
    return S_OK;
}

WeakMap_destructor()

static void WeakMap_destructor ( jsdisp_t *  dispex )

static

Definition at line 806 of file set.c.

{
    WeakMapInstance *weakmap = (WeakMapInstance*)dispex;
 
    while(weakmap->map.root)
        remove_weakmap_entry(RB_ENTRY_VALUE(weakmap->map.root, struct weakmap_entry, entry));
}

WeakMap_gc_traverse()

static HRESULT WeakMap_gc_traverse ( struct gc_ctx *  gc_ctx, enum gc_traverse_op  op, jsdisp_t *  dispex  )

static

Definition at line 814 of file set.c.

{
    WeakMapInstance *weakmap = (WeakMapInstance*)dispex;
    struct weakmap_entry *entry;
    HRESULT hres;
 
    if(op == GC_TRAVERSE_UNLINK) {
        while(weakmap->map.root)
            remove_weakmap_entry(RB_ENTRY_VALUE(weakmap->map.root, struct weakmap_entry, entry));
        return S_OK;
    }
 
    RB_FOR_EACH_ENTRY(entry, &weakmap->map, struct weakmap_entry, entry) {
        /* Only traverse the values if the key turned out to be alive, which means it might not have traversed
           the associated values with it from this WeakMap yet (because it wasn't considered alive back then).
           We need both the key and the WeakMap for the entry to actually be accessible (and thus traversed). */
        if(op == GC_TRAVERSE && entry->key->gc_marked)
            continue;
 
        hres = gc_process_linked_val(gc_ctx, op, dispex, &entry->value);
        if(FAILED(hres))
            return hres;
    }
    return S_OK;
}

WeakMap_get()

static HRESULT WeakMap_get ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 699 of file set.c.

{
    jsdisp_t *key = (argc >= 1 && is_object_instance(argv[0])) ? to_jsdisp(get_object(argv[0])) : NULL;
    struct weakmap_entry *entry;
    WeakMapInstance *weakmap;
    HRESULT hres;
 
    hres = get_weakmap_this(ctx, vthis, &weakmap);
    if(FAILED(hres))
        return hres;
 
    TRACE("%p (%p)\n", weakmap, key);
 
    if(!(entry = get_weakmap_entry(weakmap, key))) {
        if(r) *r = jsval_undefined();
        return S_OK;
    }
 
    return r ? jsval_copy(entry->value, r) : S_OK;
}

WeakMap_has()

static HRESULT WeakMap_has ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 782 of file set.c.

{
    jsdisp_t *key = (argc >= 1 && is_object_instance(argv[0])) ? to_jsdisp(get_object(argv[0])) : NULL;
    WeakMapInstance *weakmap;
    HRESULT hres;
 
    hres = get_weakmap_this(ctx, vthis, &weakmap);
    if(FAILED(hres))
        return hres;
 
    TRACE("%p (%p)\n", weakmap, key);
 
    if(r) *r = jsval_bool(!!get_weakmap_entry(weakmap, key));
    return S_OK;
}

WeakMap_set()

static HRESULT WeakMap_set ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 721 of file set.c.

{
    jsdisp_t *key = (argc >= 1 && is_object_instance(argv[0])) ? to_jsdisp(get_object(argv[0])) : NULL;
    jsval_t value = argc >= 2 ? argv[1] : jsval_undefined();
    struct weakmap_entry *entry;
    WeakMapInstance *weakmap;
    HRESULT hres;
 
    hres = get_weakmap_this(ctx, vthis, &weakmap);
    if(FAILED(hres))
        return hres;
 
    TRACE("%p (%p %s)\n", weakmap, key, debugstr_jsval(value));
 
    if(!key)
        return JS_E_KEY_NOT_OBJECT;
 
    if((entry = get_weakmap_entry(weakmap, key))) {
        jsval_t val;
        hres = jsval_copy(value, &val);
        if(FAILED(hres))
            return hres;
 
        jsval_release(entry->value);
        entry->value = val;
    }else {
        struct weak_refs_entry *weak_refs_entry;
 
        if(!(entry = malloc(sizeof(*entry))))
            return E_OUTOFMEMORY;
 
        hres = jsval_copy(value, &entry->value);
        if(FAILED(hres)) {
            free(entry);
            return hres;
        }
 
        if(key->has_weak_refs)
            weak_refs_entry = RB_ENTRY_VALUE(rb_get(&ctx->thread_data->weak_refs, key), struct weak_refs_entry, entry);
        else {
            if(!(weak_refs_entry = malloc(sizeof(*weak_refs_entry)))) {
                jsval_release(entry->value);
                free(entry);
                return E_OUTOFMEMORY;
            }
            rb_put(&ctx->thread_data->weak_refs, key, &weak_refs_entry->entry);
            list_init(&weak_refs_entry->list);
            key->has_weak_refs = TRUE;
        }
        list_add_tail(&weak_refs_entry->list, &entry->weak_refs_entry);
 
        entry->key = key;
        entry->weakmap = &weakmap->dispex;
        rb_put(&weakmap->map, key, &entry->entry);
    }
 
    if(r) *r = jsval_undefined();
    return S_OK;
}

WeakMap_value()

static HRESULT WeakMap_value ( script_ctx_t *  ctx, jsval_t  vthis, WORD  flags, unsigned  argc, jsval_t *  argv, jsval_t *  r  )

static

Definition at line 799 of file set.c.

{
    FIXME("\n");
    return E_NOTIMPL;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

jscript

)

Variable Documentation

Map_info

const builtin_info_t Map_info

static

Initial value:

= {
    .class       = JSCLASS_MAP,
    .call        = Map_value,
    .props_cnt   = ARRAY_SIZE(Map_props),
    .props       = Map_props,
    .destructor  = Map_destructor,
    .gc_traverse = Map_gc_traverse,
}

Definition at line 413 of file set.c.

Referenced by Map_constructor().

Map_props

const builtin_prop_t Map_props[]

static

Initial value:

= {
    {L"size",       NULL,0,        Map_get_size, builtin_set_const},
}

Definition at line 402 of file set.c.

Map_prototype_info

const builtin_info_t Map_prototype_info

static

Initial value:

= {
    .class     = JSCLASS_OBJECT,
    .call      = Map_value,
    .props_cnt = ARRAY_SIZE(Map_prototype_props),
    .props     = Map_prototype_props,
}

Definition at line 406 of file set.c.

Referenced by init_set_constructor().

Map_prototype_props

const builtin_prop_t Map_prototype_props[]

static

Initial value:

= {
    {L"clear",      Map_clear,     PROPF_METHOD},
    {L"delete" ,    Map_delete,    PROPF_METHOD|1},
    {L"forEach",    Map_forEach,   PROPF_METHOD|1},
    {L"get",        Map_get,       PROPF_METHOD|1},
    {L"has",        Map_has,       PROPF_METHOD|1},
    {L"set",        Map_set,       PROPF_METHOD|2},
}

Definition at line 393 of file set.c.

Set_info

const builtin_info_t Set_info

static

Initial value:

= {
    .class       = JSCLASS_SET,
    .call        = Set_value,
    .props_cnt   = ARRAY_SIZE(Map_props),
    .props       = Map_props,
    .destructor  = Map_destructor,
    .gc_traverse = Map_gc_traverse,
}

Definition at line 566 of file set.c.

Referenced by Set_constructor().

Set_prototype_info

const builtin_info_t Set_prototype_info

static

Initial value:

= {
    .class     = JSCLASS_OBJECT,
    .call      = Set_value,
    .props_cnt = ARRAY_SIZE(Set_prototype_props),
    .props     = Set_prototype_props,
}

Definition at line 559 of file set.c.

Referenced by init_set_constructor().

Set_prototype_props

const builtin_prop_t Set_prototype_props[]

static

Initial value:

= {
    {L"add",        Set_add,       PROPF_METHOD|1},
    {L"clear",      Set_clear,     PROPF_METHOD},
    {L"delete" ,    Set_delete,    PROPF_METHOD|1},
    {L"forEach",    Set_forEach,   PROPF_METHOD|1},
    {L"has",        Set_has,       PROPF_METHOD|1},
}

Definition at line 551 of file set.c.

WeakMap_info

const builtin_info_t WeakMap_info

static

Initial value:

= {
    .class       = JSCLASS_WEAKMAP,
    .call        = WeakMap_value,
    .destructor  = WeakMap_destructor,
    .gc_traverse = WeakMap_gc_traverse,
}

Definition at line 855 of file set.c.

Referenced by WeakMap_constructor().

WeakMap_prototype_info

const builtin_info_t WeakMap_prototype_info

static

Initial value:

= {
    .class     = JSCLASS_OBJECT,
    .call      = WeakMap_value,
    .props_cnt = ARRAY_SIZE(WeakMap_prototype_props),
    .props     = WeakMap_prototype_props,
}

Definition at line 848 of file set.c.

Referenced by init_set_constructor().

WeakMap_prototype_props

const builtin_prop_t WeakMap_prototype_props[]

static

Initial value:

= {
    {L"clear",      WeakMap_clear,     PROPF_METHOD},
    {L"delete",     WeakMap_delete,    PROPF_METHOD|1},
    {L"get",        WeakMap_get,       PROPF_METHOD|1},
    {L"has",        WeakMap_has,       PROPF_METHOD|1},
    {L"set",        WeakMap_set,       PROPF_METHOD|2},
}

Definition at line 840 of file set.c.