make -C quickjs -j"$(nproc)" libquickjs.a
;;
quickjs-ng)
- git clone --branch v0.16.2 --depth=1 \
+ git clone --branch v0.18.0 --depth=1 \
https://github.com/quickjs-ng/quickjs quickjs-ng
CFLAGS="$cc_opt -fPIC" LDFLAGS="$ld_opt" \
meson setup quickjs-ng/build quickjs-ng \
- name: Build QuickJS-NG
if: matrix.engine == 'quickjs-ng'
run: |
- git clone --branch v0.16.2 --depth=1 \
+ git clone --branch v0.18.0 --depth=1 \
https://github.com/quickjs-ng/quickjs quickjs-ng
CFLAGS="$(dpkg-buildflags --get CFLAGS) -fPIC" \
LDFLAGS="$(dpkg-buildflags --get LDFLAGS)" \
cln->data = dgst;
if (EVP_DigestInit_ex(dgst->ctx, md, NULL) <= 0) {
- njs_vm_internal_error(vm, "EVP_DigestInit_ex() failed");
+ njs_vm_error(vm, "EVP_DigestInit_ex() failed");
return NJS_ERROR;
}
if (!hmac) {
if (EVP_DigestUpdate(dgst->ctx, data.start, data.length) <= 0) {
- njs_vm_internal_error(vm, "EVP_DigestUpdate() failed");
+ njs_vm_error(vm, "EVP_DigestUpdate() failed");
return NJS_ERROR;
}
} else {
if (HMAC_Update(ctx->ctx, data.start, data.length) <= 0) {
- njs_vm_internal_error(vm, "HMAC_Update() failed");
+ njs_vm_error(vm, "HMAC_Update() failed");
return NJS_ERROR;
}
}
if (!hmac) {
if (EVP_DigestFinal_ex(dgst->ctx, digest, &len) <= 0) {
- njs_vm_internal_error(vm, "EVP_DigestFinal_ex() failed");
+ njs_vm_error(vm, "EVP_DigestFinal_ex() failed");
return NJS_ERROR;
}
} else {
if (HMAC_Final(ctx->ctx, digest, &len) <= 0) {
- njs_vm_internal_error(vm, "HMAC_Final() failed");
+ njs_vm_error(vm, "HMAC_Final() failed");
return NJS_ERROR;
}
cln->data = copy;
if (EVP_MD_CTX_copy_ex(copy->ctx, dgst->ctx) <= 0) {
- njs_vm_internal_error(vm, "EVP_MD_CTX_copy_ex() failed");
+ njs_vm_error(vm, "EVP_MD_CTX_copy_ex() failed");
return NJS_ERROR;
}
cln->data = ctx;
if (HMAC_Init_ex(ctx->ctx, key.start, (int) key.length, md, NULL) <= 0) {
- njs_vm_internal_error(vm, "HMAC_Init_ex() failed");
+ njs_vm_error(vm, "HMAC_Init_ex() failed");
return NJS_ERROR;
}
}
if (njs_slow_path((p - path) > NJS_MAX_PATH)) {
- njs_vm_internal_error(vm, "too large path");
+ njs_vm_error(vm, "too large path");
return NJS_ERROR;
}
}
if (njs_slow_path(str.length > NJS_MAX_PATH - 1)) {
- njs_vm_internal_error(vm, "\"%s\" is too long >= %d", prop_name,
- NJS_MAX_PATH);
+ njs_vm_range_error(vm, "\"%s\" is too long >= %d", prop_name,
+ NJS_MAX_PATH);
return NULL;
}
if (njs_slow_path(njs_value_is_number(type)
&& (njs_value_number(type) == NJS_DT_INVALID)))
{
- njs_vm_internal_error(vm, "dentry type is not supported on this "
- "platform");
+ njs_vm_error(vm, "dentry type is not supported on this "
+ "platform");
return NJS_ERROR;
}
(void) close(info.fd);
if (njs_slow_path(ret != NJS_OK)) {
- njs_vm_internal_error(vm, "while reading \"%V\" module", &info.file);
+ njs_vm_error(vm, "while reading \"%V\" module", &info.file);
return NULL;
}
ret = njs_console_set_cwd(console, &info.file);
if (njs_slow_path(ret != NJS_OK)) {
- njs_vm_internal_error(vm, "while setting cwd for \"%V\" module",
- &info.file);
+ njs_vm_error(vm, "while setting cwd for \"%V\" module",
+ &info.file);
return NULL;
}
(void) close(info.fd);
if (njs_slow_path(ret != NJS_OK)) {
- JS_ThrowInternalError(ctx, "while reading \"%.*s\" module",
- (int) info.file.length, info.file.start);
+ qjs_throw_error(ctx, "while reading \"%.*s\" module",
+ (int) info.file.length, info.file.start);
return NULL;
}
ret = njs_console_set_cwd(console, &info.file);
if (njs_slow_path(ret != NJS_OK)) {
- JS_ThrowInternalError(ctx, "while setting cwd for \"%.*s\" module",
- (int) info.file.length, info.file.start);
+ qjs_throw_error(ctx, "while setting cwd for \"%.*s\" module",
+ (int) info.file.length, info.file.start);
return NULL;
}
error:
- njs_vm_internal_error(vm, "cannot make webcrypto result");
+ njs_vm_error(vm, "cannot make webcrypto result");
return NJS_ERROR;
}
ctx = xmlNewParserCtxt();
if (njs_slow_path(ctx == NULL)) {
- njs_vm_internal_error(vm, "xmlNewParserCtxt() failed");
+ njs_vm_error(vm, "xmlNewParserCtxt() failed");
return NJS_ERROR;
}
node = xmlDocCopyNode(node, current->doc, 1);
if (njs_slow_path(node == NULL)) {
- njs_vm_internal_error(vm, "xmlDocCopyNode() failed");
+ njs_vm_error(vm, "xmlDocCopyNode() failed");
return NJS_ERROR;
}
text = xmlNodeGetContent((xmlNode *) attr);
if (njs_slow_path(text == NULL)) {
- njs_vm_internal_error(vm, "xmlNodeGetContent() failed");
+ njs_vm_error(vm, "xmlNodeGetContent() failed");
return NJS_ERROR;
}
if (retval != NULL && setval != NULL) {
text = xmlNewDocTextLen(current->doc, content.start, content.length);
if (njs_slow_path(text == NULL)) {
- njs_vm_internal_error(vm, "xmlNewDocTextLen() failed");
+ njs_vm_error(vm, "xmlNewDocTextLen() failed");
return NJS_ERROR;
}
}
attr = xmlSetProp(current, name_c, value);
if (njs_slow_path(attr == NULL)) {
- njs_vm_internal_error(vm, "xmlSetProp() failed");
+ njs_vm_error(vm, "xmlSetProp() failed");
return NJS_ERROR;
}
text = xmlNodeGetContent((xmlNode *) attr);
if (njs_slow_path(text == NULL)) {
- njs_vm_internal_error(vm, "xmlNodeGetContent() failed");
+ njs_vm_error(vm, "xmlNodeGetContent() failed");
return NJS_ERROR;
}
node = xmlDocCopyNode(node, current->doc, 1);
if (njs_slow_path(node == NULL)) {
- njs_vm_internal_error(vm, "xmlDocCopyNode() failed");
+ njs_vm_error(vm, "xmlDocCopyNode() failed");
goto error;
}
buf = xmlOutputBufferCreateIO(njs_xml_buf_write_cb, NULL, &chain, NULL);
if (njs_slow_path(buf == NULL)) {
- njs_vm_internal_error(vm, "xmlOutputBufferCreateIO() failed");
+ njs_vm_error(vm, "xmlOutputBufferCreateIO() failed");
return NJS_ERROR;
}
prefix_list, comments, buf);
if (njs_slow_path(ret < 0)) {
- njs_vm_internal_error(vm, "xmlC14NExecute() failed");
+ njs_vm_error(vm, "xmlC14NExecute() failed");
ret = NJS_ERROR;
goto error;
}
rc = deflateInit2(&stream, level, Z_DEFLATED, window_bits, mem_level,
strategy);
if (njs_slow_path(rc != Z_OK)) {
- njs_vm_internal_error(vm, "deflateInit2() failed");
+ njs_vm_error(vm, "deflateInit2() failed");
return NJS_ERROR;
}
if (dictionary.start != NULL) {
rc = deflateSetDictionary(&stream, dictionary.start, dictionary.length);
if (njs_slow_path(rc != Z_OK)) {
- njs_vm_internal_error(vm, "deflateSetDictionary() failed");
+ njs_vm_error(vm, "deflateSetDictionary() failed");
return NJS_ERROR;
}
}
rc = deflate(&stream, Z_FINISH);
if (njs_slow_path(rc < 0)) {
- njs_vm_internal_error(vm, "failed to deflate the data: %s",
- stream.msg);
+ njs_vm_error(vm, "failed to deflate the data: %s",
+ stream.msg);
goto fail;
}
rc = inflateInit2(&stream, window_bits);
if (njs_slow_path(rc != Z_OK)) {
- njs_vm_internal_error(vm, "inflateInit2() failed");
+ njs_vm_error(vm, "inflateInit2() failed");
return NJS_ERROR;
}
if (dictionary.start != NULL) {
rc = inflateSetDictionary(&stream, dictionary.start, dictionary.length);
if (njs_slow_path(rc != Z_OK)) {
- njs_vm_internal_error(vm, "deflateSetDictionary() failed");
+ njs_vm_error(vm, "deflateSetDictionary() failed");
return NJS_ERROR;
}
}
rc = inflate(&stream, Z_NO_FLUSH);
if (njs_slow_path(rc < 0)) {
- njs_vm_internal_error(vm, "failed to inflate the compressed "
- "data: %s", stream.msg);
+ njs_vm_error(vm, "failed to inflate the compressed "
+ "data: %s", stream.msg);
goto fail;
}
if (EVP_DigestInit_ex(dgst->ctx, md, NULL) <= 0) {
njs_evp_md_ctx_free(dgst->ctx);
js_free(cx, dgst);
- JS_ThrowInternalError(cx, "EVP_DigestInit_ex() failed");
+ qjs_throw_error(cx, "EVP_DigestInit_ex() failed");
return JS_EXCEPTION;
}
<= 0)
{
js_free(cx, content.start);
- JS_ThrowInternalError(cx, "EVP_DigestUpdate() failed");
+ qjs_throw_error(cx, "EVP_DigestUpdate() failed");
return JS_EXCEPTION;
}
if (HMAC_Update(hctx->ctx, content.start, content.length) <= 0)
{
js_free(cx, content.start);
- JS_ThrowInternalError(cx, "HMAC_Update() failed");
+ qjs_throw_error(cx, "HMAC_Update() failed");
return JS_EXCEPTION;
}
}
if (!hmac) {
if (EVP_DigestUpdate(dgst->ctx, str.start, str.length) <= 0) {
JS_FreeCString(cx, (const char *) str.start);
- JS_ThrowInternalError(cx, "EVP_DigestUpdate() failed");
+ qjs_throw_error(cx, "EVP_DigestUpdate() failed");
return JS_EXCEPTION;
}
} else {
if (HMAC_Update(hctx->ctx, str.start, str.length) <= 0) {
JS_FreeCString(cx, (const char *) str.start);
- JS_ThrowInternalError(cx, "HMAC_Update() failed");
+ qjs_throw_error(cx, "HMAC_Update() failed");
return JS_EXCEPTION;
}
}
if (!hmac) {
if (EVP_DigestUpdate(dgst->ctx, bytes.start, bytes.length) <= 0) {
- JS_ThrowInternalError(cx, "EVP_DigestUpdate() failed");
+ qjs_throw_error(cx, "EVP_DigestUpdate() failed");
return JS_EXCEPTION;
}
} else {
if (HMAC_Update(hctx->ctx, bytes.start, bytes.length) <= 0) {
- JS_ThrowInternalError(cx, "HMAC_Update() failed");
+ qjs_throw_error(cx, "HMAC_Update() failed");
return JS_EXCEPTION;
}
}
}
if (EVP_DigestFinal_ex(dgst->ctx, digest, &len) <= 0) {
- JS_ThrowInternalError(cx, "EVP_DigestFinal_ex() failed");
+ qjs_throw_error(cx, "EVP_DigestFinal_ex() failed");
return JS_EXCEPTION;
}
}
if (HMAC_Final(hctx->ctx, digest, &len) <= 0) {
- JS_ThrowInternalError(cx, "HMAC_Final() failed");
+ qjs_throw_error(cx, "HMAC_Final() failed");
return JS_EXCEPTION;
}
if (EVP_MD_CTX_copy_ex(copy->ctx, dgst->ctx) <= 0) {
njs_evp_md_ctx_free(copy->ctx);
js_free(cx, copy);
- JS_ThrowInternalError(cx, "EVP_MD_CTX_copy_ex() failed");
+ qjs_throw_error(cx, "EVP_MD_CTX_copy_ex() failed");
return JS_EXCEPTION;
}
JS_FreeCString(cx, (const char *) key.start);
}
- JS_ThrowInternalError(cx, "HMAC_Init_ex() failed");
+ qjs_throw_error(cx, "HMAC_Init_ex() failed");
return JS_EXCEPTION;
}
}
if ((p - path) > NJS_MAX_PATH) {
- JS_ThrowInternalError(cx, "too large path");
+ qjs_throw_error(cx, "too large path");
return JS_EXCEPTION;
}
JS_FreeValue(cx, type);
if (value == QJS_DT_INVALID) {
- JS_ThrowInternalError(cx, "dentry type is not supported on this "
- "platform");
+ qjs_throw_error(cx, "dentry type is not supported on this "
+ "platform");
return JS_EXCEPTION;
}
}
if (njs_bn_bn2binpad(v, &buf[0], size) <= 0) {
- JS_ThrowInternalError(cx, "njs_bn_bn2binpad() failed");
+ qjs_throw_error(cx, "njs_bn_bn2binpad() failed");
return JS_EXCEPTION;
}
ctx = xmlNewParserCtxt();
if (ctx == NULL) {
qjs_bytes_free(cx, &data);
- JS_ThrowInternalError(cx, "xmlNewParserCtxt() failed");
+ qjs_throw_error(cx, "xmlNewParserCtxt() failed");
qjs_xml_doc_free(JS_GetRuntime(cx), tree);
return JS_EXCEPTION;
}
buf = xmlOutputBufferCreateIO(qjs_xml_buf_write_cb, NULL,
&chain, NULL);
if (buf == NULL) {
- JS_ThrowInternalError(cx, "xmlOutputBufferCreateIO() failed");
+ qjs_throw_error(cx, "xmlOutputBufferCreateIO() failed");
goto fail;
}
if (size < 0) {
njs_chb_destroy(&chain);
(void) xmlOutputBufferClose(buf);
- JS_ThrowInternalError(cx, "xmlC14NExecute() failed");
+ qjs_throw_error(cx, "xmlC14NExecute() failed");
goto fail;
}
text = xmlNodeGetContent((xmlNode *) attr);
if (text == NULL) {
- JS_ThrowInternalError(cx, "xmlNodeGetContent() failed");
+ qjs_throw_error(cx, "xmlNodeGetContent() failed");
return JS_EXCEPTION;
}
attr = xmlSetProp(node->node, name, value);
JS_FreeCString(cx, (char *) value);
if (attr == NULL) {
- JS_ThrowInternalError(cx, "xmlSetProp() failed");
+ qjs_throw_error(cx, "xmlSetProp() failed");
return -1;
}
node = xmlDocCopyNode(node, current->doc->doc, 1);
JS_FreeValue(cx, v);
if (node == NULL) {
- JS_ThrowInternalError(cx, "xmlDocCopyNode() failed");
+ qjs_throw_error(cx, "xmlDocCopyNode() failed");
goto error;
}
text = xmlNewDocTextLen(node->doc->doc, content.start, content.length);
JS_FreeCString(cx, (char *) content.start);
if (text == NULL) {
- JS_ThrowInternalError(cx, "xmlNewDocTextLen() failed");
+ qjs_throw_error(cx, "xmlNewDocTextLen() failed");
return -1;
}
}
text = xmlNodeGetContent((xmlNode *) attr);
if (text == NULL) {
- value = JS_ThrowInternalError(cx, "xmlNodeGetContent() failed");
+ value = qjs_throw_error(cx, "xmlNodeGetContent() failed");
break;
}
node = xmlDocCopyNode(node, current->doc->doc, 1);
if (node == NULL) {
- JS_ThrowInternalError(cx, "xmlDocCopyNode() failed");
+ qjs_throw_error(cx, "xmlDocCopyNode() failed");
return JS_EXCEPTION;
}
rc = deflateInit2(&stream, level, Z_DEFLATED, window_bits, mem_level,
strategy);
if (njs_slow_path(rc != Z_OK)) {
- JS_ThrowInternalError(ctx, "deflateInit2() failed");
+ qjs_throw_error(ctx, "deflateInit2() failed");
goto fail;
}
if (dictionary_copy != NULL) {
rc = deflateSetDictionary(&stream, dictionary_copy, dictionary_length);
if (rc != Z_OK) {
- JS_ThrowInternalError(ctx, "deflateSetDictionary() failed");
+ qjs_throw_error(ctx, "deflateSetDictionary() failed");
goto fail;
}
}
rc = deflate(&stream, Z_FINISH);
if (njs_slow_path(rc < 0)) {
- JS_ThrowInternalError(ctx, "failed to deflate the data: %s",
- stream.msg);
+ qjs_throw_error(ctx, "failed to deflate the data: %s",
+ stream.msg);
goto fail;
}
rc = inflateInit2(&stream, window_bits);
if (njs_slow_path(rc != Z_OK)) {
- JS_ThrowInternalError(ctx, "inflateInit2() failed");
+ qjs_throw_error(ctx, "inflateInit2() failed");
goto fail;
}
if (dictionary_copy != NULL) {
rc = inflateSetDictionary(&stream, dictionary_copy, dictionary_length);
if (rc != Z_OK) {
- JS_ThrowInternalError(ctx, "inflateSetDictionary() failed");
+ qjs_throw_error(ctx, "inflateSetDictionary() failed");
goto fail;
}
}
rc = inflate(&stream, Z_NO_FLUSH);
if (njs_slow_path(rc < 0)) {
- JS_ThrowInternalError(ctx, "failed to inflate the data: %s",
- stream.msg);
+ qjs_throw_error(ctx, "failed to inflate the data: %s",
+ stream.msg);
goto fail;
}
rc = inflateEnd(&stream);
if (njs_slow_path(rc != Z_OK)) {
- JS_ThrowInternalError(ctx, "inflateEnd() failed");
+ qjs_throw_error(ctx, "inflateEnd() failed");
goto fail;
}
}
if (ngx_http_set_content_type(r) != NGX_OK) {
- njs_vm_internal_error(vm, "failed to set content type");
+ njs_vm_error(vm, "failed to set content type");
return NJS_ERROR;
}
r->disable_not_modified = 1;
if (ngx_http_send_header(r) == NGX_ERROR) {
- njs_vm_internal_error(vm, "failed to send header");
+ njs_vm_error(vm, "failed to send header");
return NJS_ERROR;
}
*ll = NULL;
if (ngx_http_output_filter(r, out) == NGX_ERROR) {
- njs_vm_internal_error(vm, "failed to send response");
+ njs_vm_error(vm, "failed to send response");
return NJS_ERROR;
}
}
if (ngx_http_send_special(r, NGX_HTTP_LAST) == NGX_ERROR) {
- njs_vm_internal_error(vm, "failed to send response");
+ njs_vm_error(vm, "failed to send response");
return NJS_ERROR;
}
ctx->status = ngx_http_send_response(r, status, NULL, &cv);
if (ctx->status == NGX_ERROR) {
- njs_vm_internal_error(vm, "failed to send response");
+ njs_vm_error(vm, "failed to send response");
return NJS_ERROR;
}
}
if (ngx_http_js_collect_body(r, ctx) != NGX_OK) {
- njs_vm_internal_error(vm, "failed to read request body");
+ njs_vm_error(vm, "failed to read request body");
return NJS_ERROR;
}
resolve:
if (ngx_http_js_collect_body(r, ctx) != NGX_OK) {
- njs_vm_internal_error(vm, "failed to read request body");
+ njs_vm_error(vm, "failed to read request body");
return NJS_ERROR;
}
resolve:
if (ngx_http_js_collect_body(r, ctx) != NGX_OK) {
- njs_vm_internal_error(vm, "failed to read request body");
+ njs_vm_error(vm, "failed to read request body");
return NJS_ERROR;
}
if (ngx_http_subrequest(r, &uri, rargs.len ? &rargs : NULL, &sr, ps, flags)
!= NGX_OK)
{
- njs_vm_internal_error(vm, "subrequest creation failed");
+ njs_vm_error(vm, "subrequest creation failed");
return NJS_ERROR;
}
}
if (ngx_http_send_special(r, NGX_HTTP_LAST) == NGX_ERROR) {
- return JS_ThrowInternalError(cx, "failed to send response");
+ return qjs_throw_error(cx, "failed to send response");
}
ctx = ngx_http_get_module_ctx(r, ngx_http_js_module);
ctx = ngx_http_get_module_ctx(r, ngx_http_js_module);
if (ngx_http_js_collect_body(r, ctx) != NGX_OK) {
- return JS_ThrowInternalError(cx, "failed to read request body");
+ return qjs_throw_error(cx, "failed to read request body");
}
body = ngx_qjs_prop(cx, buffer_type, ctx->body_read_data,
resolve:
if (ngx_http_js_collect_body(r, ctx) != NGX_OK) {
- return JS_ThrowInternalError(cx, "failed to read request body");
+ return qjs_throw_error(cx, "failed to read request body");
}
return ngx_http_qjs_body_to_value(cx, ctx, (ngx_uint_t) magic);
resolve:
if (ngx_http_js_collect_body(r, ctx) != NGX_OK) {
- return JS_ThrowInternalError(cx, "failed to read request body");
+ return qjs_throw_error(cx, "failed to read request body");
}
return ngx_http_qjs_form_to_value(cx, r, ctx, max_keys, this_val);
ctx->status = ngx_http_send_response(r, status, NULL, &cv);
if (ctx->status == NGX_ERROR) {
- return JS_ThrowInternalError(cx, "failed to send response");
+ return qjs_throw_error(cx, "failed to send response");
}
} else {
*ll = NULL;
if (ngx_http_output_filter(r, out) == NGX_ERROR) {
- return JS_ThrowInternalError(cx, "failed to send response");
+ return qjs_throw_error(cx, "failed to send response");
}
return JS_UNDEFINED;
}
if (ngx_http_set_content_type(r) != NGX_OK) {
- return JS_ThrowInternalError(cx, "failed to set content type");
+ return qjs_throw_error(cx, "failed to set content type");
}
r->disable_not_modified = 1;
if (ngx_http_send_header(r) == NGX_ERROR) {
- return JS_ThrowInternalError(cx, "failed to send header");
+ return qjs_throw_error(cx, "failed to send header");
}
return JS_UNDEFINED;
}
JS_FreeValue(cx, retval);
- return JS_ThrowInternalError(cx, "subrequest creation failed");
+ return qjs_throw_error(cx, "subrequest creation failed");
}
if (event != NULL) {
key = JS_NewAtomLen(cx, (char *) start, size);
if (key == JS_ATOM_NULL) {
JS_FreeValue(cx, value);
- return JS_ThrowInternalError(cx, "could not create atom");
+ return qjs_throw_error(cx, "could not create atom");
}
rv = JS_GetProperty(cx, value, key);
(void) close(info.fd);
if (ret != NJS_OK) {
- JS_ThrowInternalError(cx, "while reading \"%.*s\" module",
- (int) info.file.length, info.file.start);
+ qjs_throw_error(cx, "while reading \"%.*s\" module",
+ (int) info.file.length, info.file.start);
return NULL;
}
JS_WRITE_OBJ_BYTECODE);
if (pc->code == NULL) {
JS_FreeValue(cx, func_val);
- JS_ThrowInternalError(cx, "could not write module bytecode");
+ qjs_throw_error(cx, "could not write module bytecode");
return NULL;
}
(void) close(info.fd);
if (ret != NJS_OK) {
- njs_vm_internal_error(vm, "while reading \"%V\" module", &info.file);
+ njs_vm_error(vm, "while reading \"%V\" module", &info.file);
return NULL;
}
ret = ngx_js_set_cwd(njs_vm_memory_pool(vm), conf, &info.file);
if (ret != NJS_OK) {
- njs_vm_internal_error(vm, "while setting cwd for \"%V\" module",
- &info.file);
+ njs_vm_error(vm, "while setting cwd for \"%V\" module",
+ &info.file);
return NULL;
}
&http->proxy.url, &http->proxy.auth)
!= NGX_OK)
{
- njs_vm_internal_error(vm, "failed to evaluate proxy URL");
+ njs_vm_error(vm, "failed to evaluate proxy URL");
goto fail;
}
}
if (ctx == NGX_NO_RESOLVER) {
- njs_vm_internal_error(vm, "no resolver defined");
+ njs_vm_error(vm, "no resolver defined");
goto fail;
}
failed:
- njs_vm_internal_error(vm, "internal error");
+ njs_vm_error(vm, "internal error");
return NULL;
}
error:
- njs_vm_internal_error(vm, "internal error");
+ njs_vm_error(vm, "internal error");
return NJS_ERROR;
}
ngx_js_shared_dict_proto_id,
shm_zone, 0);
if (ret != NJS_OK) {
- njs_vm_internal_error(vm, "sharedDict creation failed");
+ njs_vm_error(vm, "sharedDict creation failed");
return NJS_ERROR;
}
&http->proxy.url, &http->proxy.auth)
!= NGX_OK)
{
- JS_ThrowInternalError(cx, "failed to evaluate proxy URL");
+ qjs_throw_error(cx, "failed to evaluate proxy URL");
goto fail;
}
}
if (rs == NGX_NO_RESOLVER) {
- JS_ThrowInternalError(cx, "no resolver defined");
+ qjs_throw_error(cx, "no resolver defined");
goto fail;
}
JS_FreeValue(cx, fetch->promise_callbacks[0]);
JS_FreeValue(cx, fetch->promise_callbacks[1]);
- JS_ThrowInternalError(cx, "internal error");
+ qjs_throw_error(cx, "internal error");
return NULL;
}
} else {
if (ngx_stream_js_next_filter(s, ctx, cl, from_upstream) == NGX_ERROR) {
- njs_vm_internal_error(vm, "ngx_stream_js_next_filter() failed");
+ njs_vm_error(vm, "ngx_stream_js_next_filter() failed");
return NJS_ERROR;
}
}
JS_FreeCString(cx, str);
}
- return JS_ThrowInternalError(cx, "ngx_stream_js_next_filter() "
- "failed");
+ return qjs_throw_error(cx, "ngx_stream_js_next_filter() "
+ "failed");
}
}
}
+/*
+ * Library and host failures are reported as Error, since QuickJS-NG makes
+ * InternalError uncatchable by JavaScript code.
+ */
+
+JSValue
+qjs_throw_error(JSContext *cx, const char *fmt, ...)
+{
+ char buf[256];
+ JSValue error, message;
+ va_list args;
+
+ va_start(args, fmt);
+ vsnprintf(buf, sizeof(buf), fmt, args);
+ va_end(args);
+
+ error = qjs_new_error(cx);
+ if (JS_IsException(error)) {
+ return JS_EXCEPTION;
+ }
+
+ message = JS_NewString(cx, buf);
+ if (JS_IsException(message)) {
+ JS_FreeValue(cx, error);
+ return JS_EXCEPTION;
+ }
+
+ if (JS_DefinePropertyValueStr(cx, error, "message", message,
+ JS_PROP_WRITABLE | JS_PROP_CONFIGURABLE)
+ < 0)
+ {
+ JS_FreeValue(cx, error);
+ return JS_EXCEPTION;
+ }
+
+ return JS_Throw(cx, error);
+}
+
+
JSValue
qjs_string_create_chb(JSContext *cx, njs_chb_t *chain)
{
val = JS_ThrowRangeError(cx, "invalid string length");
} else {
- val = JS_ThrowInternalError(cx, "failed to create string");
+ val = qjs_throw_error(cx, "failed to create string");
}
njs_chb_destroy(chain);
JSValue qjs_new_uint8_array(JSContext *ctx, int argc, JSValueConst *argv);
JSValue qjs_array_buffer_adopt(JSContext *cx, uint8_t *src, size_t len);
+JSValue qjs_throw_error(JSContext *cx, const char *fmt, ...);
JSValue qjs_buffer_alloc(JSContext *ctx, uint64_t size);
JSValue qjs_buffer_copy(JSContext *ctx, u_char *start, size_t size);
JSValue qjs_buffer_chb_copy(JSContext *ctx, njs_chb_t *chain);
return false;
}
} catch (e) {
- if (e instanceof InternalError) {
+ if (e.message.startsWith('dentry type is not supported')) {
return true;
}
exception: 'RangeError: windowBits must be in the range -15..-8' },
{ value: zlib.deflateRawSync('WAKA', {dictionary: Buffer.from('WAKA')}),
- exception: 'InternalError: failed to inflate the compressed data: invalid distance too far back' },
+ exception: 'Error: failed to inflate the compressed data: invalid distance too far back' },
{ value: zlib.deflateSync('WAKA WAKA WAKA', {dictionary: Buffer.from('WAKA')}),
raw: false,