Attachment #756136 for bug #869996

Attachment #756136: final patch for bug #869996

View | Details | Raw Unified | Return to bug 869996
Collapse All | Expand All






const JSFunctionSpec MapObject::methods[] = {
    JS_FN("get", get, 1, 0),
    JS_FN("has", has, 1, 0),
    JS_FN("set", set, 2, 0),
    JS_FN("delete", delete_, 1, 0),
    JS_FN("keys", keys, 0, 0),
    JS_FN("values", values, 0, 0),
    JS_FN("entries", entries, 0, 0),
    JS_FN("iterator", entries, 0, 0),
    JS_FN("clear", clear, 0, 0),
    JS_FS_END
};

static JSObject *
InitClass(JSContext *cx, Handle<GlobalObject*> global, Class *clasp, JSProtoKey key, Native construct,
          const JSPropertySpec *properties, const JSFunctionSpec *methods)
{

    }
    return proto;
}

JSObject *
MapObject::initClass(JSContext *cx, JSObject *obj)
{
    Rooted<GlobalObject*> global(cx, &obj->asGlobal());
    RootedObject proto(cx,
        InitClass(cx, global, &class_, JSProto_Map, construct, properties, methods));
    if (proto) {
        // Define the "entries" method.
        JSFunction *fun = JS_DefineFunction(cx, proto, "entries", entries, 0, 0);
        if (!fun)
            return NULL;

        // Define its alias.
        RootedValue funval(cx, ObjectValue(*fun));
        if (!JS_DefineProperty(cx, proto, "iterator", funval, NULL, NULL, 0))
            return NULL;
    }
    return proto;
}

template <class Range>
static void
MarkKey(Range &r, const HashableValue &key, JSTracer *trc)
{
    HashableValue newKey = key.mark(trc);


}


/*** SetIterator *********************************************************************************/

class js::SetIteratorObject : public JSObject
{
  public:
    enum { TargetSlot, KindSlot, RangeSlot, SlotCount };
    static const JSFunctionSpec methods[];
    static SetIteratorObject *create(JSContext *cx, HandleObject setobj, ValueSet *data,
                                     SetObject::IteratorKind kind);
    static void finalize(FreeOp *fop, JSObject *obj);

  private:
    static inline bool is(const Value &v);
    inline ValueSet::Range *range();
    inline SetObject::IteratorKind kind() const;
    static bool next_impl(JSContext *cx, CallArgs args);
    static JSBool next(JSContext *cx, unsigned argc, Value *vp);
};

inline js::SetIteratorObject &
JSObject::asSetIterator()
{
    JS_ASSERT(isSetIterator());

};

inline ValueSet::Range *
SetIteratorObject::range()
{
    return static_cast<ValueSet::Range *>(getSlot(RangeSlot).toPrivate());
}

inline SetObject::IteratorKind
SetIteratorObject::kind() const
{
    int32_t i = getSlot(KindSlot).toInt32();
    JS_ASSERT(i == SetObject::Keys || i == SetObject::Values || i == SetObject::Entries);
    return SetObject::IteratorKind(i);
}

bool
GlobalObject::initSetIteratorProto(JSContext *cx, Handle<GlobalObject*> global)
{
    JSObject *base = global->getOrCreateIteratorPrototype(cx);
    if (!base)
        return false;
    RootedObject proto(cx, NewObjectWithGivenProto(cx, &SetIteratorClass, base, global));
    if (!proto)

    proto->setSlot(SetIteratorObject::RangeSlot, PrivateValue(NULL));
    if (!JS_DefineFunctions(cx, proto, SetIteratorObject::methods))
        return false;
    global->setReservedSlot(SET_ITERATOR_PROTO, ObjectValue(*proto));
    return true;
}

SetIteratorObject *
SetIteratorObject::create(JSContext *cx, HandleObject setobj, ValueSet *data,
                          SetObject::IteratorKind kind)
{
    Rooted<GlobalObject *> global(cx, &setobj->global());
    Rooted<JSObject*> proto(cx, global->getOrCreateSetIteratorPrototype(cx));
    if (!proto)
        return NULL;

    ValueSet::Range *range = cx->new_<ValueSet::Range>(data->all());
    if (!range)
        return NULL;

    JSObject *iterobj = NewObjectWithGivenProto(cx, &SetIteratorClass, proto, global);
    if (!iterobj) {
        js_delete(range);
        return NULL;
    }
    iterobj->setSlot(TargetSlot, ObjectValue(*setobj));
    iterobj->setSlot(KindSlot, Int32Value(int32_t(kind)));
    iterobj->setSlot(RangeSlot, PrivateValue(range));
    return static_cast<SetIteratorObject *>(iterobj);
}

void
SetIteratorObject::finalize(FreeOp *fop, JSObject *obj)
{
    fop->delete_(obj->asSetIterator().range());

    if (!range)
        return js_ThrowStopIteration(cx);
    if (range->empty()) {
        js_delete(range);
        thisobj.setReservedSlot(RangeSlot, PrivateValue(NULL));
        return js_ThrowStopIteration(cx);
    }

    switch (thisobj.kind()) {
        case SetObject::Values:
          args.rval().set(range->front().get());
          break;

        case SetObject::Entries: {
          Value pair[2] = { range->front().get(), range->front().get() };
          AutoValueArray root(cx, pair, 2);

          JSObject *pairobj = NewDenseCopiedArray(cx, 2, pair);
          if (!pairobj)
            return false;
          args.rval().setObject(*pairobj);
          break;
        }
    }

    range->popFront();
    return true;
}

JSBool
SetIteratorObject::next(JSContext *cx, unsigned argc, Value *vp)
{
    CallArgs args = CallArgsFromVp(argc, vp);

    JS_PSG("size", size, 0),
    JS_PS_END
};

const JSFunctionSpec SetObject::methods[] = {
    JS_FN("has", has, 1, 0),
    JS_FN("add", add, 1, 0),
    JS_FN("delete", delete_, 1, 0),
    JS_FN("entries", entries, 0, 0),
    JS_FN("clear", clear, 0, 0),
    JS_FS_END
};

JSObject *
SetObject::initClass(JSContext *cx, JSObject *obj)
{
    Rooted<GlobalObject*> global(cx, &obj->asGlobal());
    RootedObject proto(cx,
        InitClass(cx, global, &class_, JSProto_Set, construct, properties, methods));
    if (proto) {
        // Define the "values" method.
        JSFunction *fun = JS_DefineFunction(cx, proto, "values", values, 0, 0);
        if (!fun)
            return NULL;

        // Define its aliases.
        RootedValue funval(cx, ObjectValue(*fun));
        if (!JS_DefineProperty(cx, proto, "keys", funval, NULL, NULL, 0))
            return NULL;
        if (!JS_DefineProperty(cx, proto, "iterator", funval, NULL, NULL, 0))
            return NULL;
    }
    return proto;
}

void
SetObject::mark(JSTracer *trc, JSObject *obj)
{
    SetObject *setobj = static_cast<SetObject *>(obj);
    if (ValueSet *set = setobj->getData()) {
        for (ValueSet::Range r = set->all(); !r.empty(); r.popFront())

JSBool
SetObject::delete_(JSContext *cx, unsigned argc, Value *vp)
{
    CallArgs args = CallArgsFromVp(argc, vp);
    return CallNonGenericMethod<SetObject::is, SetObject::delete_impl>(cx, args);
}

bool
SetObject::iterator_impl(JSContext *cx, CallArgs args, IteratorKind kind)
{
    Rooted<SetObject*> setobj(cx, &args.thisv().toObject().asSet());
    ValueSet &set = *setobj->getData();
    Rooted<JSObject*> iterobj(cx, SetIteratorObject::create(cx, setobj, &set, kind));
    if (!iterobj)
        return false;
    args.rval().setObject(*iterobj);
    return true;
}

bool
SetObject::values_impl(JSContext *cx, CallArgs args)
{
    return iterator_impl(cx, args, Values);
}

JSBool
SetObject::values(JSContext *cx, unsigned argc, Value *vp)
{
    CallArgs args = CallArgsFromVp(argc, vp);
    return CallNonGenericMethod(cx, is, values_impl, args);
}

bool
SetObject::entries_impl(JSContext *cx, CallArgs args)
{
    return iterator_impl(cx, args, Entries);
}

JSBool
SetObject::entries(JSContext *cx, unsigned argc, Value *vp)
{
    CallArgs args = CallArgsFromVp(argc, vp);
    return CallNonGenericMethod(cx, is, entries_impl, args);
}

bool
SetObject::clear_impl(JSContext *cx, CallArgs args)
{
    Rooted<SetObject*> setobj(cx, &args.thisv().toObject().asSet());
    if (!setobj->getData()->clear()) {
        js_ReportOutOfMemory(cx);





    static bool entries_impl(JSContext *cx, CallArgs args);
    static JSBool entries(JSContext *cx, unsigned argc, Value *vp);
    static bool clear_impl(JSContext *cx, CallArgs args);
    static JSBool clear(JSContext *cx, unsigned argc, Value *vp);
};

class SetObject : public JSObject {
  public:
    enum IteratorKind { Values, Entries };
    static JSObject *initClass(JSContext *cx, JSObject *obj);
    static Class class_;
  private:
    static const JSPropertySpec properties[];
    static const JSFunctionSpec methods[];
    ValueSet *getData() { return static_cast<ValueSet *>(getPrivate()); }
    static ValueSet & extract(CallReceiver call);
    static void mark(JSTracer *trc, JSObject *obj);
    static void finalize(FreeOp *fop, JSObject *obj);
    static JSBool construct(JSContext *cx, unsigned argc, Value *vp);

    static bool is(const Value &v);

    static bool iterator_impl(JSContext *cx, CallArgs args, IteratorKind kind);

    static bool size_impl(JSContext *cx, CallArgs args);
    static JSBool size(JSContext *cx, unsigned argc, Value *vp);
    static bool has_impl(JSContext *cx, CallArgs args);
    static JSBool has(JSContext *cx, unsigned argc, Value *vp);
    static bool add_impl(JSContext *cx, CallArgs args);
    static JSBool add(JSContext *cx, unsigned argc, Value *vp);
    static bool delete_impl(JSContext *cx, CallArgs args);
    static JSBool delete_(JSContext *cx, unsigned argc, Value *vp);
    static bool values_impl(JSContext *cx, CallArgs args);
    static JSBool values(JSContext *cx, unsigned argc, Value *vp);
    static bool entries_impl(JSContext *cx, CallArgs args);
    static JSBool entries(JSContext *cx, unsigned argc, Value *vp);
    static bool clear_impl(JSContext *cx, CallArgs args);
    static JSBool clear(JSContext *cx, unsigned argc, Value *vp);
};

} /* namespace js */

extern JSObject *
js_InitMapClass(JSContext *cx, js::HandleObject obj);

(-)a/js/src/jit-test/tests/collections/Map-values-1.js (+4 lines)

Line	Link Here

Lines 1-8	Link Here

// Map.prototype.iterator and .entries are the same function object

assertEq(Map.prototype.iterator, Map.prototype.entries);

// map.keys(), .values(), and .entries() on an empty map produce empty iterators.

// map.keys(), .values(), and .entries() on an empty map produce empty iterators.

var m = Map();

var m = Map();

var ki = m.keys(), vi = m.values(), ei = m.entries();

var ki = m.keys(), vi = m.values(), ei = m.entries();

var p = Object.getPrototypeOf(ki)

var p = Object.getPrototypeOf(ki)

assertEq(Object.getPrototypeOf(vi), p);

assertEq(Object.getPrototypeOf(vi), p);

assertEq(Object.getPrototypeOf(ei), p);

assertEq(Object.getPrototypeOf(ei), p);

-      Line
+  Link Here
-      Line 0
+  Link Here
+// Set.prototype.keys and .values are the same function object
+assertEq(Set.prototype.keys, Set.prototype.values);
+// set.keys(), .values(), and .entries() on an empty set produce empty iterators
+var s = Set();
+var ki = s.keys(), vi = s.values(), ei = s.entries();
+var p = Object.getPrototypeOf(ki);
+assertEq(Object.getPrototypeOf(vi), p);
+assertEq(Object.getPrototypeOf(ei), p);
+for (let k of ki)
+	throw "FAIL";
+for (let v of vi)
+	throw "FAIL";
+for (let [k, v] of ei)
+	throw "FAIL";

-      Line
+  Link Here
-      Line 0
+  Link Here
+// set.keys() and set.values() return iterators over the values,
+// and set.entries() return iterator over a pair of values in the set
+load(libdir + "asserts.js");
+var data = [1, 2, 3, 4];
+var values = [[1, 1], [2, 2], [3, 3], [4, 4]];
+var s = Set(data);
+var ki = s.keys();
+assertEq(ki.next(), 1);
+assertEq(ki.next(), 2);
+assertEq(ki.next(), 3);
+assertEq(ki.next(), 4);
+assertThrowsValue(function () { ki.next(); }, StopIteration);
+assertEq([...s.keys()].toSource(), [1, 2, 3, 4].toSource());
+assertEq([...s.values()].toSource(), [1, 2, 3, 4].toSource());
+assertEq([...s.entries()].toSource(), values.toSource());

Return to bug 869996