void
_ejs_process_init(ejsval global, uint32_t argc, char **argv)
{
_ejs_Process = _ejs_object_new (_ejs_null, &_ejs_Object_specops);
_ejs_object_setprop (global, _ejs_atom_process, _ejs_Process);
ejsval _argv = _ejs_array_new (argc, EJS_FALSE);
_ejs_object_setprop (_ejs_Process, _ejs_atom_argv, _argv);
for (int i = 0; i < argc; i ++)
_ejs_object_setprop (_argv, NUMBER_TO_EJSVAL(i), _ejs_string_new_utf8(argv[i]));
#define OBJ_PROP(x) EJS_INSTALL_ATOM_GETTER(_ejs_Process, x, _ejs_Process_get_##x)
#define OBJ_METHOD(x) EJS_INSTALL_ATOM_FUNCTION(_ejs_Process, x, _ejs_Process_##x)
OBJ_PROP(env);
OBJ_METHOD(exit);
OBJ_METHOD(chdir);
OBJ_METHOD(cwd);
#undef OBJ_PROP
#undef OBJ_METHOD
}
void
_ejs_symbol_init(ejsval global)
{
_ejs_Symbol = _ejs_function_new_without_proto (_ejs_null, _ejs_atom_Symbol, _ejs_Symbol_impl);
_ejs_object_setprop (global, _ejs_atom_Symbol, _ejs_Symbol);
_ejs_gc_add_root (&_ejs_Symbol_prototype);
_ejs_Symbol_prototype = _ejs_object_new(_ejs_null, &_ejs_Object_specops); // XXX
_ejs_object_setprop (_ejs_Symbol, _ejs_atom_prototype, _ejs_Symbol_prototype);
PROTO_METHOD(toString);
PROTO_METHOD(valueOf);
OBJ_METHOD(for);
OBJ_METHOD(keyFor);
WELL_KNOWN_SYMBOL(hasInstance);
WELL_KNOWN_SYMBOL(isConcatSpreadable);
WELL_KNOWN_SYMBOL(species);
WELL_KNOWN_SYMBOL(iterator);
WELL_KNOWN_SYMBOL(toPrimitive);
WELL_KNOWN_SYMBOL(toStringTag);
WELL_KNOWN_SYMBOL(unscopables);
WELL_KNOWN_SYMBOL(match);
WELL_KNOWN_SYMBOL(replace);
WELL_KNOWN_SYMBOL(split);
WELL_KNOWN_SYMBOL(search);
_ejs_object_define_value_property (_ejs_Symbol_prototype, _ejs_Symbol_toStringTag, _ejs_atom_Symbol, EJS_PROP_NOT_ENUMERABLE | EJS_PROP_NOT_WRITABLE | EJS_PROP_CONFIGURABLE);
}
void
_ejs_promise_init(ejsval global)
{
_ejs_Promise = _ejs_function_new_without_proto (_ejs_null, _ejs_atom_Promise, (EJSClosureFunc)_ejs_Promise_impl);
_ejs_object_setprop (global, _ejs_atom_Promise, _ejs_Promise);
_ejs_gc_add_root (&_ejs_Promise_prototype);
_ejs_Promise_prototype = _ejs_object_new(_ejs_null, &_ejs_Object_specops);
_ejs_object_setprop (_ejs_Promise, _ejs_atom_prototype, _ejs_Promise_prototype);
_ejs_object_define_value_property (_ejs_Promise_prototype, _ejs_atom_constructor, _ejs_Promise,
EJS_PROP_NOT_ENUMERABLE | EJS_PROP_CONFIGURABLE | EJS_PROP_WRITABLE);
#define PROTO_METHOD(x) EJS_INSTALL_ATOM_FUNCTION_FLAGS (_ejs_Promise_prototype, x, _ejs_Promise_prototype_##x, EJS_PROP_NOT_ENUMERABLE)
#define OBJ_METHOD(x) EJS_INSTALL_ATOM_FUNCTION_FLAGS (_ejs_Promise, x, _ejs_Promise_##x, EJS_PROP_NOT_ENUMERABLE)
PROTO_METHOD(catch);
PROTO_METHOD(then);
_ejs_object_define_value_property (_ejs_Promise_prototype, _ejs_Symbol_toStringTag, _ejs_atom_Promise, EJS_PROP_NOT_ENUMERABLE | EJS_PROP_NOT_WRITABLE | EJS_PROP_CONFIGURABLE);
OBJ_METHOD(all);
OBJ_METHOD(race);
OBJ_METHOD(reject);
OBJ_METHOD(resolve);
#undef PROTO_METHOD
EJS_INSTALL_SYMBOL_FUNCTION_FLAGS (_ejs_Promise, create, _ejs_Promise_create, EJS_PROP_NOT_ENUMERABLE);
_ejs_gc_add_root(&_ejs_identity_function);
_ejs_identity_function = _ejs_function_new_anon(_ejs_undefined, identity);
_ejs_gc_add_root(&_ejs_thrower_function);
_ejs_thrower_function = _ejs_function_new_anon(_ejs_undefined, thrower);
}
void
_ejs_weakset_init(ejsval global)
{
_ejs_gc_add_root (&_ejs_WeakSetData_symbol);
_ejs_WeakSetData_symbol = _ejs_symbol_new(_ejs_atom_WeakSetData);
_ejs_WeakSet = _ejs_function_new_without_proto (_ejs_null, _ejs_atom_WeakSet, _ejs_WeakSet_impl);
_ejs_object_setprop (global, _ejs_atom_WeakSet, _ejs_WeakSet);
_ejs_gc_add_root (&_ejs_WeakSet_prototype);
_ejs_WeakSet_prototype = _ejs_object_new (_ejs_Object_prototype, &_ejs_Object_specops);
_ejs_object_setprop (_ejs_WeakSet, _ejs_atom_prototype, _ejs_WeakSet_prototype);
#define OBJ_METHOD(x) EJS_INSTALL_ATOM_FUNCTION(_ejs_WeakSet, x, _ejs_WeakSet_##x)
#define PROTO_METHOD(x) EJS_INSTALL_ATOM_FUNCTION_FLAGS(_ejs_WeakSet_prototype, x, _ejs_WeakSet_prototype_##x, EJS_PROP_NOT_ENUMERABLE | EJS_PROP_WRITABLE | EJS_PROP_CONFIGURABLE)
#define PROTO_GETTER(x) EJS_INSTALL_ATOM_GETTER(_ejs_WeakSet_prototype, x, _ejs_WeakSet_prototype_get_##x)
PROTO_METHOD(add);
// XXX (ES6 23.4.3.2) WeakSet.prototype.constructor
PROTO_METHOD(delete);
PROTO_METHOD(has);
_ejs_object_define_value_property (_ejs_WeakSet_prototype, _ejs_Symbol_toStringTag, _ejs_atom_WeakSet, EJS_PROP_NOT_ENUMERABLE | EJS_PROP_NOT_WRITABLE | EJS_PROP_CONFIGURABLE);
#undef OBJ_METHOD
#undef PROTO_METHOD
}
void
_ejs_set_init(ejsval global)
{
_ejs_Set = _ejs_function_new_without_proto (_ejs_null, _ejs_atom_Set, (EJSClosureFunc)_ejs_Set_impl);
_ejs_object_setprop (global, _ejs_atom_Set, _ejs_Set);
_ejs_gc_add_root (&_ejs_Set_prototype);
_ejs_Set_prototype = _ejs_set_new ();
_ejs_object_setprop (_ejs_Set, _ejs_atom_prototype, _ejs_Set_prototype);
#define OBJ_METHOD(x) EJS_INSTALL_ATOM_FUNCTION(_ejs_Set, x, _ejs_Set_##x)
#define PROTO_METHOD(x) EJS_INSTALL_ATOM_FUNCTION_FLAGS(_ejs_Set_prototype, x, _ejs_Set_prototype_##x, EJS_PROP_NOT_ENUMERABLE | EJS_PROP_WRITABLE | EJS_PROP_CONFIGURABLE)
#define PROTO_GETTER(x) EJS_INSTALL_ATOM_GETTER(_ejs_Set_prototype, x, _ejs_Set_prototype_get_##x)
PROTO_METHOD(add);
PROTO_METHOD(clear);
PROTO_METHOD(delete);
PROTO_METHOD(entries);
PROTO_METHOD(forEach);
PROTO_METHOD(has);
PROTO_GETTER(size);
// expand PROTO_METHOD(values) here so that we can install the function for both keys and @@iterator below
ejsval _values = _ejs_function_new_native (_ejs_null, _ejs_atom_values, (EJSClosureFunc)_ejs_Set_prototype_values);
_ejs_object_define_value_property (_ejs_Set_prototype, _ejs_atom_values, _values, EJS_PROP_NOT_ENUMERABLE | EJS_PROP_FLAGS_WRITABLE | EJS_PROP_CONFIGURABLE);
_ejs_object_define_value_property (_ejs_Set_prototype, _ejs_atom_keys, _values, EJS_PROP_NOT_ENUMERABLE | EJS_PROP_WRITABLE | EJS_PROP_CONFIGURABLE);
_ejs_object_define_value_property (_ejs_Set_prototype, _ejs_Symbol_iterator, _values, EJS_PROP_NOT_ENUMERABLE);
_ejs_object_define_value_property (_ejs_Set_prototype, _ejs_Symbol_toStringTag, _ejs_atom_Set, EJS_PROP_NOT_ENUMERABLE | EJS_PROP_NOT_WRITABLE | EJS_PROP_CONFIGURABLE);
EJS_INSTALL_SYMBOL_FUNCTION_FLAGS (_ejs_Set, create, _ejs_Set_create, EJS_PROP_NOT_ENUMERABLE);
#undef OBJ_METHOD
#undef PROTO_METHOD
_ejs_SetIterator = _ejs_function_new_without_proto (_ejs_null, _ejs_atom_Set, (EJSClosureFunc)_ejs_SetIterator_impl);
_ejs_gc_add_root (&_ejs_SetIterator_prototype);
_ejs_SetIterator_prototype = _ejs_set_iterator_new(_ejs_Set_prototype, EJS_SET_ITER_KIND_VALUE);
EJSVAL_TO_OBJECT(_ejs_SetIterator_prototype)->proto = _ejs_Object_prototype;
_ejs_object_define_value_property (_ejs_SetIterator, _ejs_atom_prototype, _ejs_SetIterator_prototype,
EJS_PROP_NOT_ENUMERABLE | EJS_PROP_NOT_CONFIGURABLE | EJS_PROP_NOT_WRITABLE);
_ejs_object_define_value_property (_ejs_SetIterator_prototype, _ejs_atom_constructor, _ejs_SetIterator,
EJS_PROP_NOT_ENUMERABLE | EJS_PROP_CONFIGURABLE | EJS_PROP_WRITABLE);
#define PROTO_ITER_METHOD(x) EJS_INSTALL_ATOM_FUNCTION_FLAGS (_ejs_SetIterator_prototype, x, _ejs_SetIterator_prototype_##x, EJS_PROP_NOT_ENUMERABLE | EJS_PROP_WRITABLE | EJS_PROP_CONFIGURABLE)
PROTO_ITER_METHOD(next);
#undef PROTO_ITER_METHOD
}
void
_ejs_require_init(ejsval global)
{
_ejs_require = _ejs_function_new_without_proto (_ejs_null, _ejs_atom_require, _ejs_require_impl);
_ejs_object_setprop (global, _ejs_atom_require, _ejs_require);
int i;
for (i = 0; i < num_builtin_modules; i ++) {
builtin_module_map[i].cached_exports = _ejs_null;
}
i = 0;
while (1) {
if (!_ejs_external_module_require_map[i].name)
break;
_ejs_external_module_require_map[i].cached_exports = _ejs_null;
i++;
}
i = 0;
while (1) {
if (!_ejs_require_map[i].name)
break;
_ejs_require_map[i].cached_exports = _ejs_null;
i++;
}
}
void
_ejs_reflect_init(ejsval global)
{
_ejs_Reflect = _ejs_object_new (_ejs_Object_prototype, &_ejs_Object_specops);
_ejs_object_setprop (global, _ejs_atom_Reflect, _ejs_Reflect);
#define OBJ_METHOD(x) EJS_INSTALL_ATOM_FUNCTION(_ejs_Reflect, x, _ejs_Reflect_##x)
OBJ_METHOD(apply);
OBJ_METHOD(construct);
OBJ_METHOD(defineProperty);
OBJ_METHOD(deleteProperty);
OBJ_METHOD(enumerate);
OBJ_METHOD(get);
OBJ_METHOD(getOwnPropertyDescriptor);
OBJ_METHOD(getPrototypeOf);
OBJ_METHOD(has);
OBJ_METHOD(isExtensible);
OBJ_METHOD(ownKeys);
OBJ_METHOD(preventExtensions);
OBJ_METHOD(set);
OBJ_METHOD(setPrototypeOf);
#undef OBJ_METHOD
}
void
Call_init (ejsval exports)
{
_ejs_Call_specops = _ejs_Object_specops;
_ejs_Call_specops.class_name = "LLVMCall";
_ejs_Call_specops.Allocate = Call_allocate;
_ejs_gc_add_root (&_ejs_Call_prototype);
_ejs_Call_prototype = _ejs_object_new(_ejs_Object_prototype, &_ejs_Call_specops);
ejsval tmpobj = _ejs_function_new_utf8 (_ejs_null, "LLVMCall", (EJSClosureFunc)Call_impl);
_ejs_Call = tmpobj;
#define PROTO_METHOD(x) EJS_INSTALL_ATOM_FUNCTION(_ejs_Call_prototype, x, Call_prototype_##x)
_ejs_object_setprop (_ejs_Call, _ejs_atom_prototype, _ejs_Call_prototype);
PROTO_METHOD(setOnlyReadsMemory);
PROTO_METHOD(setDoesNotAccessMemory);
PROTO_METHOD(setDoesNotThrow);
PROTO_METHOD(setStructRet);
PROTO_METHOD(dump);
PROTO_METHOD(toString);
#undef PROTO_METHOD
_ejs_object_setprop_utf8 (exports, "Call", _ejs_Call);
}
void
_ejs_function_init(ejsval global)
{
trace = getenv("EJS_TRACE") != NULL;
_ejs_function_init_proto();
_ejs_Function = _ejs_function_new_without_proto (_ejs_null, _ejs_atom_Function, (EJSClosureFunc)_ejs_Function_impl);
_ejs_object_setprop (global, _ejs_atom_Function, _ejs_Function);
// ECMA262 15.3.3.1
_ejs_object_define_value_property (_ejs_Function, _ejs_atom_prototype, _ejs_Function_prototype, EJS_PROP_NOT_ENUMERABLE | EJS_PROP_NOT_CONFIGURABLE | EJS_PROP_NOT_WRITABLE);
// ECMA262 15.3.3.2
_ejs_object_define_value_property (_ejs_Function, _ejs_atom_length, NUMBER_TO_EJSVAL(1), EJS_PROP_NOT_ENUMERABLE | EJS_PROP_NOT_CONFIGURABLE | EJS_PROP_NOT_WRITABLE);
#define PROTO_METHOD(x) EJS_INSTALL_ATOM_FUNCTION_FLAGS(_ejs_Function_prototype, x, _ejs_Function_prototype_##x, EJS_PROP_NOT_ENUMERABLE)
PROTO_METHOD(toString);
PROTO_METHOD(apply);
PROTO_METHOD(call);
PROTO_METHOD(bind);
#undef PROTO_METHOD
}
static EJSBool
json_value_to_ejsval(JSON_Value *v, ejsval *rv)
{
switch (json_value_get_type (v)) {
case JSONNull:
*rv = _ejs_null;
return EJS_TRUE;
case JSONString:
*rv = _ejs_string_new_utf8 (json_value_get_string(v));
return EJS_TRUE;
case JSONNumber:
*rv = NUMBER_TO_EJSVAL(json_value_get_number(v));
return EJS_TRUE;
case JSONObject: {
JSON_Object *obj = json_value_get_object (v);
*rv = _ejs_object_create (_ejs_null);
int count = json_object_get_count (obj);
for (int i = 0; i < count; i ++) {
const char *propkey = json_object_get_name (obj, i);
ejsval propval;
if (!json_value_to_ejsval (json_object_get_value (obj, propkey), &propval))
return EJS_FALSE;
_ejs_object_setprop_utf8 (*rv, propkey, propval);
}
return EJS_TRUE;
}
case JSONArray: {
JSON_Array *arr = json_value_get_array (v);
int count = json_array_get_count (arr);
*rv = _ejs_array_new (count, EJS_FALSE);
for (int i = 0; i < count; i ++) {
ejsval propkey = _ejs_number_new (i);
ejsval propval;
if (!json_value_to_ejsval (json_array_get_value (arr, i), &propval))
return EJS_FALSE;
_ejs_object_setprop (*rv, propkey, propval);
}
return EJS_TRUE;
}
case JSONBoolean:
*rv = BOOLEAN_TO_EJSVAL(json_value_get_boolean(v));
return EJS_TRUE;
case JSONError:
EJS_NOT_IMPLEMENTED();
return EJS_FALSE;
}
}
void
_ejs_regexp_init(ejsval global)
{
_ejs_RegExp = _ejs_function_new_without_proto (_ejs_null, _ejs_atom_RegExp, (EJSClosureFunc)_ejs_RegExp_impl);
_ejs_object_setprop (global, _ejs_atom_RegExp, _ejs_RegExp);
_ejs_gc_add_root (&_ejs_RegExp_prototype);
_ejs_RegExp_prototype = _ejs_object_new(_ejs_null, &_ejs_RegExp_specops);
EJSRegExp* re_proto = (EJSRegExp*)EJSVAL_TO_OBJECT(_ejs_RegExp_prototype);
re_proto->pattern = _ejs_string_new_utf8("(?:)");
re_proto->flags = _ejs_atom_empty;
_ejs_object_setprop (_ejs_RegExp, _ejs_atom_prototype, _ejs_RegExp_prototype);
#define OBJ_METHOD(x) EJS_INSTALL_ATOM_FUNCTION(_ejs_RegExp, x, _ejs_RegExp_##x)
#define PROTO_METHOD(x) EJS_INSTALL_ATOM_FUNCTION(_ejs_RegExp_prototype, x, _ejs_RegExp_prototype_##x)
#define PROTO_METHOD_VAL(x) EJS_INSTALL_ATOM_FUNCTION_VAL(_ejs_RegExp_prototype, x, _ejs_RegExp_prototype_##x)
#define PROTO_GETTER(x) EJS_INSTALL_ATOM_GETTER(_ejs_RegExp_prototype, x, _ejs_RegExp_prototype_get_##x)
_ejs_gc_add_root (&_ejs_RegExp_prototype_exec_closure);
_ejs_RegExp_prototype_exec_closure = PROTO_METHOD_VAL(exec);
PROTO_METHOD(test);
PROTO_METHOD(toString);
PROTO_GETTER(global);
PROTO_GETTER(ignoreCase);
PROTO_GETTER(lastIndex);
PROTO_GETTER(multiline);
PROTO_GETTER(source);
PROTO_GETTER(sticky);
PROTO_GETTER(unicode);
#undef OBJ_METHOD
#undef PROTO_METHOD
EJS_INSTALL_SYMBOL_FUNCTION_FLAGS (_ejs_RegExp, create, _ejs_RegExp_create, EJS_PROP_NOT_ENUMERABLE);
}
// ES6: 23.4.3.1
// WeakSet.prototype.add ( value )
static EJS_NATIVE_FUNC(_ejs_WeakSet_prototype_add) {
ejsval value = _ejs_undefined;
if (argc > 0) value = args[0];
// 1. Let S be the this value.
ejsval S = *_this;
// 2. If Type(S) is not Object, then throw a TypeError exception.
if (!EJSVAL_IS_OBJECT(S))
_ejs_throw_nativeerror_utf8 (EJS_TYPE_ERROR, "add called with non-object this.");
// 3. If S does not have a [[WeakSetData]] internal slot throw a TypeError exception.
if (!EJSVAL_IS_WEAKSET(S))
_ejs_throw_nativeerror_utf8 (EJS_TYPE_ERROR, "add called with non-WeakSet this.");
// 4. If S’s [[WeakSetData]] internal slot is undefined, then throw a TypeError exception.
// 6. If Type(value) is not Object, then throw a TypeError exception.
if (!EJSVAL_IS_OBJECT(value))
_ejs_throw_nativeerror_utf8 (EJS_TYPE_ERROR, "add called with non-Object value.");
#if WEAK_COLLECTIONS_USE_INVERTED_REP
ejsval iset = _ejs_object_getprop(value, _ejs_WeakSetData_symbol);
if (EJSVAL_IS_NULL_OR_UNDEFINED(iset)) {
iset = _ejs_set_new();
_ejs_object_setprop(value, _ejs_WeakSetData_symbol, iset);
}
if (!EJSVAL_IS_SET(iset))
_ejs_throw_nativeerror_utf8 (EJS_TYPE_ERROR, "[[WeakSetData]] internal error");
_ejs_set_add (iset, S);
return S;
#else
// 7. Let entries be the List that is the value of S’s [[WeakSetData]] internal slot.
// a. If e is not empty and SameValue(e, value) is true, then
// 1. Return S.
// 8. Append value as the last element of entries.
// 9. Return S.
#endif
}
void
_ejs_init(int argc, char** argv)
{
// process class inheritance
_ejs_init_classes();
// initialize our atoms before anything else
_ejs_init_static_strings();
_ejs_gc_init();
_ejs_exception_init();
// initialization or ECMA262 builtins
_ejs_gc_add_root (&_ejs_global);
_ejs_global = _ejs_object_new (_ejs_null, &_ejs_Object_specops);
_ejs_nan = NUMBER_TO_EJSVAL(nan("7734"));
_ejs_object_setprop (_ejs_global, _ejs_atom_undefined, _ejs_undefined);
_ejs_object_setprop (_ejs_global, _ejs_atom_NaN, _ejs_nan);
_ejs_object_setprop (_ejs_global, _ejs_atom_Infinity, _ejs_Infinity);
_ejs_object_setprop (_ejs_global, _ejs_atom_eval, _ejs_function_new_native (_ejs_undefined, _ejs_atom_eval, _ejs_eval));
_ejs_object_init_proto();
_ejs_function_init(_ejs_global);
_ejs_object_init(_ejs_global);
_ejs_symbol_init(_ejs_global);
_ejs_error_init(_ejs_global);
_ejs_arguments_init(_ejs_global);
_ejs_array_init(_ejs_global);
_ejs_boolean_init (_ejs_global);
_ejs_string_init(_ejs_global);
_ejs_number_init(_ejs_global);
_ejs_regexp_init(_ejs_global);
_ejs_date_init(_ejs_global);
_ejs_json_init(_ejs_global);
_ejs_math_init(_ejs_global);
// ES6 bits
_ejs_proxy_init(_ejs_global);
_ejs_map_init(_ejs_global);
_ejs_set_init(_ejs_global);
_ejs_typedarrays_init(_ejs_global);
#if IOS
_ejs_webgl_init(_ejs_global);
#endif
#define GLOBAL_METHOD(x) EJS_MACRO_START \
_ejs_##x = _ejs_function_new_native (_ejs_null, _ejs_atom_##x, (EJSClosureFunc)_ejs_##x##_impl); \
_ejs_object_setprop (_ejs_global, _ejs_atom_##x, _ejs_##x); \
EJS_MACRO_END
GLOBAL_METHOD(isNaN);
GLOBAL_METHOD(isFinite);
GLOBAL_METHOD(parseInt);
GLOBAL_METHOD(parseFloat);
GLOBAL_METHOD(decodeURI);
GLOBAL_METHOD(decodeURIComponent);
GLOBAL_METHOD(encodeURI);
GLOBAL_METHOD(encodeURIComponent);
#undef GLOBAL_METHOD
// the node-like api we support in order for our driver to
// function. this should really be a separate opt-in .a/.so.
_ejs_require_init(_ejs_global);
_ejs_console_init(_ejs_global);
_ejs_process_init(_ejs_global, argc, argv);
_ejs_xmlhttprequest_init(_ejs_global);
// a special global (__ejs) under which we can stuff other
// semi-useful runtime features, like a call to force a GC. the
// compiler also uses the presence of __ejs to disable
// buggy/nonfunctional code (like those that use regexps)
ejsval _ejs_ejs_global = _ejs_object_new (_ejs_null, &_ejs_Object_specops);
_ejs_object_setprop (_ejs_global, _ejs_atom___ejs, _ejs_ejs_global);
_ejs_GC_init(_ejs_ejs_global);
_ejs_gc_allocate_oom_exceptions();
}
static ejsval
_ejs_SetIterator_prototype_next (ejsval env, ejsval _this, uint32_t argc, ejsval *args)
{
/* 1. Let O be the this value. */
ejsval O = _this;
/* 2. If Type(O) is not Object, throw a TypeError exception. */
if (!EJSVAL_IS_OBJECT(O))
_ejs_throw_nativeerror_utf8 (EJS_TYPE_ERROR, ".next called on non-object");
/* 3. If O does not have all of the internal slots of a Set Iterator Instance (23.2.5.3),
* throw a TypeError exception. */
if (!EJSVAL_IS_SETITERATOR(O))
_ejs_throw_nativeerror_utf8 (EJS_TYPE_ERROR, ".next called on non-SetIterator instance");
EJSSetIterator *OObj = (EJSSetIterator*)EJSVAL_TO_OBJECT(O);
/* 4. Let s be the value of the [[IteratedSet]] internal slot of O. */
ejsval s = OObj->iterated;
/* 5. Let index be the value of the [[SetNextIndex]] internal slot of O. */
uint32_t index = OObj->next_index;
/* 6. Let itemKind be the value of the [[SetIterationKind]] internal slot of O. */
EJSSetIteratorKind itemKind = OObj->kind;
/* 7. If s is undefined, then return CreateIterResultObject(undefined, true). */
if (EJSVAL_IS_UNDEFINED(s))
return _ejs_create_iter_result (_ejs_undefined, _ejs_true);
/* 8. Assert: s has a [[SetData]] internal slot and s has been initialized so the value of
* [[SetData]] is not undefined. */
/* 9. Let entries be the List that is the value of the [[SetData]] internal slot of s. */
EJSSetValueEntry *entries = EJSVAL_TO_SET(s)->head_insert;
/* 10. Repeat while index is less than the total number of elements of entries. The number of elements must
* be redetermined each time this method is evaluated. */
uint32_t i = 0;
for (EJSSetValueEntry *entry = entries; entry; entry = entry->next_insert) {
/* Ignore this item if is marked as empty */
if (EJSVAL_IS_NO_ITER_VALUE_MAGIC(entry->value))
continue;
/* Ignore this item if we haven't reached the initial needed point/index */
if (index > i++)
continue;
/* a. Let e be entries[index]. */
ejsval e = entry->value;
/* b. Set index to index+1; */
index = index + 1;
/* c. Set the [[SetNextIndex]] internal slot of O to index. */
OObj->next_index = index;
/* d. If e is not empty, then */
/* (see EJSVAL_IS_NO_ITER_VALUE_MAGIC check at the beginning of the loop */
/* i. If itemKind is "key+value" then, */
if (itemKind == EJS_SET_ITER_KIND_KEYVALUE) {
/* 1. Let result be the result of performing ArrayCreate(2). */
/* 2. Assert: result is a new, well-formed Array object so the following operations will never fail. */
ejsval result = _ejs_array_new (2, EJS_FALSE);
/* 3. Call CreateDataProperty(result, "0", e) . */
_ejs_object_setprop (result, NUMBER_TO_EJSVAL(0), e);
/* 4. Call CreateDataProperty(result, "1", e) . */
_ejs_object_setprop (result, NUMBER_TO_EJSVAL(1), e);
return _ejs_create_iter_result (result, _ejs_false);
}
/* ii. Return CreateIterResultObject(e, false). */
return _ejs_create_iter_result (e, _ejs_false);
}
/* 11. Set the [[IteratedSet]] internal slot of O to undefined. */
OObj->iterated = _ejs_undefined;
/* 12. Return CreateIterResultObject(undefined, true). */
return _ejs_create_iter_result (_ejs_undefined, _ejs_true);
}
void
_ejs_typedarrays_init(ejsval global)
{
#define OBJ_METHOD(t,x) EJS_INSTALL_ATOM_FUNCTION(_ejs_##t, x, _ejs_##t##_##x)
#define PROTO_METHOD(t,x) EJS_INSTALL_ATOM_FUNCTION(_ejs_##t##_prototype, x, _ejs_##t##_prototype_##x)
#define PROTO_METHOD_IMPL(t,x) EJS_INSTALL_ATOM_FUNCTION(_ejs_##t##_prototype, x, _ejs_##t##_prototype_##x##_impl)
#define PROTO_GETTER(t,x) EJS_INSTALL_SYMBOL_GETTER(_ejs_##t##_prototype, x, _ejs_##t##_prototype_get_##x)
// ArrayBuffer
{
_ejs_ArrayBuffer = _ejs_function_new_without_proto (_ejs_null, _ejs_atom_ArrayBuffer, (EJSClosureFunc)_ejs_ArrayBuffer_impl);
_ejs_object_setprop (global, _ejs_atom_ArrayBuffer, _ejs_ArrayBuffer);
_ejs_gc_add_root (&_ejs_ArrayBuffer_prototype);
_ejs_ArrayBuffer_prototype = _ejs_object_new(_ejs_null, &_ejs_Object_specops);
_ejs_object_setprop (_ejs_ArrayBuffer, _ejs_atom_prototype, _ejs_ArrayBuffer_prototype);
PROTO_METHOD(ArrayBuffer, slice);
_ejs_object_define_value_property (_ejs_ArrayBuffer_prototype, _ejs_Symbol_toStringTag, _ejs_atom_ArrayBuffer, EJS_PROP_NOT_ENUMERABLE | EJS_PROP_NOT_WRITABLE | EJS_PROP_CONFIGURABLE);
}
// DataView
{
_ejs_DataView = _ejs_function_new_without_proto (_ejs_null, _ejs_atom_DataView, (EJSClosureFunc)_ejs_DataView_impl);
_ejs_object_setprop (global, _ejs_atom_DataView, _ejs_DataView);
_ejs_gc_add_root (&_ejs_DataView_prototype);
_ejs_DataView_prototype = _ejs_object_new (_ejs_null, &_ejs_Object_specops);
_ejs_object_setprop (_ejs_DataView, _ejs_atom_prototype, _ejs_DataView_prototype);
PROTO_METHOD_IMPL(DataView, getInt8);
PROTO_METHOD_IMPL(DataView, setInt8);
PROTO_METHOD_IMPL(DataView, getInt16);
PROTO_METHOD_IMPL(DataView, setInt16);
PROTO_METHOD_IMPL(DataView, getInt32);
PROTO_METHOD_IMPL(DataView, setInt32);
PROTO_METHOD_IMPL(DataView, getFloat32);
PROTO_METHOD_IMPL(DataView, setFloat32);
PROTO_METHOD_IMPL(DataView, getFloat64);
PROTO_METHOD_IMPL(DataView, setFloat64);
_ejs_object_define_value_property (_ejs_DataView_prototype, _ejs_Symbol_toStringTag, _ejs_atom_DataView, EJS_PROP_NOT_ENUMERABLE | EJS_PROP_NOT_WRITABLE | EJS_PROP_CONFIGURABLE);
}
#define ADD_TYPEDARRAY(EnumType, ArrayType, arraytype, elementSizeInBytes) EJS_MACRO_START \
_ejs_##ArrayType##Array = _ejs_function_new_without_proto (_ejs_null, _ejs_atom_##ArrayType##Array, (EJSClosureFunc)_ejs_##ArrayType##Array_impl); \
_ejs_object_setprop (global, _ejs_atom_##ArrayType##Array, _ejs_##ArrayType##Array); \
\
_ejs_gc_add_root (&_ejs_##ArrayType##Array_prototype); \
_ejs_##ArrayType##Array_prototype = _ejs_object_new(_ejs_null, &_ejs_Object_specops); \
_ejs_object_setprop (_ejs_##ArrayType##Array, _ejs_atom_prototype, _ejs_##ArrayType##Array_prototype); \
\
/* make sure ctor.BYTES_PER_ELEMENT is defined */ \
_ejs_object_define_value_property (_ejs_##ArrayType##Array, _ejs_atom_BYTES_PER_ELEMENT, NUMBER_TO_EJSVAL(elementSizeInBytes), EJS_PROP_FLAGS_ENUMERABLE); \
\
_ejs_typed_array_elsizes[EJS_TYPEDARRAY_##EnumType] = elementSizeInBytes; \
_ejs_typed_array_protos[EJS_TYPEDARRAY_##EnumType] = _ejs_##ArrayType##Array_prototype; \
_ejs_typed_array_specops[EJS_TYPEDARRAY_##EnumType] = &_ejs_##arraytype##array_specops; \
\
PROTO_METHOD_IMPL(ArrayType##Array, get); \
PROTO_METHOD_IMPL(ArrayType##Array, set); \
PROTO_METHOD_IMPL(ArrayType##Array, subarray); \
PROTO_GETTER(ArrayType##Array, toStringTag); /* XXX needs to be enumerable: false, configurable: true */ \
EJS_MACRO_END
ADD_TYPEDARRAY(INT8, Int8, int8, 1);
ADD_TYPEDARRAY(UINT8, Uint8, uint8, 1);
//ADD_TYPEDARRAY(UINT8CLAMPED, Uint8Clamped, uint8clamped, 1);
ADD_TYPEDARRAY(INT16, Int16, int16, 2);
ADD_TYPEDARRAY(UINT16, Uint16, uint16, 2);
ADD_TYPEDARRAY(INT32, Int32, int32, 4);
ADD_TYPEDARRAY(UINT32, Uint32, uint32, 4);
ADD_TYPEDARRAY(FLOAT32, Float32, float32, 4);
ADD_TYPEDARRAY(FLOAT64, Float64, float64, 8);
}
