YourWishes/jerryscript
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Implement for-await-of statement. (#3946)

Browse Source 
AsyncIteratorClose has not supported yet.

JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg zherczeg.u-szeged@partner.samsung.com
This commit is contained in:
Zoltan Herczeg
2020-06-30 11:21:50 +02:00
committed by GitHub
parent 0b404ea893
commit 5535ea88ac
20 changed files with 729 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files
jerry-core/ecma/base/ecma-gc.c
+30 -1
View File
@@ -466,7 +466,36 @@ ecma_gc_mark_executable_object (ecma_object_t *object_p) /**< object */
register_p++;
}
register_p += executable_object_p->frame_ctx.context_depth;
if (executable_object_p->frame_ctx.context_depth > 0)
{
ecma_value_t *context_end_p = register_p;
register_p += executable_object_p->frame_ctx.context_depth;
ecma_value_t *context_top_p = register_p;
do
{
uint32_t offsets = vm_get_context_value_offsets (context_top_p);
while (VM_CONTEXT_HAS_NEXT_OFFSET (offsets))
{
int32_t offset = VM_CONTEXT_GET_NEXT_OFFSET (offsets);
if (ecma_is_value_object (context_top_p[offset]))
{
ecma_gc_set_object_visited (ecma_get_object_from_value (context_top_p[offset]));
}
offsets >>= VM_CONTEXT_OFFSET_SHIFT;
}
JERRY_ASSERT (context_top_p >= context_end_p + offsets);
context_top_p -= offsets;
}
while (context_top_p > context_end_p);
}
register_end_p = executable_object_p->frame_ctx.stack_top_p;
while (register_p < register_end_p)
jerry-core/ecma/base/ecma-globals.h
+34 -2
View File
@@ -1865,18 +1865,50 @@ typedef enum
ECMA_EXECUTABLE_OBJECT_COMPLETED = (1u << 0), /**< executable object is completed and cannot be resumed */
ECMA_EXECUTABLE_OBJECT_RUNNING = (1u << 1), /**< executable object is currently running */
/* Generator specific flags. */
ECMA_GENERATOR_ITERATE_AND_YIELD = (1u << 2), /**< the generator performs a yield* operation */
ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD = (1u << 2), /**< the executable object performs
* an await or a yield* operation */
ECMA_ASYNC_GENERATOR_CALLED = (1u << 3), /**< the async generator was executed before */
/* This must be the last generator specific flag. */
ECMA_ASYNC_YIELD_ITERATOR_STATE_SHIFT = 4, /**< shift for async yield iterator state */
ECMA_AWAIT_STATE_SHIFT = 4, /**< shift for await states */
} ecma_executable_object_flags_t;
/**
* Async function states after an await is completed.
*/
typedef enum
{
ECMA_AWAIT_YIELD_NEXT, /**< wait for an iterator result object */
ECMA_AWAIT_YIELD_NEXT_RETURN, /**< wait for an iterator result object after a return operation */
ECMA_AWAIT_YIELD_RETURN, /**< wait for the argument passed to return operation */
ECMA_AWAIT_YIELD_NEXT_VALUE, /**< wait for the value property of an iterator result object */
ECMA_AWAIT_YIELD_OPERATION, /**< wait for the generator operation (next/throw/return) */
ECMA_AWAIT_YIELD_CLOSE, /**< wait for the result of iterator close operation */
/* After adding new ECMA_AWAIT_YIELD items, the ECMA_AWAIT_YIELD_END should be updated. */
ECMA_AWAIT_FOR_NEXT, /**< wait for an iterator result object of for-await-of statement */
} ecma_await_states_t;
/**
* Checks whether the executable object is waiting for resuming.
*/
#define ECMA_EXECUTABLE_OBJECT_IS_SUSPENDED(extra_info) \
(!((extra_info) & (ECMA_EXECUTABLE_OBJECT_COMPLETED | ECMA_EXECUTABLE_OBJECT_RUNNING)))
/**
* Last item of yield* related await states.
*/
#define ECMA_AWAIT_YIELD_END ECMA_AWAIT_YIELD_CLOSE
/**
* Helper macro for ECMA_EXECUTABLE_OBJECT_RESUME_EXEC.
*/
#define ECMA_EXECUTABLE_OBJECT_RESUME_EXEC_MASK ((uint16_t) ~ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD)
/**
* Resume execution of the byte code.
*/
#define ECMA_EXECUTABLE_OBJECT_RESUME_EXEC(executable_object_p) \
((executable_object_p)->extended_object.u.class_prop.extra_info &= ECMA_EXECUTABLE_OBJECT_RESUME_EXEC_MASK)
/**
* Enqueued task of an AsyncGenerator.
*
jerry-core/ecma/builtin-objects/ecma-builtin-generator-prototype.c
+3 -3
View File
@@ -91,7 +91,7 @@ ecma_builtin_generator_prototype_object_do (vm_executable_object_t *generator_ob
while (true)
{
if (generator_object_p->extended_object.u.class_prop.extra_info & ECMA_GENERATOR_ITERATE_AND_YIELD)
if (generator_object_p->extended_object.u.class_prop.extra_info & ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD)
{
ecma_value_t iterator = generator_object_p->frame_ctx.block_result;
ecma_value_t next_method = generator_object_p->frame_ctx.stack_top_p[-1];
@@ -119,7 +119,7 @@ ecma_builtin_generator_prototype_object_do (vm_executable_object_t *generator_ob
return result;
}
generator_object_p->extended_object.u.class_prop.extra_info &= (uint16_t) ~ECMA_GENERATOR_ITERATE_AND_YIELD;
ECMA_EXECUTABLE_OBJECT_RESUME_EXEC (generator_object_p);
generator_object_p->frame_ctx.block_result = ECMA_VALUE_UNDEFINED;
JERRY_ASSERT (generator_object_p->frame_ctx.stack_top_p[-1] == ECMA_VALUE_UNDEFINED
@@ -173,7 +173,7 @@ ecma_builtin_generator_prototype_object_do (vm_executable_object_t *generator_ob
}
ecma_deref_object (ecma_get_object_from_value (iterator));
generator_object_p->extended_object.u.class_prop.extra_info |= ECMA_GENERATOR_ITERATE_AND_YIELD;
generator_object_p->extended_object.u.class_prop.extra_info |= ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD;
generator_object_p->frame_ctx.block_result = iterator;
if (generator_object_p->frame_ctx.stack_top_p[0] != ECMA_VALUE_UNDEFINED)
jerry-core/ecma/operations/ecma-async-generator-object.c
+93 -35
View File
@@ -27,6 +27,7 @@
#include "jcontext.h"
#include "opcodes.h"
#include "vm.h"
#include "vm-stack.h"
#if ENABLED (JERRY_ESNEXT)
@@ -165,7 +166,7 @@ ecma_async_yield_throw (vm_executable_object_t *async_generator_object_p, /**< a
return result;
}
ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (async_generator_object_p, OPERATION, CLOSE);
ECMA_AWAIT_CHANGE_STATE (async_generator_object_p, YIELD_OPERATION, YIELD_CLOSE);
return ECMA_VALUE_UNDEFINED;
}
@@ -179,7 +180,7 @@ ecma_async_yield_throw (vm_executable_object_t *async_generator_object_p, /**< a
return result;
}
ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (async_generator_object_p, OPERATION, NEXT);
ECMA_AWAIT_CHANGE_STATE (async_generator_object_p, YIELD_OPERATION, YIELD_NEXT);
return ECMA_VALUE_UNDEFINED;
} /* ecma_async_yield_throw */
@@ -197,7 +198,7 @@ ecma_async_generator_run (vm_executable_object_t *async_generator_object_p) /**<
ecma_async_generator_task_t *task_p = ECMA_GET_INTERNAL_VALUE_POINTER (ecma_async_generator_task_t, head);
ecma_value_t result;
if (async_generator_object_p->extended_object.u.class_prop.extra_info & ECMA_GENERATOR_ITERATE_AND_YIELD)
if (async_generator_object_p->extended_object.u.class_prop.extra_info & ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD)
{
switch (task_p->operation_type)
{
@@ -219,7 +220,7 @@ ecma_async_generator_run (vm_executable_object_t *async_generator_object_p) /**<
break;
}
ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (async_generator_object_p, OPERATION, NEXT);
ECMA_AWAIT_CHANGE_STATE (async_generator_object_p, YIELD_OPERATION, YIELD_NEXT);
break;
}
case ECMA_ASYNC_GENERATOR_DO_THROW:
@@ -239,7 +240,7 @@ ecma_async_generator_run (vm_executable_object_t *async_generator_object_p) /**<
break;
}
ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (async_generator_object_p, OPERATION, RETURN);
ECMA_AWAIT_CHANGE_STATE (async_generator_object_p, YIELD_OPERATION, YIELD_RETURN);
break;
}
}
@@ -254,7 +255,7 @@ ecma_async_generator_run (vm_executable_object_t *async_generator_object_p) /**<
JERRY_ASSERT (ECMA_IS_VALUE_ERROR (result));
ECMA_ASYNC_YIELD_ITERATOR_END (async_generator_object_p);
async_generator_object_p->extended_object.u.class_prop.extra_info &= ECMA_AWAIT_CLEAR_MASK;
async_generator_object_p->frame_ctx.block_result = ECMA_VALUE_UNDEFINED;
async_generator_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_throw;
@@ -346,13 +347,15 @@ ecma_async_generator_finalize (vm_executable_object_t *async_generator_object_p,
* @return an updated value for the value argument
*/
ecma_value_t
ecma_async_yield_continue_await (vm_executable_object_t *async_generator_object_p, /**< async generator */
ecma_value_t value) /**< job value (takes reference) */
ecma_await_continue (vm_executable_object_t *executable_object_p, /**< executable object */
ecma_value_t value) /**< job value (takes reference) */
{
switch (ECMA_ASYNC_YIELD_ITERATOR_GET_STATE (async_generator_object_p))
ecma_await_states_t state = (ecma_await_states_t) ECMA_AWAIT_GET_STATE (executable_object_p);
switch (state)
{
case ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT:
case ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT_RETURN:
case ECMA_AWAIT_YIELD_NEXT:
case ECMA_AWAIT_YIELD_NEXT_RETURN:
{
if (!ecma_is_value_object (value))
{
@@ -381,23 +384,21 @@ ecma_async_yield_continue_await (vm_executable_object_t *async_generator_object_
if (!done)
{
ECMA_ASYNC_YIELD_ITERATOR_SET_STATE (async_generator_object_p, NEXT_VALUE);
return ecma_promise_async_await ((ecma_extended_object_t *) async_generator_object_p, result);
ECMA_AWAIT_SET_STATE (executable_object_p, YIELD_NEXT_VALUE);
return ecma_promise_async_await ((ecma_extended_object_t *) executable_object_p, result);
}
if (ECMA_ASYNC_YIELD_ITERATOR_GET_STATE (async_generator_object_p) == ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT)
ECMA_EXECUTABLE_OBJECT_RESUME_EXEC (executable_object_p);
if (state == ECMA_AWAIT_YIELD_NEXT_RETURN)
{
ECMA_ASYNC_YIELD_ITERATOR_END (async_generator_object_p);
return result;
executable_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_return;
}
ECMA_ASYNC_YIELD_ITERATOR_END (async_generator_object_p);
async_generator_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_return;
return result;
}
case ECMA_ASYNC_YIELD_ITERATOR_AWAIT_RETURN:
case ECMA_AWAIT_YIELD_RETURN:
{
ecma_object_t *obj_p = ecma_get_object_from_value (async_generator_object_p->frame_ctx.block_result);
ecma_object_t *obj_p = ecma_get_object_from_value (executable_object_p->frame_ctx.block_result);
ecma_value_t result = ecma_op_object_get_by_magic_id (obj_p, LIT_MAGIC_STRING_RETURN);
if (ECMA_IS_VALUE_ERROR (result))
@@ -408,13 +409,13 @@ ecma_async_yield_continue_await (vm_executable_object_t *async_generator_object_
if (result == ECMA_VALUE_UNDEFINED)
{
ECMA_ASYNC_YIELD_ITERATOR_END (async_generator_object_p);
async_generator_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_return;
ECMA_EXECUTABLE_OBJECT_RESUME_EXEC (executable_object_p);
executable_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_return;
return value;
}
result = ecma_async_yield_call (result,
async_generator_object_p,
executable_object_p,
value,
ECMA_ERR_MSG ("Iterator return() is not callable."));
ecma_free_value (value);
@@ -425,35 +426,92 @@ ecma_async_yield_continue_await (vm_executable_object_t *async_generator_object_
}
JERRY_ASSERT (result == ECMA_VALUE_UNDEFINED);
ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (async_generator_object_p, RETURN, NEXT_RETURN);
ECMA_AWAIT_CHANGE_STATE (executable_object_p, YIELD_RETURN, YIELD_NEXT_RETURN);
return ECMA_VALUE_UNDEFINED;
}
case ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT_VALUE:
case ECMA_AWAIT_YIELD_NEXT_VALUE:
{
ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (async_generator_object_p, NEXT_VALUE, OPERATION);
opfunc_async_generator_yield ((ecma_extended_object_t *) async_generator_object_p, value);
ECMA_AWAIT_CHANGE_STATE (executable_object_p, YIELD_NEXT_VALUE, YIELD_OPERATION);
opfunc_async_generator_yield ((ecma_extended_object_t *) executable_object_p, value);
return ECMA_VALUE_UNDEFINED;
}
case ECMA_ASYNC_YIELD_ITERATOR_AWAIT_OPERATION:
case ECMA_AWAIT_YIELD_OPERATION:
{
/* Currently this is always a throw exception case. */
ecma_value_t result = ecma_async_yield_throw (async_generator_object_p, value);
ecma_value_t result = ecma_async_yield_throw (executable_object_p, value);
ecma_free_value (value);
return result;
}
default:
case ECMA_AWAIT_YIELD_CLOSE:
{
JERRY_ASSERT (ECMA_ASYNC_YIELD_ITERATOR_GET_STATE (async_generator_object_p)
== ECMA_ASYNC_YIELD_ITERATOR_AWAIT_CLOSE);
const char *msg_p = (ecma_is_value_object (value) ? ECMA_ERR_MSG ("Iterator throw() is not available.")
: ECMA_ERR_MSG ("Value received by yield* is not Object."));
ecma_free_value (value);
return ecma_raise_type_error (msg_p);
}
default:
{
JERRY_ASSERT (state == ECMA_AWAIT_FOR_NEXT);
JERRY_ASSERT (VM_GET_CONTEXT_TYPE (executable_object_p->frame_ctx.stack_top_p[-1]) == VM_CONTEXT_FOR_AWAIT_OF);
if (!ecma_is_value_object (value))
{
ecma_free_value (value);
return ecma_raise_type_error (ECMA_ERR_MSG ("Value received by for-async-of is not Object."));
}
ecma_object_t *result_obj_p = ecma_get_object_from_value (value);
ecma_value_t result = ecma_op_object_get_by_magic_id (result_obj_p, LIT_MAGIC_STRING_DONE);
if (ECMA_IS_VALUE_ERROR (result))
{
ecma_deref_object (result_obj_p);
return result;
}
bool done = ecma_op_to_boolean (result);
ecma_free_value (result);
ecma_value_t *stack_top_p = executable_object_p->frame_ctx.stack_top_p;
JERRY_ASSERT (stack_top_p[-2] == ECMA_VALUE_UNDEFINED);
JERRY_ASSERT (ecma_is_value_object (stack_top_p[-3]));
JERRY_ASSERT (stack_top_p[-4] == ECMA_VALUE_UNDEFINED || ecma_is_value_object (stack_top_p[-4]));
if (!done)
{
result = ecma_op_object_get_by_magic_id (result_obj_p, LIT_MAGIC_STRING_VALUE);
ecma_deref_object (result_obj_p);
if (ECMA_IS_VALUE_ERROR (result))
{
return result;
}
/* It seems browsers call Await(result) here, although the standard does not
* requests to do so. The following code might follow browsers in the future. */
ecma_deref_if_object (result);
stack_top_p[-2] = result;
ECMA_EXECUTABLE_OBJECT_RESUME_EXEC (executable_object_p);
return ECMA_VALUE_EMPTY;
}
ecma_deref_object (result_obj_p);
/* This code jumps to the end regardless of the byte code which triggered this await. */
uint32_t context_end = VM_GET_CONTEXT_END (stack_top_p[-1]);
executable_object_p->frame_ctx.byte_code_p = executable_object_p->frame_ctx.byte_code_start_p + context_end;
VM_MINUS_EQUAL_U16 (executable_object_p->frame_ctx.context_depth,
PARSER_FOR_AWAIT_OF_CONTEXT_STACK_ALLOCATION);
stack_top_p -= PARSER_FOR_AWAIT_OF_CONTEXT_STACK_ALLOCATION;
executable_object_p->frame_ctx.stack_top_p = stack_top_p;
ECMA_EXECUTABLE_OBJECT_RESUME_EXEC (executable_object_p);
return ECMA_VALUE_EMPTY;
}
}
} /* ecma_async_yield_continue_await */
} /* ecma_await_continue */
#endif /* ENABLED (JERRY_ESNEXT) */
jerry-core/ecma/operations/ecma-async-generator-object.h
+14 -39
View File
@@ -38,67 +38,42 @@ typedef enum
ECMA_ASYNC_GENERATOR_DO_RETURN, /**< async generator return operation */
} ecma_async_generator_operation_type_t;
/**
* AsyncGenerator yield iterator states.
*/
typedef enum
{
ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT, /**< wait for an iterator result object */
ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT_RETURN, /**< wait for an iterator result object after a return operation */
ECMA_ASYNC_YIELD_ITERATOR_AWAIT_RETURN, /**< wait for the argument passed to return operation */
ECMA_ASYNC_YIELD_ITERATOR_AWAIT_NEXT_VALUE, /**< wait for the value property of an iterator result object */
ECMA_ASYNC_YIELD_ITERATOR_AWAIT_OPERATION, /**< wait for the generator operation (next/throw/return) */
ECMA_ASYNC_YIELD_ITERATOR_AWAIT_CLOSE, /**< wait for the result of iterator close operation */
} ecma_async_yield_iterator_states_t;
/**
* Get the state of an async yield iterator.
*/
#define ECMA_ASYNC_YIELD_ITERATOR_GET_STATE(async_generator_object_p) \
((async_generator_object_p)->extended_object.u.class_prop.extra_info >> ECMA_ASYNC_YIELD_ITERATOR_STATE_SHIFT)
#define ECMA_AWAIT_GET_STATE(async_generator_object_p) \
((async_generator_object_p)->extended_object.u.class_prop.extra_info >> ECMA_AWAIT_STATE_SHIFT)
/**
* Set the state of an async yield iterator.
*/
#define ECMA_ASYNC_YIELD_ITERATOR_SET_STATE(async_generator_object_p, to) \
#define ECMA_AWAIT_SET_STATE(async_generator_object_p, to) \
do \
{ \
uint16_t extra_info = (async_generator_object_p)->extended_object.u.class_prop.extra_info; \
extra_info &= ((1 << ECMA_ASYNC_YIELD_ITERATOR_STATE_SHIFT) - 1); \
extra_info |= (ECMA_ASYNC_YIELD_ITERATOR_AWAIT_ ## to) << ECMA_ASYNC_YIELD_ITERATOR_STATE_SHIFT; \
extra_info &= ((1 << ECMA_AWAIT_STATE_SHIFT) - 1); \
extra_info |= (ECMA_AWAIT_ ## to) << ECMA_AWAIT_STATE_SHIFT; \
(async_generator_object_p)->extended_object.u.class_prop.extra_info = extra_info; \
} \
while (false)
/**
* Helper value for ECMA_ASYNC_YIELD_ITERATOR_END.
* Mask for clearing all ASYNC_AWAIT status bits
*/
#define ECMA_ASYNC_YIELD_ITERATOR_END_MASK \
(((1 << ECMA_ASYNC_YIELD_ITERATOR_STATE_SHIFT) - 1) - ECMA_GENERATOR_ITERATE_AND_YIELD)
#define ECMA_AWAIT_CLEAR_MASK \
(((1 << ECMA_AWAIT_STATE_SHIFT) - 1) - ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD)
/**
* Return from yield iterator.
* Helper macro for ECMA_AWAIT_CHANGE_STATE.
*/
#define ECMA_ASYNC_YIELD_ITERATOR_END(async_generator_object_p) \
((async_generator_object_p)->extended_object.u.class_prop.extra_info &= ECMA_ASYNC_YIELD_ITERATOR_END_MASK)
/**
* Helper macro for ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE.
*/
#define ECMA_ASYNC_YIELD_ITERATOR_CS1(from, to) \
((ECMA_ASYNC_YIELD_ITERATOR_AWAIT_ ## from) ^ (ECMA_ASYNC_YIELD_ITERATOR_AWAIT_ ## to))
/**
* Helper macro for ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE.
*/
#define ECMA_ASYNC_YIELD_ITERATOR_CS2(from, to) \
(ECMA_ASYNC_YIELD_ITERATOR_CS1(from, to) << ECMA_ASYNC_YIELD_ITERATOR_STATE_SHIFT)
#define ECMA_AWAIT_CS_HELPER(from, to) \
(((ECMA_AWAIT_ ## from) ^ (ECMA_AWAIT_ ## to)) << ECMA_AWAIT_STATE_SHIFT)
/**
* Change the state of an async yield iterator.
*/
#define ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE(async_generator_object_p, from, to) \
((async_generator_object_p)->extended_object.u.class_prop.extra_info ^= ECMA_ASYNC_YIELD_ITERATOR_CS2 (from, to))
#define ECMA_AWAIT_CHANGE_STATE(async_generator_object_p, from, to) \
((async_generator_object_p)->extended_object.u.class_prop.extra_info ^= ECMA_AWAIT_CS_HELPER (from, to))
ecma_value_t ecma_async_generator_enqueue (vm_executable_object_t *async_generator_object_p,
ecma_async_generator_operation_type_t operation, ecma_value_t value);
@@ -106,7 +81,7 @@ ecma_value_t ecma_async_generator_enqueue (vm_executable_object_t *async_generat
void ecma_async_generator_run (vm_executable_object_t *async_generator_object_p);
void ecma_async_generator_finalize (vm_executable_object_t *async_generator_object_p, ecma_value_t value);
ecma_value_t ecma_async_yield_continue_await (vm_executable_object_t *async_generator_object_p, ecma_value_t value);
ecma_value_t ecma_await_continue (vm_executable_object_t *async_generator_object_p, ecma_value_t value);
#endif /* ENABLED (JERRY_ESNEXT) */
jerry-core/ecma/operations/ecma-jobqueue.c
+27 -21
View File
@@ -260,40 +260,43 @@ ecma_process_promise_async_reaction_job (ecma_job_promise_async_reaction_t *job_
if (ecma_job_queue_get_type (&job_p->header) == ECMA_JOB_PROMISE_ASYNC_REACTION_REJECTED)
{
if (!(executable_object_p->extended_object.u.class_prop.extra_info & ECMA_GENERATOR_ITERATE_AND_YIELD))
if (!(executable_object_p->extended_object.u.class_prop.extra_info & ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD))
{
executable_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_throw;
}
else if (ECMA_ASYNC_YIELD_ITERATOR_GET_STATE (executable_object_p) == ECMA_ASYNC_YIELD_ITERATOR_AWAIT_RETURN)
else if (ECMA_AWAIT_GET_STATE (executable_object_p) == ECMA_AWAIT_YIELD_RETURN)
{
/* Unlike other operations, return captures rejected promises as well. */
ECMA_ASYNC_YIELD_ITERATOR_CHANGE_STATE (executable_object_p, RETURN, OPERATION);
ECMA_AWAIT_CHANGE_STATE (executable_object_p, YIELD_RETURN, YIELD_OPERATION);
}
else
{
if (ECMA_AWAIT_GET_STATE (executable_object_p) <= ECMA_AWAIT_YIELD_END)
{
JERRY_ASSERT (ecma_is_value_object (executable_object_p->frame_ctx.block_result));
executable_object_p->frame_ctx.block_result = ECMA_VALUE_UNDEFINED;
JERRY_ASSERT (executable_object_p->frame_ctx.stack_top_p[-1] == ECMA_VALUE_UNDEFINED
|| ecma_is_value_object (executable_object_p->frame_ctx.stack_top_p[-1]));
executable_object_p->frame_ctx.stack_top_p--;
}
/* Exception: Abort iterators, clear all status. */
ECMA_ASYNC_YIELD_ITERATOR_END (executable_object_p);
JERRY_ASSERT (ecma_is_value_object (executable_object_p->frame_ctx.block_result));
executable_object_p->frame_ctx.block_result = ECMA_VALUE_UNDEFINED;
executable_object_p->extended_object.u.class_prop.extra_info &= ECMA_AWAIT_CLEAR_MASK;
executable_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_throw;
JERRY_ASSERT (executable_object_p->frame_ctx.stack_top_p[-1] == ECMA_VALUE_UNDEFINED
|| ecma_is_value_object (executable_object_p->frame_ctx.stack_top_p[-1]));
executable_object_p->frame_ctx.stack_top_p--;
}
}
if (executable_object_p->extended_object.u.class_prop.extra_info & ECMA_GENERATOR_ITERATE_AND_YIELD)
if (executable_object_p->extended_object.u.class_prop.extra_info & ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD)
{
job_p->argument = ecma_async_yield_continue_await (executable_object_p, job_p->argument);
job_p->argument = ecma_await_continue (executable_object_p, job_p->argument);
if (ECMA_IS_VALUE_ERROR (job_p->argument))
{
job_p->argument = jcontext_take_exception ();
executable_object_p->frame_ctx.byte_code_p = opfunc_resume_executable_object_with_throw;
}
else if (executable_object_p->extended_object.u.class_prop.extra_info & ECMA_GENERATOR_ITERATE_AND_YIELD)
else if (executable_object_p->extended_object.u.class_prop.extra_info & ECMA_EXECUTABLE_OBJECT_DO_AWAIT_OR_YIELD)
{
/* Continue iteration. */
JERRY_ASSERT (job_p->argument == ECMA_VALUE_UNDEFINED);
@@ -302,15 +305,18 @@ ecma_process_promise_async_reaction_job (ecma_job_promise_async_reaction_t *job_
return ECMA_VALUE_UNDEFINED;
}
/* End of yield*, clear all status. */
ECMA_ASYNC_YIELD_ITERATOR_END (executable_object_p);
if (ECMA_AWAIT_GET_STATE (executable_object_p) <= ECMA_AWAIT_YIELD_END)
{
JERRY_ASSERT (ecma_is_value_object (executable_object_p->frame_ctx.block_result));
executable_object_p->frame_ctx.block_result = ECMA_VALUE_UNDEFINED;
JERRY_ASSERT (ecma_is_value_object (executable_object_p->frame_ctx.block_result));
executable_object_p->frame_ctx.block_result = ECMA_VALUE_UNDEFINED;
JERRY_ASSERT (executable_object_p->frame_ctx.stack_top_p[-1] == ECMA_VALUE_UNDEFINED
|| ecma_is_value_object (executable_object_p->frame_ctx.stack_top_p[-1]));
executable_object_p->frame_ctx.stack_top_p--;
}
JERRY_ASSERT (executable_object_p->frame_ctx.stack_top_p[-1] == ECMA_VALUE_UNDEFINED
|| ecma_is_value_object (executable_object_p->frame_ctx.stack_top_p[-1]));
executable_object_p->frame_ctx.stack_top_p--;
/* Clear all status. */
executable_object_p->extended_object.u.class_prop.extra_info &= ECMA_AWAIT_CLEAR_MASK;
}
ecma_value_t result = opfunc_resume_executable_object (executable_object_p, job_p->argument);