mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-14 13:55:43 +00:00
8b32fceeee
--HG-- extra : rebase_source : 2394326ee9de3485ffd087944092bff9c669b1f5
259 lines
6.8 KiB
C++
259 lines
6.8 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* vim: set ts=8 sts=4 et sw=4 tw=99:
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef jsiter_h
|
|
#define jsiter_h
|
|
|
|
/*
|
|
* JavaScript iterators.
|
|
*/
|
|
|
|
#include "mozilla/MemoryReporting.h"
|
|
|
|
#include "jscntxt.h"
|
|
|
|
#include "gc/Barrier.h"
|
|
#include "vm/Stack.h"
|
|
|
|
/*
|
|
* For cacheable native iterators, whether the iterator is currently active.
|
|
* Not serialized by XDR.
|
|
*/
|
|
#define JSITER_ACTIVE 0x1000
|
|
#define JSITER_UNREUSABLE 0x2000
|
|
|
|
namespace js {
|
|
|
|
struct NativeIterator
|
|
{
|
|
HeapPtrObject obj; // Object being iterated.
|
|
JSObject *iterObj_; // Internal iterator object.
|
|
HeapPtrFlatString *props_array;
|
|
HeapPtrFlatString *props_cursor;
|
|
HeapPtrFlatString *props_end;
|
|
Shape **shapes_array;
|
|
uint32_t shapes_length;
|
|
uint32_t shapes_key;
|
|
uint32_t flags;
|
|
|
|
private:
|
|
/* While in compartment->enumerators, these form a doubly linked list. */
|
|
NativeIterator *next_;
|
|
NativeIterator *prev_;
|
|
|
|
public:
|
|
bool isKeyIter() const {
|
|
return (flags & JSITER_FOREACH) == 0;
|
|
}
|
|
|
|
inline HeapPtrFlatString *begin() const {
|
|
return props_array;
|
|
}
|
|
|
|
inline HeapPtrFlatString *end() const {
|
|
return props_end;
|
|
}
|
|
|
|
size_t numKeys() const {
|
|
return end() - begin();
|
|
}
|
|
|
|
JSObject *iterObj() const {
|
|
return iterObj_;
|
|
}
|
|
HeapPtrFlatString *current() const {
|
|
JS_ASSERT(props_cursor < props_end);
|
|
return props_cursor;
|
|
}
|
|
|
|
NativeIterator *next() {
|
|
return next_;
|
|
}
|
|
|
|
static inline size_t offsetOfNext() {
|
|
return offsetof(NativeIterator, next_);
|
|
}
|
|
static inline size_t offsetOfPrev() {
|
|
return offsetof(NativeIterator, prev_);
|
|
}
|
|
|
|
void incCursor() {
|
|
props_cursor = props_cursor + 1;
|
|
}
|
|
void link(NativeIterator *other) {
|
|
/* A NativeIterator cannot appear in the enumerator list twice. */
|
|
JS_ASSERT(!next_ && !prev_);
|
|
JS_ASSERT(flags & JSITER_ENUMERATE);
|
|
|
|
this->next_ = other;
|
|
this->prev_ = other->prev_;
|
|
other->prev_->next_ = this;
|
|
other->prev_ = this;
|
|
}
|
|
void unlink() {
|
|
JS_ASSERT(flags & JSITER_ENUMERATE);
|
|
|
|
next_->prev_ = prev_;
|
|
prev_->next_ = next_;
|
|
next_ = nullptr;
|
|
prev_ = nullptr;
|
|
}
|
|
|
|
static NativeIterator *allocateSentinel(JSContext *cx);
|
|
static NativeIterator *allocateIterator(JSContext *cx, uint32_t slength,
|
|
const js::AutoIdVector &props);
|
|
void init(JSObject *obj, JSObject *iterObj, unsigned flags, uint32_t slength, uint32_t key);
|
|
|
|
void mark(JSTracer *trc);
|
|
|
|
static void destroy(NativeIterator *iter) {
|
|
js_free(iter);
|
|
}
|
|
};
|
|
|
|
class PropertyIteratorObject : public JSObject
|
|
{
|
|
public:
|
|
static const Class class_;
|
|
|
|
NativeIterator *getNativeIterator() const {
|
|
return static_cast<js::NativeIterator *>(getPrivate());
|
|
}
|
|
void setNativeIterator(js::NativeIterator *ni) {
|
|
setPrivate(ni);
|
|
}
|
|
|
|
size_t sizeOfMisc(mozilla::MallocSizeOf mallocSizeOf) const;
|
|
|
|
private:
|
|
static void trace(JSTracer *trc, JSObject *obj);
|
|
static void finalize(FreeOp *fop, JSObject *obj);
|
|
};
|
|
|
|
class ArrayIteratorObject : public JSObject
|
|
{
|
|
public:
|
|
static const Class class_;
|
|
};
|
|
|
|
class StringIteratorObject : public JSObject
|
|
{
|
|
public:
|
|
static const Class class_;
|
|
};
|
|
|
|
bool
|
|
VectorToIdArray(JSContext *cx, AutoIdVector &props, JSIdArray **idap);
|
|
|
|
bool
|
|
GetIterator(JSContext *cx, HandleObject obj, unsigned flags, MutableHandleValue vp);
|
|
|
|
JSObject *
|
|
GetIteratorObject(JSContext *cx, HandleObject obj, unsigned flags);
|
|
|
|
bool
|
|
VectorToKeyIterator(JSContext *cx, HandleObject obj, unsigned flags, AutoIdVector &props,
|
|
MutableHandleValue vp);
|
|
|
|
bool
|
|
VectorToValueIterator(JSContext *cx, HandleObject obj, unsigned flags, AutoIdVector &props,
|
|
MutableHandleValue vp);
|
|
|
|
/*
|
|
* Creates either a key or value iterator, depending on flags. For a value
|
|
* iterator, performs value-lookup to convert the given list of jsids.
|
|
*/
|
|
bool
|
|
EnumeratedIdVectorToIterator(JSContext *cx, HandleObject obj, unsigned flags, AutoIdVector &props,
|
|
MutableHandleValue vp);
|
|
|
|
/*
|
|
* Convert the value stored in *vp to its iteration object. The flags should
|
|
* contain JSITER_ENUMERATE if js::ValueToIterator is called when enumerating
|
|
* for-in semantics are required, and when the caller can guarantee that the
|
|
* iterator will never be exposed to scripts.
|
|
*/
|
|
bool
|
|
ValueToIterator(JSContext *cx, unsigned flags, MutableHandleValue vp);
|
|
|
|
bool
|
|
CloseIterator(JSContext *cx, HandleObject iterObj);
|
|
|
|
bool
|
|
UnwindIteratorForException(JSContext *cx, js::HandleObject obj);
|
|
|
|
void
|
|
UnwindIteratorForUncatchableException(JSContext *cx, JSObject *obj);
|
|
|
|
bool
|
|
IteratorConstructor(JSContext *cx, unsigned argc, Value *vp);
|
|
|
|
} /* namespace js */
|
|
|
|
extern bool
|
|
js_SuppressDeletedProperty(JSContext *cx, js::HandleObject obj, jsid id);
|
|
|
|
extern bool
|
|
js_SuppressDeletedElement(JSContext *cx, js::HandleObject obj, uint32_t index);
|
|
|
|
extern bool
|
|
js_SuppressDeletedElements(JSContext *cx, js::HandleObject obj, uint32_t begin, uint32_t end);
|
|
|
|
/*
|
|
* IteratorMore() indicates whether another value is available. It might
|
|
* internally call iterobj.next() and then cache the value until its
|
|
* picked up by IteratorNext(). The value is cached in the current context.
|
|
*/
|
|
extern bool
|
|
js_IteratorMore(JSContext *cx, js::HandleObject iterobj, js::MutableHandleValue rval);
|
|
|
|
extern bool
|
|
js_IteratorNext(JSContext *cx, js::HandleObject iterobj, js::MutableHandleValue rval);
|
|
|
|
extern bool
|
|
js_ThrowStopIteration(JSContext *cx);
|
|
|
|
namespace js {
|
|
|
|
/*
|
|
* Create an object of the form { value: VALUE, done: DONE }.
|
|
* ES6 draft from 2013-09-05, section 25.4.3.4.
|
|
*/
|
|
extern JSObject *
|
|
CreateItrResultObject(JSContext *cx, js::HandleValue value, bool done);
|
|
|
|
} /* namespace js */
|
|
|
|
/*
|
|
* Generator state codes.
|
|
*/
|
|
enum JSGeneratorState
|
|
{
|
|
JSGEN_NEWBORN, /* not yet started */
|
|
JSGEN_OPEN, /* started by a .next() or .send(undefined) call */
|
|
JSGEN_RUNNING, /* currently executing via .next(), etc., call */
|
|
JSGEN_CLOSING, /* close method is doing asynchronous return */
|
|
JSGEN_CLOSED /* closed, cannot be started or closed again */
|
|
};
|
|
|
|
struct JSGenerator
|
|
{
|
|
js::HeapPtrObject obj;
|
|
JSGeneratorState state;
|
|
js::InterpreterRegs regs;
|
|
JSGenerator *prevGenerator;
|
|
js::InterpreterFrame *fp;
|
|
js::HeapValue stackSnapshot[1];
|
|
};
|
|
|
|
extern JSObject *
|
|
js_NewGenerator(JSContext *cx, const js::InterpreterRegs ®s);
|
|
|
|
extern JSObject *
|
|
js_InitIteratorClasses(JSContext *cx, js::HandleObject obj);
|
|
|
|
#endif /* jsiter_h */
|