mirror of
https://github.com/bellard/quickjs.git
synced 2024-11-29 09:08:12 +08:00
Strip trailing spaces
This commit is contained in:
parent
6f480abbc8
commit
37bd4ae62d
2
LICENSE
2
LICENSE
@ -1,5 +1,5 @@
|
||||
QuickJS Javascript Engine
|
||||
|
||||
|
||||
Copyright (c) 2017-2021 Fabrice Bellard
|
||||
Copyright (c) 2017-2021 Charlie Gordon
|
||||
|
||||
|
8
Makefile
8
Makefile
@ -1,6 +1,6 @@
|
||||
#
|
||||
# QuickJS Javascript Engine
|
||||
#
|
||||
#
|
||||
# Copyright (c) 2017-2021 Fabrice Bellard
|
||||
# Copyright (c) 2017-2021 Charlie Gordon
|
||||
#
|
||||
@ -187,7 +187,7 @@ endif
|
||||
|
||||
all: $(OBJDIR) $(OBJDIR)/quickjs.check.o $(OBJDIR)/qjs.check.o $(PROGS)
|
||||
|
||||
QJS_LIB_OBJS=$(OBJDIR)/quickjs.o $(OBJDIR)/libregexp.o $(OBJDIR)/libunicode.o $(OBJDIR)/cutils.o $(OBJDIR)/quickjs-libc.o $(OBJDIR)/libbf.o
|
||||
QJS_LIB_OBJS=$(OBJDIR)/quickjs.o $(OBJDIR)/libregexp.o $(OBJDIR)/libunicode.o $(OBJDIR)/cutils.o $(OBJDIR)/quickjs-libc.o $(OBJDIR)/libbf.o
|
||||
|
||||
QJS_OBJS=$(OBJDIR)/qjs.o $(OBJDIR)/repl.o $(QJS_LIB_OBJS)
|
||||
ifdef CONFIG_BIGNUM
|
||||
@ -375,11 +375,11 @@ examples/point.so: $(OBJDIR)/examples/point.pic.o
|
||||
###############################################################################
|
||||
# documentation
|
||||
|
||||
DOCS=doc/quickjs.pdf doc/quickjs.html doc/jsbignum.pdf doc/jsbignum.html
|
||||
DOCS=doc/quickjs.pdf doc/quickjs.html doc/jsbignum.pdf doc/jsbignum.html
|
||||
|
||||
build_doc: $(DOCS)
|
||||
|
||||
clean_doc:
|
||||
clean_doc:
|
||||
rm -f $(DOCS)
|
||||
|
||||
doc/%.pdf: doc/%.texi
|
||||
|
4
cutils.c
4
cutils.c
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* C utilities
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017 Fabrice Bellard
|
||||
* Copyright (c) 2018 Charlie Gordon
|
||||
*
|
||||
@ -172,7 +172,7 @@ int __attribute__((format(printf, 2, 3))) dbuf_printf(DynBuf *s,
|
||||
va_list ap;
|
||||
char buf[128];
|
||||
int len;
|
||||
|
||||
|
||||
va_start(ap, fmt);
|
||||
len = vsnprintf(buf, sizeof(buf), fmt, ap);
|
||||
va_end(ap);
|
||||
|
16
cutils.h
16
cutils.h
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* C utilities
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017 Fabrice Bellard
|
||||
* Copyright (c) 2018 Charlie Gordon
|
||||
*
|
||||
@ -223,13 +223,13 @@ static inline uint32_t bswap32(uint32_t v)
|
||||
|
||||
static inline uint64_t bswap64(uint64_t v)
|
||||
{
|
||||
return ((v & ((uint64_t)0xff << (7 * 8))) >> (7 * 8)) |
|
||||
((v & ((uint64_t)0xff << (6 * 8))) >> (5 * 8)) |
|
||||
((v & ((uint64_t)0xff << (5 * 8))) >> (3 * 8)) |
|
||||
((v & ((uint64_t)0xff << (4 * 8))) >> (1 * 8)) |
|
||||
((v & ((uint64_t)0xff << (3 * 8))) << (1 * 8)) |
|
||||
((v & ((uint64_t)0xff << (2 * 8))) << (3 * 8)) |
|
||||
((v & ((uint64_t)0xff << (1 * 8))) << (5 * 8)) |
|
||||
return ((v & ((uint64_t)0xff << (7 * 8))) >> (7 * 8)) |
|
||||
((v & ((uint64_t)0xff << (6 * 8))) >> (5 * 8)) |
|
||||
((v & ((uint64_t)0xff << (5 * 8))) >> (3 * 8)) |
|
||||
((v & ((uint64_t)0xff << (4 * 8))) >> (1 * 8)) |
|
||||
((v & ((uint64_t)0xff << (3 * 8))) << (1 * 8)) |
|
||||
((v & ((uint64_t)0xff << (2 * 8))) << (3 * 8)) |
|
||||
((v & ((uint64_t)0xff << (1 * 8))) << (5 * 8)) |
|
||||
((v & ((uint64_t)0xff << (0 * 8))) << (7 * 8));
|
||||
}
|
||||
|
||||
|
@ -289,7 +289,7 @@ precision.
|
||||
Otherwise, the number is rounded to nearest with ties to even using
|
||||
the global precision. It is then converted to string using the minimum
|
||||
number of digits so that its conversion back to a floating point using
|
||||
the global precision and round to nearest gives the same number.
|
||||
the global precision and round to nearest gives the same number.
|
||||
|
||||
@end itemize
|
||||
|
||||
|
@ -160,7 +160,7 @@ Options are:
|
||||
@table @code
|
||||
@item -c
|
||||
Only output bytecode in a C file. The default is to output an executable file.
|
||||
@item -e
|
||||
@item -e
|
||||
Output @code{main()} and bytecode in a C file. The default is to output an
|
||||
executable file.
|
||||
@item -o output
|
||||
@ -489,7 +489,7 @@ optional properties:
|
||||
to be UTF-8 encoded.
|
||||
|
||||
@item full
|
||||
|
||||
|
||||
Boolean (default = false). If true, return the an object contains
|
||||
the properties @code{response} (response content),
|
||||
@code{responseHeaders} (headers separated by CRLF), @code{status}
|
||||
@ -596,7 +596,7 @@ Available exports:
|
||||
Open a file. Return a handle or < 0 if error.
|
||||
|
||||
@item O_RDONLY
|
||||
@item O_WRONLY
|
||||
@item O_WRONLY
|
||||
@item O_RDWR
|
||||
@item O_APPEND
|
||||
@item O_CREAT
|
||||
@ -734,7 +734,7 @@ object containing optional parameters:
|
||||
terminated. In this case, @code{exec} return the exit code if positive
|
||||
or the negated signal number if the process was interrupted by a
|
||||
signal. If false, do not block and return the process id of the child.
|
||||
|
||||
|
||||
@item usePath
|
||||
Boolean (default = true). If true, the file is searched in the
|
||||
@code{PATH} environment variable.
|
||||
@ -758,7 +758,7 @@ object containing optional parameters:
|
||||
@item uid
|
||||
Integer. If present, the process uid with @code{setuid}.
|
||||
|
||||
@item gid
|
||||
@item gid
|
||||
Integer. If present, the process gid with @code{setgid}.
|
||||
|
||||
@end table
|
||||
@ -829,7 +829,7 @@ The worker instances have the following properties:
|
||||
|
||||
@table @code
|
||||
@item postMessage(msg)
|
||||
|
||||
|
||||
Send a message to the corresponding worker. @code{msg} is cloned in
|
||||
the destination worker using an algorithm similar to the @code{HTML}
|
||||
structured clone algorithm. @code{SharedArrayBuffer} are shared
|
||||
@ -972,7 +972,7 @@ The compiler generates bytecode directly with no intermediate
|
||||
representation such as a parse tree, hence it is very fast. Several
|
||||
optimizations passes are done over the generated bytecode.
|
||||
|
||||
A stack-based bytecode was chosen because it is simple and generates
|
||||
A stack-based bytecode was chosen because it is simple and generates
|
||||
compact code.
|
||||
|
||||
For each function, the maximum stack size is computed at compile time so that
|
||||
|
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* QuickJS: Example of C module
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017-2018 Fabrice Bellard
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
|
@ -11,7 +11,7 @@ function calc_pi(prec) {
|
||||
const CHUD_C = 640320m;
|
||||
const CHUD_C3 = 10939058860032000m; /* C^3/24 */
|
||||
const CHUD_DIGITS_PER_TERM = 14.18164746272548; /* log10(C/12)*3 */
|
||||
|
||||
|
||||
/* return [P, Q, G] */
|
||||
function chud_bs(a, b, need_G) {
|
||||
var c, P, Q, G, P1, Q1, G1, P2, Q2, G2, b1;
|
||||
|
@ -11,7 +11,7 @@ function calc_pi() {
|
||||
const CHUD_C = 640320n;
|
||||
const CHUD_C3 = 10939058860032000n; /* C^3/24 */
|
||||
const CHUD_BITS_PER_TERM = 47.11041313821584202247; /* log2(C/12)*3 */
|
||||
|
||||
|
||||
/* return [P, Q, G] */
|
||||
function chud_bs(a, b, need_G) {
|
||||
var c, P, Q, G, P1, Q1, G1, P2, Q2, G2;
|
||||
|
@ -54,7 +54,7 @@ function calc_pi(prec) {
|
||||
const CHUD_C = 640320n;
|
||||
const CHUD_C3 = 10939058860032000n; /* C^3/24 */
|
||||
const CHUD_BITS_PER_TERM = 47.11041313821584202247; /* log2(C/12)*3 */
|
||||
|
||||
|
||||
/* return [P, Q, G] */
|
||||
function chud_bs(a, b, need_G) {
|
||||
var c, P, Q, G, P1, Q1, G1, P2, Q2, G2;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* QuickJS: Example of C module with a class
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2019 Fabrice Bellard
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
@ -49,7 +49,7 @@ static JSValue js_point_ctor(JSContext *ctx,
|
||||
JSPointData *s;
|
||||
JSValue obj = JS_UNDEFINED;
|
||||
JSValue proto;
|
||||
|
||||
|
||||
s = js_mallocz(ctx, sizeof(*s));
|
||||
if (!s)
|
||||
return JS_EXCEPTION;
|
||||
@ -112,7 +112,7 @@ static JSValue js_point_norm(JSContext *ctx, JSValueConst this_val,
|
||||
static JSClassDef js_point_class = {
|
||||
"Point",
|
||||
.finalizer = js_point_finalizer,
|
||||
};
|
||||
};
|
||||
|
||||
static const JSCFunctionListEntry js_point_proto_funcs[] = {
|
||||
JS_CGETSET_MAGIC_DEF("x", js_point_get_xy, js_point_set_xy, 0),
|
||||
@ -123,19 +123,19 @@ static const JSCFunctionListEntry js_point_proto_funcs[] = {
|
||||
static int js_point_init(JSContext *ctx, JSModuleDef *m)
|
||||
{
|
||||
JSValue point_proto, point_class;
|
||||
|
||||
|
||||
/* create the Point class */
|
||||
JS_NewClassID(&js_point_class_id);
|
||||
JS_NewClass(JS_GetRuntime(ctx), js_point_class_id, &js_point_class);
|
||||
|
||||
point_proto = JS_NewObject(ctx);
|
||||
JS_SetPropertyFunctionList(ctx, point_proto, js_point_proto_funcs, countof(js_point_proto_funcs));
|
||||
|
||||
|
||||
point_class = JS_NewCFunction2(ctx, js_point_ctor, "Point", 2, JS_CFUNC_constructor, 0);
|
||||
/* set proto.constructor and ctor.prototype */
|
||||
JS_SetConstructor(ctx, point_class, point_proto);
|
||||
JS_SetClassProto(ctx, js_point_class_id, point_proto);
|
||||
|
||||
|
||||
JS_SetModuleExport(ctx, m, "Point", point_class);
|
||||
return 0;
|
||||
}
|
||||
|
20
libbf.h
20
libbf.h
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* Tiny arbitrary precision floating point library
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017-2021 Fabrice Bellard
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
@ -171,7 +171,7 @@ static inline bf_flags_t bf_set_exp_bits(int n)
|
||||
#define BF_ST_UNDERFLOW (1 << 3)
|
||||
#define BF_ST_INEXACT (1 << 4)
|
||||
/* indicate that a memory allocation error occured. NaN is returned */
|
||||
#define BF_ST_MEM_ERROR (1 << 5)
|
||||
#define BF_ST_MEM_ERROR (1 << 5)
|
||||
|
||||
#define BF_RADIX_MAX 36 /* maximum radix for bf_atof() and bf_ftoa() */
|
||||
|
||||
@ -284,7 +284,7 @@ int bf_sub(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags)
|
||||
int bf_add_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec, bf_flags_t flags);
|
||||
int bf_mul(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags);
|
||||
int bf_mul_ui(bf_t *r, const bf_t *a, uint64_t b1, limb_t prec, bf_flags_t flags);
|
||||
int bf_mul_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec,
|
||||
int bf_mul_si(bf_t *r, const bf_t *a, int64_t b1, limb_t prec,
|
||||
bf_flags_t flags);
|
||||
int bf_mul_2exp(bf_t *r, slimb_t e, limb_t prec, bf_flags_t flags);
|
||||
int bf_div(bf_t *r, const bf_t *a, const bf_t *b, limb_t prec, bf_flags_t flags);
|
||||
@ -341,12 +341,12 @@ int bf_mul_pow_radix(bf_t *r, const bf_t *T, limb_t radix,
|
||||
/* fractional format: prec digits after the decimal point rounded with
|
||||
(flags & BF_RND_MASK) */
|
||||
#define BF_FTOA_FORMAT_FRAC (1 << 16)
|
||||
/* free format:
|
||||
|
||||
/* free format:
|
||||
|
||||
For binary radices with bf_ftoa() and for bfdec_ftoa(): use the minimum
|
||||
number of digits to represent 'a'. The precision and the rounding
|
||||
mode are ignored.
|
||||
|
||||
|
||||
For the non binary radices with bf_ftoa(): use as many digits as
|
||||
necessary so that bf_atof() return the same number when using
|
||||
precision 'prec', rounding to nearest and the subnormal
|
||||
@ -373,7 +373,7 @@ char *bf_ftoa(size_t *plen, const bf_t *a, int radix, limb_t prec,
|
||||
bf_flags_t flags);
|
||||
|
||||
/* modulo 2^n instead of saturation. NaN and infinity return 0 */
|
||||
#define BF_GET_INT_MOD (1 << 0)
|
||||
#define BF_GET_INT_MOD (1 << 0)
|
||||
int bf_get_int32(int *pres, const bf_t *a, int flags);
|
||||
int bf_get_int64(int64_t *pres, const bf_t *a, int flags);
|
||||
int bf_get_uint64(uint64_t *pres, const bf_t *a);
|
||||
@ -387,10 +387,10 @@ int bf_normalize_and_round(bf_t *r, limb_t prec1, bf_flags_t flags);
|
||||
int bf_can_round(const bf_t *a, slimb_t prec, bf_rnd_t rnd_mode, slimb_t k);
|
||||
slimb_t bf_mul_log2_radix(slimb_t a1, unsigned int radix, int is_inv,
|
||||
int is_ceil1);
|
||||
int mp_mul(bf_context_t *s, limb_t *result,
|
||||
const limb_t *op1, limb_t op1_size,
|
||||
int mp_mul(bf_context_t *s, limb_t *result,
|
||||
const limb_t *op1, limb_t op1_size,
|
||||
const limb_t *op2, limb_t op2_size);
|
||||
limb_t mp_add(limb_t *res, const limb_t *op1, const limb_t *op2,
|
||||
limb_t mp_add(limb_t *res, const limb_t *op1, const limb_t *op2,
|
||||
limb_t n, limb_t carry);
|
||||
limb_t mp_add_ui(limb_t *tab, limb_t b, size_t n);
|
||||
int mp_sqrtrem(bf_context_t *s, limb_t *tabs, limb_t *taba, limb_t n);
|
||||
|
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* Regular Expression Engine
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017-2018 Fabrice Bellard
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
|
98
libregexp.c
98
libregexp.c
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* Regular Expression Engine
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017-2018 Fabrice Bellard
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
@ -196,7 +196,7 @@ static int cr_init_char_range(REParseState *s, CharRange *cr, uint32_t c)
|
||||
BOOL invert;
|
||||
const uint16_t *c_pt;
|
||||
int len, i;
|
||||
|
||||
|
||||
invert = c & 1;
|
||||
c_pt = char_range_table[c >> 1];
|
||||
len = *c_pt++;
|
||||
@ -221,7 +221,7 @@ static __maybe_unused void lre_dump_bytecode(const uint8_t *buf,
|
||||
{
|
||||
int pos, len, opcode, bc_len, re_flags, i;
|
||||
uint32_t val;
|
||||
|
||||
|
||||
assert(buf_len >= RE_HEADER_LEN);
|
||||
|
||||
re_flags= buf[0];
|
||||
@ -392,7 +392,7 @@ static int parse_digits(const uint8_t **pp, BOOL allow_overflow)
|
||||
const uint8_t *p;
|
||||
uint64_t v;
|
||||
int c;
|
||||
|
||||
|
||||
p = *pp;
|
||||
v = 0;
|
||||
for(;;) {
|
||||
@ -464,7 +464,7 @@ int lre_parse_escape(const uint8_t **pp, int allow_utf16)
|
||||
{
|
||||
int h, n, i;
|
||||
uint32_t c1;
|
||||
|
||||
|
||||
if (*p == '{' && allow_utf16) {
|
||||
p++;
|
||||
c = 0;
|
||||
@ -658,7 +658,7 @@ static int get_class_atom(REParseState *s, CharRange *cr,
|
||||
const uint8_t *p;
|
||||
uint32_t c;
|
||||
int ret;
|
||||
|
||||
|
||||
p = *pp;
|
||||
|
||||
c = *p;
|
||||
@ -766,7 +766,7 @@ static int re_emit_range(REParseState *s, const CharRange *cr)
|
||||
{
|
||||
int len, i;
|
||||
uint32_t high;
|
||||
|
||||
|
||||
len = (unsigned)cr->len / 2;
|
||||
if (len >= 65535)
|
||||
return re_parse_error(s, "too many ranges");
|
||||
@ -807,7 +807,7 @@ static int re_parse_char_class(REParseState *s, const uint8_t **pp)
|
||||
CharRange cr_s, *cr = &cr_s;
|
||||
CharRange cr1_s, *cr1 = &cr1_s;
|
||||
BOOL invert;
|
||||
|
||||
|
||||
cr_init(cr, s->opaque, lre_realloc);
|
||||
p = *pp;
|
||||
p++; /* skip '[' */
|
||||
@ -895,7 +895,7 @@ static BOOL re_need_check_advance(const uint8_t *bc_buf, int bc_buf_len)
|
||||
int pos, opcode, len;
|
||||
uint32_t val;
|
||||
BOOL ret;
|
||||
|
||||
|
||||
ret = TRUE;
|
||||
pos = 0;
|
||||
while (pos < bc_buf_len) {
|
||||
@ -948,7 +948,7 @@ static int re_is_simple_quantifier(const uint8_t *bc_buf, int bc_buf_len)
|
||||
{
|
||||
int pos, opcode, len, count;
|
||||
uint32_t val;
|
||||
|
||||
|
||||
count = 0;
|
||||
pos = 0;
|
||||
while (pos < bc_buf_len) {
|
||||
@ -1113,7 +1113,7 @@ static int find_group_name(REParseState *s, const char *name)
|
||||
const char *p, *buf_end;
|
||||
size_t len, name_len;
|
||||
int capture_index;
|
||||
|
||||
|
||||
name_len = strlen(name);
|
||||
p = (char *)s->group_names.buf;
|
||||
buf_end = (char *)s->group_names.buf + s->group_names.size;
|
||||
@ -1136,7 +1136,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
|
||||
int c, last_atom_start, quant_min, quant_max, last_capture_count;
|
||||
BOOL greedy, add_zero_advance_check, is_neg, is_backward_lookahead;
|
||||
CharRange cr_s, *cr = &cr_s;
|
||||
|
||||
|
||||
last_atom_start = -1;
|
||||
last_capture_count = 0;
|
||||
p = s->buf_ptr;
|
||||
@ -1259,15 +1259,15 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
|
||||
capture_index = s->capture_count++;
|
||||
re_emit_op_u8(s, REOP_save_start + is_backward_dir,
|
||||
capture_index);
|
||||
|
||||
|
||||
s->buf_ptr = p;
|
||||
if (re_parse_disjunction(s, is_backward_dir))
|
||||
return -1;
|
||||
p = s->buf_ptr;
|
||||
|
||||
|
||||
re_emit_op_u8(s, REOP_save_start + 1 - is_backward_dir,
|
||||
capture_index);
|
||||
|
||||
|
||||
if (re_parse_expect(s, &p, ')'))
|
||||
return -1;
|
||||
}
|
||||
@ -1283,7 +1283,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
|
||||
{
|
||||
const uint8_t *p1;
|
||||
int dummy_res;
|
||||
|
||||
|
||||
p1 = p;
|
||||
if (p1[2] != '<') {
|
||||
/* annex B: we tolerate invalid group names in non
|
||||
@ -1336,10 +1336,10 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
|
||||
goto normal_char;
|
||||
case '1': case '2': case '3': case '4':
|
||||
case '5': case '6': case '7': case '8':
|
||||
case '9':
|
||||
case '9':
|
||||
{
|
||||
const uint8_t *q = ++p;
|
||||
|
||||
|
||||
c = parse_digits(&p, FALSE);
|
||||
if (c < 0 || (c >= s->capture_count && c >= re_count_captures(s))) {
|
||||
if (!s->is_utf16) {
|
||||
@ -1480,7 +1480,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
|
||||
}
|
||||
if (greedy) {
|
||||
int len, pos;
|
||||
|
||||
|
||||
if (quant_max > 0) {
|
||||
/* specific optimization for simple quantifiers */
|
||||
if (dbuf_error(&s->byte_code))
|
||||
@ -1489,7 +1489,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
|
||||
s->byte_code.size - last_atom_start);
|
||||
if (len > 0) {
|
||||
re_emit_op(s, REOP_match);
|
||||
|
||||
|
||||
if (dbuf_insert(&s->byte_code, last_atom_start, 17))
|
||||
goto out_of_memory;
|
||||
pos = last_atom_start;
|
||||
@ -1506,7 +1506,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
|
||||
goto done;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (dbuf_error(&s->byte_code))
|
||||
goto out_of_memory;
|
||||
/* the spec tells that if there is no advance when
|
||||
@ -1518,7 +1518,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
|
||||
} else {
|
||||
add_zero_advance_check = FALSE;
|
||||
}
|
||||
|
||||
|
||||
{
|
||||
int len, pos;
|
||||
len = s->byte_code.size - last_atom_start;
|
||||
@ -1544,7 +1544,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
|
||||
len + 5 * has_goto + add_zero_advance_check * 2);
|
||||
if (add_zero_advance_check) {
|
||||
s->byte_code.buf[last_atom_start + 1 + 4] = REOP_push_char_pos;
|
||||
re_emit_op(s, REOP_check_advance);
|
||||
re_emit_op(s, REOP_check_advance);
|
||||
}
|
||||
if (has_goto)
|
||||
re_emit_goto(s, REOP_goto, last_atom_start);
|
||||
@ -1560,7 +1560,7 @@ static int re_parse_term(REParseState *s, BOOL is_backward_dir)
|
||||
pos += 4;
|
||||
if (add_zero_advance_check) {
|
||||
s->byte_code.buf[pos++] = REOP_push_char_pos;
|
||||
re_emit_op(s, REOP_check_advance);
|
||||
re_emit_op(s, REOP_check_advance);
|
||||
}
|
||||
re_emit_goto(s, REOP_loop, last_atom_start + 5);
|
||||
re_emit_op(s, REOP_drop);
|
||||
@ -1655,14 +1655,14 @@ static int re_parse_alternative(REParseState *s, BOOL is_backward_dir)
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static int re_parse_disjunction(REParseState *s, BOOL is_backward_dir)
|
||||
{
|
||||
int start, len, pos;
|
||||
|
||||
if (lre_check_stack_overflow(s->opaque, 0))
|
||||
return re_parse_error(s, "stack overflow");
|
||||
|
||||
|
||||
start = s->byte_code.size;
|
||||
if (re_parse_alternative(s, is_backward_dir))
|
||||
return -1;
|
||||
@ -1682,7 +1682,7 @@ static int re_parse_disjunction(REParseState *s, BOOL is_backward_dir)
|
||||
|
||||
if (re_parse_alternative(s, is_backward_dir))
|
||||
return -1;
|
||||
|
||||
|
||||
/* patch the goto */
|
||||
len = s->byte_code.size - (pos + 4);
|
||||
put_u32(s->byte_code.buf + pos, len);
|
||||
@ -1695,7 +1695,7 @@ static int compute_stack_size(const uint8_t *bc_buf, int bc_buf_len)
|
||||
{
|
||||
int stack_size, stack_size_max, pos, opcode, len;
|
||||
uint32_t val;
|
||||
|
||||
|
||||
stack_size = 0;
|
||||
stack_size_max = 0;
|
||||
bc_buf += RE_HEADER_LEN;
|
||||
@ -1746,7 +1746,7 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
|
||||
REParseState s_s, *s = &s_s;
|
||||
int stack_size;
|
||||
BOOL is_sticky;
|
||||
|
||||
|
||||
memset(s, 0, sizeof(*s));
|
||||
s->opaque = opaque;
|
||||
s->buf_ptr = (const uint8_t *)buf;
|
||||
@ -1760,7 +1760,7 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
|
||||
s->capture_count = 1;
|
||||
s->total_capture_count = -1;
|
||||
s->has_named_captures = -1;
|
||||
|
||||
|
||||
dbuf_init2(&s->byte_code, opaque, lre_realloc);
|
||||
dbuf_init2(&s->group_names, opaque, lre_realloc);
|
||||
|
||||
@ -1768,7 +1768,7 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
|
||||
dbuf_putc(&s->byte_code, 0); /* second element is the number of captures */
|
||||
dbuf_putc(&s->byte_code, 0); /* stack size */
|
||||
dbuf_put_u32(&s->byte_code, 0); /* bytecode length */
|
||||
|
||||
|
||||
if (!is_sticky) {
|
||||
/* iterate thru all positions (about the same as .*?( ... ) )
|
||||
. We do it without an explicit loop so that lock step
|
||||
@ -1790,7 +1790,7 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
|
||||
}
|
||||
|
||||
re_emit_op_u8(s, REOP_save_end, 0);
|
||||
|
||||
|
||||
re_emit_op(s, REOP_match);
|
||||
|
||||
if (*s->buf_ptr != '\0') {
|
||||
@ -1802,13 +1802,13 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
|
||||
re_parse_out_of_memory(s);
|
||||
goto error;
|
||||
}
|
||||
|
||||
|
||||
stack_size = compute_stack_size(s->byte_code.buf, s->byte_code.size);
|
||||
if (stack_size < 0) {
|
||||
re_parse_error(s, "too many imbricated quantifiers");
|
||||
goto error;
|
||||
}
|
||||
|
||||
|
||||
s->byte_code.buf[RE_HEADER_CAPTURE_COUNT] = s->capture_count;
|
||||
s->byte_code.buf[RE_HEADER_STACK_SIZE] = stack_size;
|
||||
put_u32(s->byte_code.buf + 3, s->byte_code.size - RE_HEADER_LEN);
|
||||
@ -1819,11 +1819,11 @@ uint8_t *lre_compile(int *plen, char *error_msg, int error_msg_size,
|
||||
s->byte_code.buf[RE_HEADER_FLAGS] |= LRE_FLAG_NAMED_GROUPS;
|
||||
}
|
||||
dbuf_free(&s->group_names);
|
||||
|
||||
|
||||
#ifdef DUMP_REOP
|
||||
lre_dump_bytecode(s->byte_code.buf, s->byte_code.size);
|
||||
#endif
|
||||
|
||||
|
||||
error_msg[0] = '\0';
|
||||
*plen = s->byte_code.size;
|
||||
return s->byte_code.buf;
|
||||
@ -1954,7 +1954,7 @@ typedef struct {
|
||||
const uint8_t *cbuf;
|
||||
const uint8_t *cbuf_end;
|
||||
/* 0 = 8 bit chars, 1 = 16 bit chars, 2 = 16 bit chars, UTF-16 */
|
||||
int cbuf_type;
|
||||
int cbuf_type;
|
||||
int capture_count;
|
||||
int stack_size_max;
|
||||
BOOL multi_line;
|
||||
@ -2016,7 +2016,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
|
||||
int cbuf_type;
|
||||
uint32_t val, c;
|
||||
const uint8_t *cbuf_end;
|
||||
|
||||
|
||||
cbuf_type = s->cbuf_type;
|
||||
cbuf_end = s->cbuf_end;
|
||||
|
||||
@ -2114,7 +2114,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
|
||||
case REOP_split_next_first:
|
||||
{
|
||||
const uint8_t *pc1;
|
||||
|
||||
|
||||
val = get_u32(pc);
|
||||
pc += 4;
|
||||
if (opcode == REOP_split_next_first) {
|
||||
@ -2140,7 +2140,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
|
||||
if (ret < 0)
|
||||
return -1;
|
||||
break;
|
||||
|
||||
|
||||
case REOP_goto:
|
||||
val = get_u32(pc);
|
||||
pc += 4 + (int)val;
|
||||
@ -2244,7 +2244,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
|
||||
{
|
||||
const uint8_t *cptr1, *cptr1_end, *cptr1_start;
|
||||
uint32_t c1, c2;
|
||||
|
||||
|
||||
val = *pc++;
|
||||
if (val >= s->capture_count)
|
||||
goto no_match;
|
||||
@ -2287,7 +2287,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
|
||||
{
|
||||
int n;
|
||||
uint32_t low, high, idx_min, idx_max, idx;
|
||||
|
||||
|
||||
n = get_u16(pc); /* n must be >= 1 */
|
||||
pc += 2;
|
||||
if (cptr >= cbuf_end)
|
||||
@ -2327,7 +2327,7 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
|
||||
{
|
||||
int n;
|
||||
uint32_t low, high, idx_min, idx_max, idx;
|
||||
|
||||
|
||||
n = get_u16(pc); /* n must be >= 1 */
|
||||
pc += 2;
|
||||
if (cptr >= cbuf_end)
|
||||
@ -2372,14 +2372,14 @@ static intptr_t lre_exec_backtrack(REExecContext *s, uint8_t **capture,
|
||||
size_t q;
|
||||
intptr_t res;
|
||||
const uint8_t *pc1;
|
||||
|
||||
|
||||
next_pos = get_u32(pc);
|
||||
quant_min = get_u32(pc + 4);
|
||||
quant_max = get_u32(pc + 8);
|
||||
pc += 16;
|
||||
pc1 = pc;
|
||||
pc += (int)next_pos;
|
||||
|
||||
|
||||
q = 0;
|
||||
for(;;) {
|
||||
res = lre_exec_backtrack(s, capture, stack, stack_len,
|
||||
@ -2422,7 +2422,7 @@ int lre_exec(uint8_t **capture,
|
||||
REExecContext s_s, *s = &s_s;
|
||||
int re_flags, i, alloca_size, ret;
|
||||
StackInt *stack_buf;
|
||||
|
||||
|
||||
re_flags = bc_buf[RE_HEADER_FLAGS];
|
||||
s->multi_line = (re_flags & LRE_FLAG_MULTILINE) != 0;
|
||||
s->ignore_case = (re_flags & LRE_FLAG_IGNORECASE) != 0;
|
||||
@ -2442,7 +2442,7 @@ int lre_exec(uint8_t **capture,
|
||||
s->state_stack = NULL;
|
||||
s->state_stack_len = 0;
|
||||
s->state_stack_size = 0;
|
||||
|
||||
|
||||
for(i = 0; i < s->capture_count * 2; i++)
|
||||
capture[i] = NULL;
|
||||
alloca_size = s->stack_size_max * sizeof(stack_buf[0]);
|
||||
@ -2494,7 +2494,7 @@ int main(int argc, char **argv)
|
||||
uint8_t *capture[CAPTURE_COUNT_MAX * 2];
|
||||
const char *input;
|
||||
int input_len, capture_count;
|
||||
|
||||
|
||||
if (argc < 3) {
|
||||
printf("usage: %s regexp input\n", argv[0]);
|
||||
exit(1);
|
||||
@ -2508,7 +2508,7 @@ int main(int argc, char **argv)
|
||||
|
||||
input = argv[2];
|
||||
input_len = strlen(input);
|
||||
|
||||
|
||||
ret = lre_exec(capture, bc, (uint8_t *)input, 0, input_len, 0, NULL);
|
||||
printf("ret=%d\n", ret);
|
||||
if (ret == 1) {
|
||||
|
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* Regular Expression Engine
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017-2018 Fabrice Bellard
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
@ -54,7 +54,7 @@ int lre_parse_escape(const uint8_t **pp, int allow_utf16);
|
||||
LRE_BOOL lre_is_space(int c);
|
||||
|
||||
/* must be provided by the user */
|
||||
LRE_BOOL lre_check_stack_overflow(void *opaque, size_t alloca_size);
|
||||
LRE_BOOL lre_check_stack_overflow(void *opaque, size_t alloca_size);
|
||||
void *lre_realloc(void *opaque, void *ptr, size_t size);
|
||||
|
||||
/* JS identifier test */
|
||||
|
56
libunicode.c
56
libunicode.c
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* Unicode utilities
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017-2018 Fabrice Bellard
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
@ -149,9 +149,9 @@ static int lre_case_conv_entry(uint32_t *res, uint32_t c, int conv_type, uint32_
|
||||
}
|
||||
|
||||
/* conv_type:
|
||||
0 = to upper
|
||||
0 = to upper
|
||||
1 = to lower
|
||||
2 = case folding (= to lower with modifications)
|
||||
2 = case folding (= to lower with modifications)
|
||||
*/
|
||||
int lre_case_conv(uint32_t *res, uint32_t c, int conv_type)
|
||||
{
|
||||
@ -168,7 +168,7 @@ int lre_case_conv(uint32_t *res, uint32_t c, int conv_type)
|
||||
} else {
|
||||
uint32_t v, code, len;
|
||||
int idx, idx_min, idx_max;
|
||||
|
||||
|
||||
idx_min = 0;
|
||||
idx_max = countof(case_conv_table1) - 1;
|
||||
while (idx_min <= idx_max) {
|
||||
@ -240,7 +240,7 @@ int lre_canonicalize(uint32_t c, BOOL is_unicode)
|
||||
} else {
|
||||
uint32_t v, code, len;
|
||||
int idx, idx_min, idx_max;
|
||||
|
||||
|
||||
idx_min = 0;
|
||||
idx_max = countof(case_conv_table1) - 1;
|
||||
while (idx_min <= idx_max) {
|
||||
@ -311,7 +311,7 @@ static BOOL lre_is_in_table(uint32_t c, const uint8_t *table,
|
||||
uint32_t code, b, bit;
|
||||
int pos;
|
||||
const uint8_t *p;
|
||||
|
||||
|
||||
pos = get_index_pos(&code, c, index_table, index_table_len);
|
||||
if (pos < 0)
|
||||
return FALSE; /* outside the table */
|
||||
@ -344,7 +344,7 @@ BOOL lre_is_cased(uint32_t c)
|
||||
{
|
||||
uint32_t v, code, len;
|
||||
int idx, idx_min, idx_max;
|
||||
|
||||
|
||||
idx_min = 0;
|
||||
idx_max = countof(case_conv_table1) - 1;
|
||||
while (idx_min <= idx_max) {
|
||||
@ -403,7 +403,7 @@ int cr_realloc(CharRange *cr, int size)
|
||||
{
|
||||
int new_size;
|
||||
uint32_t *new_buf;
|
||||
|
||||
|
||||
if (size > cr->size) {
|
||||
new_size = max_int(size, cr->size * 3 / 2);
|
||||
new_buf = cr->realloc_func(cr->mem_opaque, cr->points,
|
||||
@ -430,7 +430,7 @@ static void cr_compress(CharRange *cr)
|
||||
{
|
||||
int i, j, k, len;
|
||||
uint32_t *pt;
|
||||
|
||||
|
||||
pt = cr->points;
|
||||
len = cr->len;
|
||||
i = 0;
|
||||
@ -460,7 +460,7 @@ int cr_op(CharRange *cr, const uint32_t *a_pt, int a_len,
|
||||
{
|
||||
int a_idx, b_idx, is_in;
|
||||
uint32_t v;
|
||||
|
||||
|
||||
a_idx = 0;
|
||||
b_idx = 0;
|
||||
for(;;) {
|
||||
@ -761,7 +761,7 @@ static int unicode_decomp_char(uint32_t *res, uint32_t c, BOOL is_compat1)
|
||||
{
|
||||
uint32_t v, type, is_compat, code, len;
|
||||
int idx_min, idx_max, idx;
|
||||
|
||||
|
||||
idx_min = 0;
|
||||
idx_max = countof(unicode_decomp_table1) - 1;
|
||||
while (idx_min <= idx_max) {
|
||||
@ -791,7 +791,7 @@ static int unicode_compose_pair(uint32_t c0, uint32_t c1)
|
||||
uint32_t code, len, type, v, idx1, d_idx, d_offset, ch;
|
||||
int idx_min, idx_max, idx, d;
|
||||
uint32_t pair[2];
|
||||
|
||||
|
||||
idx_min = 0;
|
||||
idx_max = countof(unicode_comp_table) - 1;
|
||||
while (idx_min <= idx_max) {
|
||||
@ -827,7 +827,7 @@ static int unicode_get_cc(uint32_t c)
|
||||
uint32_t code, n, type, cc, c1, b;
|
||||
int pos;
|
||||
const uint8_t *p;
|
||||
|
||||
|
||||
pos = get_index_pos(&code, c,
|
||||
unicode_cc_index, sizeof(unicode_cc_index) / 3);
|
||||
if (pos < 0)
|
||||
@ -876,7 +876,7 @@ static int unicode_get_cc(uint32_t c)
|
||||
static void sort_cc(int *buf, int len)
|
||||
{
|
||||
int i, j, k, cc, cc1, start, ch1;
|
||||
|
||||
|
||||
for(i = 0; i < len; i++) {
|
||||
cc = unicode_get_cc(buf[i]);
|
||||
if (cc != 0) {
|
||||
@ -915,7 +915,7 @@ static void to_nfd_rec(DynBuf *dbuf,
|
||||
uint32_t c, v;
|
||||
int i, l;
|
||||
uint32_t res[UNICODE_DECOMP_LEN_MAX];
|
||||
|
||||
|
||||
for(i = 0; i < src_len; i++) {
|
||||
c = src[i];
|
||||
if (c >= 0xac00 && c < 0xd7a4) {
|
||||
@ -960,7 +960,7 @@ int unicode_normalize(uint32_t **pdst, const uint32_t *src, int src_len,
|
||||
int *buf, buf_len, i, p, starter_pos, cc, last_cc, out_len;
|
||||
BOOL is_compat;
|
||||
DynBuf dbuf_s, *dbuf = &dbuf_s;
|
||||
|
||||
|
||||
is_compat = n_type >> 1;
|
||||
|
||||
dbuf_init2(dbuf, opaque, realloc_func);
|
||||
@ -988,15 +988,15 @@ int unicode_normalize(uint32_t **pdst, const uint32_t *src, int src_len,
|
||||
}
|
||||
buf = (int *)dbuf->buf;
|
||||
buf_len = dbuf->size / sizeof(int);
|
||||
|
||||
|
||||
sort_cc(buf, buf_len);
|
||||
|
||||
|
||||
if (buf_len <= 1 || (n_type & 1) != 0) {
|
||||
/* NFD / NFKD */
|
||||
*pdst = (uint32_t *)buf;
|
||||
return buf_len;
|
||||
}
|
||||
|
||||
|
||||
i = 1;
|
||||
out_len = 1;
|
||||
while (i < buf_len) {
|
||||
@ -1033,7 +1033,7 @@ static int unicode_find_name(const char *name_table, const char *name)
|
||||
const char *p, *r;
|
||||
int pos;
|
||||
size_t name_len, len;
|
||||
|
||||
|
||||
p = name_table;
|
||||
pos = 0;
|
||||
name_len = strlen(name);
|
||||
@ -1066,13 +1066,13 @@ int unicode_script(CharRange *cr,
|
||||
CharRange cr1_s, *cr1;
|
||||
CharRange cr2_s, *cr2 = &cr2_s;
|
||||
BOOL is_common;
|
||||
|
||||
|
||||
script_idx = unicode_find_name(unicode_script_name_table, script_name);
|
||||
if (script_idx < 0)
|
||||
return -2;
|
||||
/* Note: we remove the "Unknown" Script */
|
||||
script_idx += UNICODE_SCRIPT_Unknown + 1;
|
||||
|
||||
|
||||
is_common = (script_idx == UNICODE_SCRIPT_Common ||
|
||||
script_idx == UNICODE_SCRIPT_Inherited);
|
||||
if (is_ext) {
|
||||
@ -1350,7 +1350,7 @@ static int point_cmp(const void *p1, const void *p2, void *arg)
|
||||
static void cr_sort_and_remove_overlap(CharRange *cr)
|
||||
{
|
||||
uint32_t start, end, start1, end1, i, j;
|
||||
|
||||
|
||||
/* the resulting ranges are not necessarily sorted and may overlap */
|
||||
rqsort(cr->points, cr->len / 2, sizeof(cr->points[0]) * 2, point_cmp, NULL);
|
||||
j = 0;
|
||||
@ -1389,7 +1389,7 @@ int cr_regexp_canonicalize(CharRange *cr, BOOL is_unicode)
|
||||
{
|
||||
CharRange cr_inter, cr_mask, cr_result, cr_sub;
|
||||
uint32_t v, code, len, i, idx, start, end, c, d_start, d_end, d;
|
||||
|
||||
|
||||
cr_init(&cr_mask, cr->mem_opaque, cr->realloc_func);
|
||||
cr_init(&cr_inter, cr->mem_opaque, cr->realloc_func);
|
||||
cr_init(&cr_result, cr->mem_opaque, cr->realloc_func);
|
||||
@ -1404,7 +1404,7 @@ int cr_regexp_canonicalize(CharRange *cr, BOOL is_unicode)
|
||||
goto fail;
|
||||
if (cr_op(&cr_sub, cr_mask.points, cr_mask.len, cr->points, cr->len, CR_OP_INTER))
|
||||
goto fail;
|
||||
|
||||
|
||||
/* cr_inter = cr & cr_mask */
|
||||
/* cr_sub = cr & ~cr_mask */
|
||||
|
||||
@ -1488,7 +1488,7 @@ static int unicode_prop_ops(CharRange *cr, ...)
|
||||
CharRange stack[POP_STACK_LEN_MAX];
|
||||
int stack_len, op, ret, i;
|
||||
uint32_t a;
|
||||
|
||||
|
||||
va_start(ap, cr);
|
||||
stack_len = 0;
|
||||
for(;;) {
|
||||
@ -1574,7 +1574,7 @@ int unicode_general_category(CharRange *cr, const char *gc_name)
|
||||
{
|
||||
int gc_idx;
|
||||
uint32_t gc_mask;
|
||||
|
||||
|
||||
gc_idx = unicode_find_name(unicode_gc_name_table, gc_name);
|
||||
if (gc_idx < 0)
|
||||
return -2;
|
||||
@ -1592,7 +1592,7 @@ int unicode_general_category(CharRange *cr, const char *gc_name)
|
||||
int unicode_prop(CharRange *cr, const char *prop_name)
|
||||
{
|
||||
int prop_idx, ret;
|
||||
|
||||
|
||||
prop_idx = unicode_find_name(unicode_prop_name_table, prop_name);
|
||||
if (prop_idx < 0)
|
||||
return -2;
|
||||
|
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* Unicode utilities
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017-2018 Fabrice Bellard
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
|
4
list.h
4
list.h
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* Linux klist like system
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2016-2017 Fabrice Bellard
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
@ -45,7 +45,7 @@ static inline void init_list_head(struct list_head *head)
|
||||
}
|
||||
|
||||
/* insert 'el' between 'prev' and 'next' */
|
||||
static inline void __list_add(struct list_head *el,
|
||||
static inline void __list_add(struct list_head *el,
|
||||
struct list_head *prev, struct list_head *next)
|
||||
{
|
||||
prev->next = el;
|
||||
|
12
qjs.c
12
qjs.c
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* QuickJS stand alone interpreter
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017-2021 Fabrice Bellard
|
||||
* Copyright (c) 2017-2021 Charlie Gordon
|
||||
*
|
||||
@ -83,7 +83,7 @@ static int eval_file(JSContext *ctx, const char *filename, int module)
|
||||
uint8_t *buf;
|
||||
int ret, eval_flags;
|
||||
size_t buf_len;
|
||||
|
||||
|
||||
buf = js_load_file(ctx, &buf_len, filename);
|
||||
if (!buf) {
|
||||
perror(filename);
|
||||
@ -315,7 +315,7 @@ int main(int argc, char **argv)
|
||||
int load_jscalc;
|
||||
#endif
|
||||
size_t stack_size = 0;
|
||||
|
||||
|
||||
#ifdef CONFIG_BIGNUM
|
||||
/* load jscalc runtime if invoked as 'qjscalc' */
|
||||
{
|
||||
@ -327,7 +327,7 @@ int main(int argc, char **argv)
|
||||
load_jscalc = !strcmp(exename, "qjscalc");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/* cannot use getopt because we want to pass the command line to
|
||||
the script */
|
||||
optind = 1;
|
||||
@ -478,7 +478,7 @@ int main(int argc, char **argv)
|
||||
JS_SetHostPromiseRejectionTracker(rt, js_std_promise_rejection_tracker,
|
||||
NULL);
|
||||
}
|
||||
|
||||
|
||||
if (!empty_run) {
|
||||
#ifdef CONFIG_BIGNUM
|
||||
if (load_jscalc) {
|
||||
@ -519,7 +519,7 @@ int main(int argc, char **argv)
|
||||
}
|
||||
js_std_loop(ctx);
|
||||
}
|
||||
|
||||
|
||||
if (dump_memory) {
|
||||
JSMemoryUsage stats;
|
||||
JS_ComputeMemoryUsage(rt, &stats);
|
||||
|
52
qjsc.c
52
qjsc.c
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* QuickJS command line compiler
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2018-2021 Fabrice Bellard
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
@ -129,7 +129,7 @@ static void get_c_name(char *buf, size_t buf_size, const char *file)
|
||||
size_t len, i;
|
||||
int c;
|
||||
char *q;
|
||||
|
||||
|
||||
p = strrchr(file, '/');
|
||||
if (!p)
|
||||
p = file;
|
||||
@ -187,8 +187,8 @@ static void output_object_code(JSContext *ctx,
|
||||
}
|
||||
|
||||
namelist_add(&cname_list, c_name, NULL, load_only);
|
||||
|
||||
fprintf(fo, "const uint32_t %s_size = %u;\n\n",
|
||||
|
||||
fprintf(fo, "const uint32_t %s_size = %u;\n\n",
|
||||
c_name, (unsigned int)out_buf_len);
|
||||
fprintf(fo, "const uint8_t %s[%u] = {\n",
|
||||
c_name, (unsigned int)out_buf_len);
|
||||
@ -251,14 +251,14 @@ JSModuleDef *jsc_module_loader(JSContext *ctx,
|
||||
uint8_t *buf;
|
||||
JSValue func_val;
|
||||
char cname[1024];
|
||||
|
||||
|
||||
buf = js_load_file(ctx, &buf_len, module_name);
|
||||
if (!buf) {
|
||||
JS_ThrowReferenceError(ctx, "could not load module filename '%s'",
|
||||
module_name);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
/* compile the module */
|
||||
func_val = JS_Eval(ctx, (char *)buf, buf_len, module_name,
|
||||
JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
|
||||
@ -270,7 +270,7 @@ JSModuleDef *jsc_module_loader(JSContext *ctx,
|
||||
find_unique_cname(cname, sizeof(cname));
|
||||
}
|
||||
output_object_code(ctx, outfile, func_val, cname, TRUE);
|
||||
|
||||
|
||||
/* the module is already referenced, so we must free it */
|
||||
m = JS_VALUE_GET_PTR(func_val);
|
||||
JS_FreeValue(ctx, func_val);
|
||||
@ -288,7 +288,7 @@ static void compile_file(JSContext *ctx, FILE *fo,
|
||||
int eval_flags;
|
||||
JSValue obj;
|
||||
size_t buf_len;
|
||||
|
||||
|
||||
buf = js_load_file(ctx, &buf_len, filename);
|
||||
if (!buf) {
|
||||
fprintf(stderr, "Could not load '%s'\n", filename);
|
||||
@ -383,7 +383,7 @@ int exec_cmd(char **argv)
|
||||
if (pid == 0) {
|
||||
execvp(argv[0], argv);
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
for(;;) {
|
||||
ret = waitpid(pid, &status, 0);
|
||||
@ -401,7 +401,7 @@ static int output_executable(const char *out_filename, const char *cfilename,
|
||||
char libjsname[1024];
|
||||
char exe_dir[1024], inc_dir[1024], lib_dir[1024], buf[1024], *p;
|
||||
int ret;
|
||||
|
||||
|
||||
/* get the directory of the executable */
|
||||
pstrcpy(exe_dir, sizeof(exe_dir), exename);
|
||||
p = strrchr(exe_dir, '/');
|
||||
@ -421,10 +421,10 @@ static int output_executable(const char *out_filename, const char *cfilename,
|
||||
snprintf(inc_dir, sizeof(inc_dir), "%s/include/quickjs", CONFIG_PREFIX);
|
||||
snprintf(lib_dir, sizeof(lib_dir), "%s/lib/quickjs", CONFIG_PREFIX);
|
||||
}
|
||||
|
||||
|
||||
lto_suffix = "";
|
||||
bn_suffix = "";
|
||||
|
||||
|
||||
arg = argv;
|
||||
*arg++ = CONFIG_CC;
|
||||
*arg++ = "-O2";
|
||||
@ -452,13 +452,13 @@ static int output_executable(const char *out_filename, const char *cfilename,
|
||||
*arg++ = "-ldl";
|
||||
*arg++ = "-lpthread";
|
||||
*arg = NULL;
|
||||
|
||||
|
||||
if (verbose) {
|
||||
for(arg = argv; *arg != NULL; arg++)
|
||||
printf("%s ", *arg);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
|
||||
ret = exec_cmd((char **)argv);
|
||||
unlink(cfilename);
|
||||
return ret;
|
||||
@ -496,7 +496,7 @@ int main(int argc, char **argv)
|
||||
BOOL bignum_ext = FALSE;
|
||||
#endif
|
||||
namelist_t dynamic_module_list;
|
||||
|
||||
|
||||
out_filename = NULL;
|
||||
output_type = OUTPUT_EXECUTABLE;
|
||||
cname = NULL;
|
||||
@ -507,7 +507,7 @@ int main(int argc, char **argv)
|
||||
use_lto = FALSE;
|
||||
stack_size = 0;
|
||||
memset(&dynamic_module_list, 0, sizeof(dynamic_module_list));
|
||||
|
||||
|
||||
/* add system modules */
|
||||
namelist_add(&cmodule_list, "std", "std", 0);
|
||||
namelist_add(&cmodule_list, "os", "os", 0);
|
||||
@ -620,14 +620,14 @@ int main(int argc, char **argv)
|
||||
} else {
|
||||
pstrcpy(cfilename, sizeof(cfilename), out_filename);
|
||||
}
|
||||
|
||||
|
||||
fo = fopen(cfilename, "w");
|
||||
if (!fo) {
|
||||
perror(cfilename);
|
||||
exit(1);
|
||||
}
|
||||
outfile = fo;
|
||||
|
||||
|
||||
rt = JS_NewRuntime();
|
||||
ctx = JS_NewContext(rt);
|
||||
#ifdef CONFIG_BIGNUM
|
||||
@ -638,14 +638,14 @@ int main(int argc, char **argv)
|
||||
JS_EnableBignumExt(ctx, TRUE);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
/* loader for ES6 modules */
|
||||
JS_SetModuleLoaderFunc(rt, NULL, jsc_module_loader, NULL);
|
||||
|
||||
fprintf(fo, "/* File generated automatically by the QuickJS compiler. */\n"
|
||||
"\n"
|
||||
);
|
||||
|
||||
|
||||
if (output_type != OUTPUT_C) {
|
||||
fprintf(fo, "#include \"quickjs-libc.h\"\n"
|
||||
"\n"
|
||||
@ -669,7 +669,7 @@ int main(int argc, char **argv)
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (output_type != OUTPUT_C) {
|
||||
fprintf(fo,
|
||||
"static JSContext *JS_NewCustomContext(JSRuntime *rt)\n"
|
||||
@ -700,7 +700,7 @@ int main(int argc, char **argv)
|
||||
for(i = 0; i < init_module_list.count; i++) {
|
||||
namelist_entry_t *e = &init_module_list.array[i];
|
||||
/* initialize the static C modules */
|
||||
|
||||
|
||||
fprintf(fo,
|
||||
" {\n"
|
||||
" extern JSModuleDef *js_init_module_%s(JSContext *ctx, const char *name);\n"
|
||||
@ -718,19 +718,19 @@ int main(int argc, char **argv)
|
||||
fprintf(fo,
|
||||
" return ctx;\n"
|
||||
"}\n\n");
|
||||
|
||||
|
||||
fputs(main_c_template1, fo);
|
||||
|
||||
if (stack_size != 0) {
|
||||
fprintf(fo, " JS_SetMaxStackSize(rt, %u);\n",
|
||||
(unsigned int)stack_size);
|
||||
}
|
||||
|
||||
|
||||
/* add the module loader if necessary */
|
||||
if (feature_bitmap & (1 << FE_MODULE_LOADER)) {
|
||||
fprintf(fo, " JS_SetModuleLoaderFunc(rt, NULL, js_module_loader, NULL);\n");
|
||||
}
|
||||
|
||||
|
||||
fprintf(fo,
|
||||
" ctx = JS_NewCustomContext(rt);\n"
|
||||
" js_std_add_helpers(ctx, argc, argv);\n");
|
||||
@ -744,7 +744,7 @@ int main(int argc, char **argv)
|
||||
}
|
||||
fputs(main_c_template2, fo);
|
||||
}
|
||||
|
||||
|
||||
JS_FreeContext(ctx);
|
||||
JS_FreeRuntime(rt);
|
||||
|
||||
|
76
qjscalc.js
76
qjscalc.js
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* QuickJS Javascript Calculator
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017-2020 Fabrice Bellard
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
@ -30,7 +30,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
global.Integer = global.BigInt;
|
||||
global.Float = global.BigFloat;
|
||||
global.algebraicMode = true;
|
||||
|
||||
|
||||
/* add non enumerable properties */
|
||||
function add_props(obj, props) {
|
||||
var i, val, prop, tab, desc;
|
||||
@ -85,9 +85,9 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
}
|
||||
}
|
||||
proto[Symbol.operatorSet] =
|
||||
Operators.create.call(null, ...new_op_list);
|
||||
Operators.create.call(null, ...new_op_list);
|
||||
}
|
||||
|
||||
|
||||
/* Integer */
|
||||
|
||||
function generic_pow(a, b) {
|
||||
@ -121,7 +121,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
var small_primes = [ 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499 ];
|
||||
|
||||
function miller_rabin_test(n, t) {
|
||||
@ -184,7 +184,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
|
||||
add_props(Integer, {
|
||||
isInteger(a) {
|
||||
/* integers are represented either as bigint or as number */
|
||||
@ -305,7 +305,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
r.push(-1);
|
||||
n = -n;
|
||||
}
|
||||
|
||||
|
||||
while ((n % 2) == 0) {
|
||||
n >>= 1;
|
||||
r.push(2);
|
||||
@ -394,7 +394,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
a = Integer.tdiv(a, d);
|
||||
b = Integer.tdiv(b, d);
|
||||
}
|
||||
|
||||
|
||||
/* the fractions are normalized with den > 0 */
|
||||
if (b < 0) {
|
||||
a = -a;
|
||||
@ -476,7 +476,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
else
|
||||
return a < b;
|
||||
}
|
||||
|
||||
|
||||
operators_set(Fraction.prototype,
|
||||
{
|
||||
"+": fraction_add,
|
||||
@ -518,7 +518,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
"==": float_eq,
|
||||
"<": float_lt,
|
||||
});
|
||||
|
||||
|
||||
add_props(Fraction, {
|
||||
/* (internal use) simplify 'a' to an integer when possible */
|
||||
toFraction(a, b) {
|
||||
@ -602,11 +602,11 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
|
||||
/* Float */
|
||||
|
||||
var const_tab = [];
|
||||
|
||||
|
||||
/* we cache the constants for small precisions */
|
||||
function get_const(n) {
|
||||
var t, c, p;
|
||||
@ -631,7 +631,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
return c;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
add_props(Float, {
|
||||
isFloat(a) {
|
||||
return typeof a === "number" || typeof a === "bigfloat";
|
||||
@ -700,9 +700,9 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
|
||||
/* Complex */
|
||||
|
||||
|
||||
Complex = function Complex(re, im)
|
||||
{
|
||||
var obj;
|
||||
@ -719,7 +719,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
return obj;
|
||||
}
|
||||
|
||||
|
||||
|
||||
function complex_add(a, b) {
|
||||
a = Complex(a);
|
||||
b = Complex(b);
|
||||
@ -746,7 +746,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
b = Complex(b);
|
||||
return a.re == b.re && a.im == b.im;
|
||||
}
|
||||
|
||||
|
||||
operators_set(Complex.prototype,
|
||||
{
|
||||
"+": complex_add,
|
||||
@ -772,7 +772,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
"**": generic_pow,
|
||||
"==": complex_eq,
|
||||
});
|
||||
|
||||
|
||||
add_props(Complex, {
|
||||
/* simplify to real number when possible */
|
||||
toComplex(re, im) {
|
||||
@ -851,7 +851,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
obj.mod = m;
|
||||
return obj;
|
||||
};
|
||||
|
||||
|
||||
function mod_add(a, b) {
|
||||
if (!(a instanceof Mod)) {
|
||||
return Mod(a + b.res, b.mod);
|
||||
@ -947,7 +947,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
Polynomial = function Polynomial(a)
|
||||
{
|
||||
if (new.target)
|
||||
@ -1017,7 +1017,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
/* trivial zero */
|
||||
if (p[0] == 0)
|
||||
return 0.0;
|
||||
|
||||
|
||||
p1 = p.deriv();
|
||||
p2 = p1.deriv();
|
||||
el = 0.0;
|
||||
@ -1041,7 +1041,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
}
|
||||
el = e;
|
||||
zl = z;
|
||||
|
||||
|
||||
z1 = p1.apply(z);
|
||||
z2 = p2.apply(z);
|
||||
t0 = (d - 1) * z1;
|
||||
@ -1052,7 +1052,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
d2 = z1 - t0;
|
||||
if (norm2(d2) > norm2(d1))
|
||||
d1 = d2;
|
||||
if (d1 == 0)
|
||||
if (d1 == 0)
|
||||
return null;
|
||||
z = z - d * z0 / d1;
|
||||
}
|
||||
@ -1274,7 +1274,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
"/": polynomial_div_scalar,
|
||||
"**": generic_pow, /* XXX: only for integer */
|
||||
});
|
||||
|
||||
|
||||
add_props(Polynomial, {
|
||||
divrem(a, b) {
|
||||
var n1, n2, i, j, q, r, n, c;
|
||||
@ -1437,7 +1437,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
});
|
||||
|
||||
/* Rational function */
|
||||
|
||||
|
||||
RationalFunction = function RationalFunction(a, b)
|
||||
{
|
||||
var t, r, d, obj;
|
||||
@ -1538,7 +1538,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
"/": ratfunc_div,
|
||||
"**": generic_pow, /* should only be used with integers */
|
||||
});
|
||||
|
||||
|
||||
add_props(RationalFunction, {
|
||||
/* This function always return a RationalFunction object even
|
||||
if it could simplified to a polynomial, so it is not
|
||||
@ -1555,7 +1555,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
}
|
||||
},
|
||||
});
|
||||
|
||||
|
||||
/* Power series */
|
||||
|
||||
/* 'a' is an array */
|
||||
@ -1574,11 +1574,11 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
return polynomial_is_scalar(a) ||
|
||||
(a instanceof Polynomial);
|
||||
}
|
||||
|
||||
|
||||
/* n is the maximum number of terms if 'a' is not a serie */
|
||||
Series = function Series(a, n) {
|
||||
var emin, r, i;
|
||||
|
||||
|
||||
if (a instanceof Series) {
|
||||
return a;
|
||||
} else if (series_is_scalar_or_polynomial(a)) {
|
||||
@ -1897,7 +1897,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
return Series.zero(0, n);
|
||||
},
|
||||
});
|
||||
|
||||
|
||||
/* Array (Matrix) */
|
||||
|
||||
Matrix = function Matrix(h, w) {
|
||||
@ -2002,7 +2002,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
},
|
||||
det(a) {
|
||||
var n, i, j, k, s, src, v, c;
|
||||
|
||||
|
||||
n = Matrix.check_square(a);
|
||||
s = 1;
|
||||
src = a.dup();
|
||||
@ -2061,7 +2061,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
src[i][k] *= c;
|
||||
dst[i][k] *= c;
|
||||
}
|
||||
|
||||
|
||||
for(j = 0; j < n; j++) {
|
||||
if (j != i) {
|
||||
c = src[j][i];
|
||||
@ -2078,7 +2078,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
},
|
||||
rank(a) {
|
||||
var src, i, j, k, w, h, l, c;
|
||||
|
||||
|
||||
if (!Array.isArray(a) ||
|
||||
!Array.isArray(a[0]))
|
||||
throw TypeError("matrix expected");
|
||||
@ -2101,12 +2101,12 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
src[l][k] = v;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
c = src[l][i].inverse();
|
||||
for(k = 0; k < w; k++) {
|
||||
src[l][k] *= c;
|
||||
}
|
||||
|
||||
|
||||
for(j = l + 1; j < h; j++) {
|
||||
c = src[j][i];
|
||||
for(k = i; k < w; k++) {
|
||||
@ -2119,7 +2119,7 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
},
|
||||
ker(a) {
|
||||
var src, i, j, k, w, h, l, m, r, im_cols, ker_dim, c;
|
||||
|
||||
|
||||
if (!Array.isArray(a) ||
|
||||
!Array.isArray(a[0]))
|
||||
throw TypeError("matrix expected");
|
||||
@ -2145,12 +2145,12 @@ var Integer, Float, Fraction, Complex, Mod, Polynomial, PolyMod, RationalFunctio
|
||||
src[l][k] = v;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
c = src[l][i].inverse();
|
||||
for(k = 0; k < w; k++) {
|
||||
src[l][k] *= c;
|
||||
}
|
||||
|
||||
|
||||
for(j = 0; j < h; j++) {
|
||||
if (j != l) {
|
||||
c = src[j][i];
|
||||
|
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* QuickJS atom definitions
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017-2018 Fabrice Bellard
|
||||
* Copyright (c) 2017-2018 Charlie Gordon
|
||||
*
|
||||
@ -204,7 +204,7 @@ DEF(RegExp, "RegExp")
|
||||
DEF(ArrayBuffer, "ArrayBuffer")
|
||||
DEF(SharedArrayBuffer, "SharedArrayBuffer")
|
||||
/* must keep same order as class IDs for typed arrays */
|
||||
DEF(Uint8ClampedArray, "Uint8ClampedArray")
|
||||
DEF(Uint8ClampedArray, "Uint8ClampedArray")
|
||||
DEF(Int8Array, "Int8Array")
|
||||
DEF(Uint8Array, "Uint8Array")
|
||||
DEF(Int16Array, "Int16Array")
|
||||
@ -269,5 +269,5 @@ DEF(Symbol_asyncIterator, "Symbol.asyncIterator")
|
||||
#ifdef CONFIG_BIGNUM
|
||||
DEF(Symbol_operatorSet, "Symbol.operatorSet")
|
||||
#endif
|
||||
|
||||
|
||||
#endif /* DEF */
|
||||
|
208
quickjs-libc.c
208
quickjs-libc.c
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* QuickJS C library
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017-2021 Fabrice Bellard
|
||||
* Copyright (c) 2017-2021 Charlie Gordon
|
||||
*
|
||||
@ -181,7 +181,7 @@ static JSValue js_printf_internal(JSContext *ctx,
|
||||
break;
|
||||
q = fmtbuf;
|
||||
*q++ = *fmt++; /* copy '%' */
|
||||
|
||||
|
||||
/* flags */
|
||||
for(;;) {
|
||||
c = *fmt;
|
||||
@ -235,14 +235,14 @@ static JSValue js_printf_internal(JSContext *ctx,
|
||||
if (*fmt == 'l') {
|
||||
mod = *fmt++;
|
||||
}
|
||||
|
||||
|
||||
/* type */
|
||||
c = *fmt++;
|
||||
if (q >= fmtbuf + sizeof(fmtbuf) - 1)
|
||||
goto invalid;
|
||||
*q++ = c;
|
||||
*q = '\0';
|
||||
|
||||
|
||||
switch (c) {
|
||||
case 'c':
|
||||
if (i >= argc)
|
||||
@ -264,7 +264,7 @@ static JSValue js_printf_internal(JSContext *ctx,
|
||||
len = unicode_to_utf8(cbuf, int32_arg);
|
||||
dbuf_put(&dbuf, cbuf, len);
|
||||
break;
|
||||
|
||||
|
||||
case 'd':
|
||||
case 'i':
|
||||
case 'o':
|
||||
@ -309,7 +309,7 @@ static JSValue js_printf_internal(JSContext *ctx,
|
||||
dbuf_printf_fun(&dbuf, fmtbuf, string_arg);
|
||||
JS_FreeCString(ctx, string_arg);
|
||||
break;
|
||||
|
||||
|
||||
case 'e':
|
||||
case 'f':
|
||||
case 'g':
|
||||
@ -324,11 +324,11 @@ static JSValue js_printf_internal(JSContext *ctx,
|
||||
goto fail;
|
||||
dbuf_printf_fun(&dbuf, fmtbuf, double_arg);
|
||||
break;
|
||||
|
||||
|
||||
case '%':
|
||||
dbuf_putc(&dbuf, '%');
|
||||
break;
|
||||
|
||||
|
||||
default:
|
||||
/* XXX: should support an extension mechanism */
|
||||
invalid:
|
||||
@ -365,7 +365,7 @@ uint8_t *js_load_file(JSContext *ctx, size_t *pbuf_len, const char *filename)
|
||||
uint8_t *buf;
|
||||
size_t buf_len;
|
||||
long lret;
|
||||
|
||||
|
||||
f = fopen(filename, "rb");
|
||||
if (!f)
|
||||
return NULL;
|
||||
@ -412,7 +412,7 @@ static JSValue js_loadScript(JSContext *ctx, JSValueConst this_val,
|
||||
const char *filename;
|
||||
JSValue ret;
|
||||
size_t buf_len;
|
||||
|
||||
|
||||
filename = JS_ToCString(ctx, argv[0]);
|
||||
if (!filename)
|
||||
return JS_EXCEPTION;
|
||||
@ -437,7 +437,7 @@ static JSValue js_std_loadFile(JSContext *ctx, JSValueConst this_val,
|
||||
const char *filename;
|
||||
JSValue ret;
|
||||
size_t buf_len;
|
||||
|
||||
|
||||
filename = JS_ToCString(ctx, argv[0]);
|
||||
if (!filename)
|
||||
return JS_EXCEPTION;
|
||||
@ -469,7 +469,7 @@ static JSModuleDef *js_module_loader_so(JSContext *ctx,
|
||||
void *hd;
|
||||
JSInitModuleFunc *init;
|
||||
char *filename;
|
||||
|
||||
|
||||
if (!strchr(module_name, '/')) {
|
||||
/* must add a '/' so that the DLL is not searched in the
|
||||
system library paths */
|
||||
@ -481,7 +481,7 @@ static JSModuleDef *js_module_loader_so(JSContext *ctx,
|
||||
} else {
|
||||
filename = (char *)module_name;
|
||||
}
|
||||
|
||||
|
||||
/* C module */
|
||||
hd = dlopen(filename, RTLD_NOW | RTLD_LOCAL);
|
||||
if (filename != module_name)
|
||||
@ -520,7 +520,7 @@ int js_module_set_import_meta(JSContext *ctx, JSValueConst func_val,
|
||||
JSValue meta_obj;
|
||||
JSAtom module_name_atom;
|
||||
const char *module_name;
|
||||
|
||||
|
||||
assert(JS_VALUE_GET_TAG(func_val) == JS_TAG_MODULE);
|
||||
m = JS_VALUE_GET_PTR(func_val);
|
||||
|
||||
@ -551,7 +551,7 @@ int js_module_set_import_meta(JSContext *ctx, JSValueConst func_val,
|
||||
pstrcpy(buf, sizeof(buf), module_name);
|
||||
}
|
||||
JS_FreeCString(ctx, module_name);
|
||||
|
||||
|
||||
meta_obj = JS_GetImportMeta(ctx, m);
|
||||
if (JS_IsException(meta_obj))
|
||||
return -1;
|
||||
@ -576,14 +576,14 @@ JSModuleDef *js_module_loader(JSContext *ctx,
|
||||
size_t buf_len;
|
||||
uint8_t *buf;
|
||||
JSValue func_val;
|
||||
|
||||
|
||||
buf = js_load_file(ctx, &buf_len, module_name);
|
||||
if (!buf) {
|
||||
JS_ThrowReferenceError(ctx, "could not load module filename '%s'",
|
||||
module_name);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
/* compile the module */
|
||||
func_val = JS_Eval(ctx, (char *)buf, buf_len, module_name,
|
||||
JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
|
||||
@ -754,7 +754,7 @@ static JSValue js_evalScript(JSContext *ctx, JSValueConst this_val,
|
||||
BOOL backtrace_barrier = FALSE;
|
||||
BOOL is_async = FALSE;
|
||||
int flags;
|
||||
|
||||
|
||||
if (argc >= 2) {
|
||||
options_obj = argv[1];
|
||||
if (get_bool_option(ctx, &backtrace_barrier, options_obj,
|
||||
@ -772,7 +772,7 @@ static JSValue js_evalScript(JSContext *ctx, JSValueConst this_val,
|
||||
/* install the interrupt handler */
|
||||
JS_SetInterruptHandler(JS_GetRuntime(ctx), interrupt_handler, NULL);
|
||||
}
|
||||
flags = JS_EVAL_TYPE_GLOBAL;
|
||||
flags = JS_EVAL_TYPE_GLOBAL;
|
||||
if (backtrace_barrier)
|
||||
flags |= JS_EVAL_FLAG_BACKTRACE_BARRIER;
|
||||
if (is_async)
|
||||
@ -878,7 +878,7 @@ static JSValue js_std_open(JSContext *ctx, JSValueConst this_val,
|
||||
const char *filename, *mode = NULL;
|
||||
FILE *f;
|
||||
int err;
|
||||
|
||||
|
||||
filename = JS_ToCString(ctx, argv[0]);
|
||||
if (!filename)
|
||||
goto fail;
|
||||
@ -914,7 +914,7 @@ static JSValue js_std_popen(JSContext *ctx, JSValueConst this_val,
|
||||
const char *filename, *mode = NULL;
|
||||
FILE *f;
|
||||
int err;
|
||||
|
||||
|
||||
filename = JS_ToCString(ctx, argv[0]);
|
||||
if (!filename)
|
||||
goto fail;
|
||||
@ -1028,7 +1028,7 @@ static JSValue js_std_file_puts(JSContext *ctx, JSValueConst this_val,
|
||||
if (!f)
|
||||
return JS_EXCEPTION;
|
||||
}
|
||||
|
||||
|
||||
for(i = 0; i < argc; i++) {
|
||||
str = JS_ToCStringLen(ctx, &len, argv[i]);
|
||||
if (!str)
|
||||
@ -1159,7 +1159,7 @@ static JSValue js_std_file_read_write(JSContext *ctx, JSValueConst this_val,
|
||||
uint64_t pos, len;
|
||||
size_t size, ret;
|
||||
uint8_t *buf;
|
||||
|
||||
|
||||
if (!f)
|
||||
return JS_EXCEPTION;
|
||||
if (JS_ToIndex(ctx, &pos, argv[1]))
|
||||
@ -1186,7 +1186,7 @@ static JSValue js_std_file_getline(JSContext *ctx, JSValueConst this_val,
|
||||
int c;
|
||||
DynBuf dbuf;
|
||||
JSValue obj;
|
||||
|
||||
|
||||
if (!f)
|
||||
return JS_EXCEPTION;
|
||||
|
||||
@ -1225,7 +1225,7 @@ static JSValue js_std_file_readAsString(JSContext *ctx, JSValueConst this_val,
|
||||
uint64_t max_size64;
|
||||
size_t max_size;
|
||||
JSValueConst max_size_val;
|
||||
|
||||
|
||||
if (!f)
|
||||
return JS_EXCEPTION;
|
||||
|
||||
@ -1289,7 +1289,7 @@ static int http_get_header_line(FILE *f, char *buf, size_t buf_size,
|
||||
{
|
||||
int c;
|
||||
char *p;
|
||||
|
||||
|
||||
p = buf;
|
||||
for(;;) {
|
||||
c = fgetc(f);
|
||||
@ -1325,21 +1325,21 @@ static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
|
||||
DynBuf cmd_buf;
|
||||
DynBuf data_buf_s, *data_buf = &data_buf_s;
|
||||
DynBuf header_buf_s, *header_buf = &header_buf_s;
|
||||
char *buf;
|
||||
char *buf;
|
||||
size_t i, len;
|
||||
int c, status;
|
||||
JSValue response = JS_UNDEFINED, ret_obj;
|
||||
JSValueConst options_obj;
|
||||
FILE *f;
|
||||
BOOL binary_flag, full_flag;
|
||||
|
||||
|
||||
url = JS_ToCString(ctx, argv[0]);
|
||||
if (!url)
|
||||
return JS_EXCEPTION;
|
||||
|
||||
|
||||
binary_flag = FALSE;
|
||||
full_flag = FALSE;
|
||||
|
||||
|
||||
if (argc >= 2) {
|
||||
options_obj = argv[1];
|
||||
|
||||
@ -1352,7 +1352,7 @@ static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
|
||||
return JS_EXCEPTION;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
js_std_dbuf_init(ctx, &cmd_buf);
|
||||
dbuf_printf(&cmd_buf, "%s ''", URL_GET_PROGRAM);
|
||||
len = strlen(url);
|
||||
@ -1378,7 +1378,7 @@ static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
|
||||
|
||||
js_std_dbuf_init(ctx, data_buf);
|
||||
js_std_dbuf_init(ctx, header_buf);
|
||||
|
||||
|
||||
buf = js_malloc(ctx, URL_GET_BUF_SIZE);
|
||||
if (!buf)
|
||||
goto fail;
|
||||
@ -1392,7 +1392,7 @@ static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
|
||||
if (!full_flag && !(status >= 200 && status <= 299)) {
|
||||
goto bad_header;
|
||||
}
|
||||
|
||||
|
||||
/* wait until there is an empty line */
|
||||
for(;;) {
|
||||
if (http_get_header_line(f, buf, URL_GET_BUF_SIZE, header_buf) < 0) {
|
||||
@ -1468,7 +1468,7 @@ static JSValue js_std_urlGet(JSContext *ctx, JSValueConst this_val,
|
||||
static JSClassDef js_std_file_class = {
|
||||
"FILE",
|
||||
.finalizer = js_std_file_finalizer,
|
||||
};
|
||||
};
|
||||
|
||||
static const JSCFunctionListEntry js_std_error_props[] = {
|
||||
/* various errno values */
|
||||
@ -1500,7 +1500,7 @@ static const JSCFunctionListEntry js_std_funcs[] = {
|
||||
JS_CFUNC_DEF("loadFile", 1, js_std_loadFile ),
|
||||
JS_CFUNC_DEF("strerror", 1, js_std_strerror ),
|
||||
JS_CFUNC_DEF("parseExtJSON", 1, js_std_parseExtJSON ),
|
||||
|
||||
|
||||
/* FILE I/O */
|
||||
JS_CFUNC_DEF("open", 2, js_std_open ),
|
||||
JS_CFUNC_DEF("popen", 2, js_std_popen ),
|
||||
@ -1514,7 +1514,7 @@ static const JSCFunctionListEntry js_std_funcs[] = {
|
||||
JS_PROP_INT32_DEF("SEEK_END", SEEK_END, JS_PROP_CONFIGURABLE ),
|
||||
JS_OBJECT_DEF("Error", js_std_error_props, countof(js_std_error_props), JS_PROP_CONFIGURABLE),
|
||||
};
|
||||
|
||||
|
||||
static const JSCFunctionListEntry js_std_file_proto_funcs[] = {
|
||||
JS_CFUNC_DEF("close", 0, js_std_file_close ),
|
||||
JS_CFUNC_MAGIC_DEF("puts", 1, js_std_file_puts, 1 ),
|
||||
@ -1539,7 +1539,7 @@ static const JSCFunctionListEntry js_std_file_proto_funcs[] = {
|
||||
static int js_std_init(JSContext *ctx, JSModuleDef *m)
|
||||
{
|
||||
JSValue proto;
|
||||
|
||||
|
||||
/* FILE class */
|
||||
/* the class ID is created once */
|
||||
JS_NewClassID(&js_std_file_class_id);
|
||||
@ -1620,7 +1620,7 @@ static JSValue js_os_seek(JSContext *ctx, JSValueConst this_val,
|
||||
int fd, whence;
|
||||
int64_t pos, ret;
|
||||
BOOL is_bigint;
|
||||
|
||||
|
||||
if (JS_ToInt32(ctx, &fd, argv[0]))
|
||||
return JS_EXCEPTION;
|
||||
is_bigint = JS_IsBigInt(ctx, argv[1]);
|
||||
@ -1645,7 +1645,7 @@ static JSValue js_os_read_write(JSContext *ctx, JSValueConst this_val,
|
||||
size_t size;
|
||||
ssize_t ret;
|
||||
uint8_t *buf;
|
||||
|
||||
|
||||
if (JS_ToInt32(ctx, &fd, argv[0]))
|
||||
return JS_EXCEPTION;
|
||||
if (JS_ToIndex(ctx, &pos, argv[2]))
|
||||
@ -1685,7 +1685,7 @@ static JSValue js_os_ttyGetWinSize(JSContext *ctx, JSValueConst this_val,
|
||||
if (JS_ToInt32(ctx, &fd, argv[0]))
|
||||
return JS_EXCEPTION;
|
||||
handle = (HANDLE)_get_osfhandle(fd);
|
||||
|
||||
|
||||
if (!GetConsoleScreenBufferInfo(handle, &info))
|
||||
return JS_NULL;
|
||||
obj = JS_NewArray(ctx);
|
||||
@ -1724,7 +1724,7 @@ static JSValue js_os_ttyGetWinSize(JSContext *ctx, JSValueConst this_val,
|
||||
int fd;
|
||||
struct winsize ws;
|
||||
JSValue obj;
|
||||
|
||||
|
||||
if (JS_ToInt32(ctx, &fd, argv[0]))
|
||||
return JS_EXCEPTION;
|
||||
if (ioctl(fd, TIOCGWINSZ, &ws) == 0 &&
|
||||
@ -1753,10 +1753,10 @@ static JSValue js_os_ttySetRaw(JSContext *ctx, JSValueConst this_val,
|
||||
{
|
||||
struct termios tty;
|
||||
int fd;
|
||||
|
||||
|
||||
if (JS_ToInt32(ctx, &fd, argv[0]))
|
||||
return JS_EXCEPTION;
|
||||
|
||||
|
||||
memset(&tty, 0, sizeof(tty));
|
||||
tcgetattr(fd, &tty);
|
||||
oldtty = tty;
|
||||
@ -1783,7 +1783,7 @@ static JSValue js_os_remove(JSContext *ctx, JSValueConst this_val,
|
||||
{
|
||||
const char *filename;
|
||||
int ret;
|
||||
|
||||
|
||||
filename = JS_ToCString(ctx, argv[0]);
|
||||
if (!filename)
|
||||
return JS_EXCEPTION;
|
||||
@ -1809,7 +1809,7 @@ static JSValue js_os_rename(JSContext *ctx, JSValueConst this_val,
|
||||
{
|
||||
const char *oldpath, *newpath;
|
||||
int ret;
|
||||
|
||||
|
||||
oldpath = JS_ToCString(ctx, argv[0]);
|
||||
if (!oldpath)
|
||||
return JS_EXCEPTION;
|
||||
@ -1861,7 +1861,7 @@ static JSValue js_os_setReadHandler(JSContext *ctx, JSValueConst this_val,
|
||||
JSOSRWHandler *rh;
|
||||
int fd;
|
||||
JSValueConst func;
|
||||
|
||||
|
||||
if (JS_ToInt32(ctx, &fd, argv[0]))
|
||||
return JS_EXCEPTION;
|
||||
func = argv[1];
|
||||
@ -1935,7 +1935,7 @@ static JSValue js_os_signal(JSContext *ctx, JSValueConst this_val,
|
||||
|
||||
if (!is_main_thread(rt))
|
||||
return JS_ThrowTypeError(ctx, "signal handler can only be set in the main thread");
|
||||
|
||||
|
||||
if (JS_ToUint32(ctx, &sig_num, argv[0]))
|
||||
return JS_EXCEPTION;
|
||||
if (sig_num >= 64)
|
||||
@ -2062,7 +2062,7 @@ static JSValue js_os_clearTimeout(JSContext *ctx, JSValueConst this_val,
|
||||
JSThreadState *ts = JS_GetRuntimeOpaque(rt);
|
||||
JSOSTimer *th;
|
||||
int timer_id;
|
||||
|
||||
|
||||
if (JS_ToInt32(ctx, &timer_id, argv[0]))
|
||||
return JS_EXCEPTION;
|
||||
th = find_timer_by_id(ts, timer_id);
|
||||
@ -2127,12 +2127,12 @@ static int js_os_poll(JSContext *ctx)
|
||||
int64_t cur_time, delay;
|
||||
JSOSRWHandler *rh;
|
||||
struct list_head *el;
|
||||
|
||||
|
||||
/* XXX: handle signals if useful */
|
||||
|
||||
if (list_empty(&ts->os_rw_handlers) && list_empty(&ts->os_timers))
|
||||
return -1; /* no more events */
|
||||
|
||||
|
||||
/* XXX: only timers and basic console input are supported */
|
||||
if (!list_empty(&ts->os_timers)) {
|
||||
cur_time = get_time_ms();
|
||||
@ -2205,7 +2205,7 @@ static int handle_posted_message(JSRuntime *rt, JSContext *ctx,
|
||||
struct list_head *el;
|
||||
JSWorkerMessage *msg;
|
||||
JSValue obj, data_obj, func, retval;
|
||||
|
||||
|
||||
pthread_mutex_lock(&ps->mutex);
|
||||
if (!list_empty(&ps->msg_queue)) {
|
||||
el = ps->msg_queue.next;
|
||||
@ -2232,7 +2232,7 @@ static int handle_posted_message(JSRuntime *rt, JSContext *ctx,
|
||||
JS_READ_OBJ_SAB | JS_READ_OBJ_REFERENCE);
|
||||
|
||||
js_free_message(msg);
|
||||
|
||||
|
||||
if (JS_IsException(data_obj))
|
||||
goto fail;
|
||||
obj = JS_NewObject(ctx);
|
||||
@ -2285,7 +2285,7 @@ static int js_os_poll(JSContext *ctx)
|
||||
unlikely(os_pending_signals != 0)) {
|
||||
JSOSSignalHandler *sh;
|
||||
uint64_t mask;
|
||||
|
||||
|
||||
list_for_each(el, &ts->os_signal_handlers) {
|
||||
sh = list_entry(el, JSOSSignalHandler, link);
|
||||
mask = (uint64_t)1 << sh->sig_num;
|
||||
@ -2300,7 +2300,7 @@ static int js_os_poll(JSContext *ctx)
|
||||
if (list_empty(&ts->os_rw_handlers) && list_empty(&ts->os_timers) &&
|
||||
list_empty(&ts->port_list))
|
||||
return -1; /* no more events */
|
||||
|
||||
|
||||
if (!list_empty(&ts->os_timers)) {
|
||||
cur_time = get_time_ms();
|
||||
min_delay = 10000;
|
||||
@ -2326,7 +2326,7 @@ static int js_os_poll(JSContext *ctx)
|
||||
} else {
|
||||
tvp = NULL;
|
||||
}
|
||||
|
||||
|
||||
FD_ZERO(&rfds);
|
||||
FD_ZERO(&wfds);
|
||||
fd_max = -1;
|
||||
@ -2412,7 +2412,7 @@ static JSValue js_os_getcwd(JSContext *ctx, JSValueConst this_val,
|
||||
{
|
||||
char buf[PATH_MAX];
|
||||
int err;
|
||||
|
||||
|
||||
if (!getcwd(buf, sizeof(buf))) {
|
||||
buf[0] = '\0';
|
||||
err = errno;
|
||||
@ -2441,7 +2441,7 @@ static JSValue js_os_mkdir(JSContext *ctx, JSValueConst this_val,
|
||||
{
|
||||
int mode, ret;
|
||||
const char *path;
|
||||
|
||||
|
||||
if (argc >= 2) {
|
||||
if (JS_ToInt32(ctx, &mode, argv[1]))
|
||||
return JS_EXCEPTION;
|
||||
@ -2471,7 +2471,7 @@ static JSValue js_os_readdir(JSContext *ctx, JSValueConst this_val,
|
||||
JSValue obj;
|
||||
int err;
|
||||
uint32_t len;
|
||||
|
||||
|
||||
path = JS_ToCString(ctx, argv[0]);
|
||||
if (!path)
|
||||
return JS_EXCEPTION;
|
||||
@ -2619,7 +2619,7 @@ static JSValue js_os_utimes(JSContext *ctx, JSValueConst this_val,
|
||||
const char *path;
|
||||
int64_t atime, mtime;
|
||||
int ret;
|
||||
|
||||
|
||||
if (JS_ToInt64(ctx, &atime, argv[1]))
|
||||
return JS_EXCEPTION;
|
||||
if (JS_ToInt64(ctx, &mtime, argv[2]))
|
||||
@ -2652,7 +2652,7 @@ static JSValue js_os_sleep(JSContext *ctx, JSValueConst this_val,
|
||||
{
|
||||
int64_t delay;
|
||||
int ret;
|
||||
|
||||
|
||||
if (JS_ToInt64(ctx, &delay, argv[0]))
|
||||
return JS_EXCEPTION;
|
||||
if (delay < 0)
|
||||
@ -2716,7 +2716,7 @@ static JSValue js_os_symlink(JSContext *ctx, JSValueConst this_val,
|
||||
{
|
||||
const char *target, *linkpath;
|
||||
int err;
|
||||
|
||||
|
||||
target = JS_ToCString(ctx, argv[0]);
|
||||
if (!target)
|
||||
return JS_EXCEPTION;
|
||||
@ -2739,7 +2739,7 @@ static JSValue js_os_readlink(JSContext *ctx, JSValueConst this_val,
|
||||
char buf[PATH_MAX];
|
||||
int err;
|
||||
ssize_t res;
|
||||
|
||||
|
||||
path = JS_ToCString(ctx, argv[0]);
|
||||
if (!path)
|
||||
return JS_EXCEPTION;
|
||||
@ -2763,7 +2763,7 @@ static char **build_envp(JSContext *ctx, JSValueConst obj)
|
||||
const char *key, *str;
|
||||
JSValue val;
|
||||
size_t key_len, str_len;
|
||||
|
||||
|
||||
if (JS_GetOwnPropertyNames(ctx, &tab, &len, obj,
|
||||
JS_GPN_STRING_MASK | JS_GPN_ENUM_ONLY) < 0)
|
||||
return NULL;
|
||||
@ -2821,7 +2821,7 @@ static int my_execvpe(const char *filename, char **argv, char **envp)
|
||||
char buf[PATH_MAX];
|
||||
size_t filename_len, path_len;
|
||||
BOOL eacces_error;
|
||||
|
||||
|
||||
filename_len = strlen(filename);
|
||||
if (filename_len == 0) {
|
||||
errno = ENOENT;
|
||||
@ -2829,7 +2829,7 @@ static int my_execvpe(const char *filename, char **argv, char **envp)
|
||||
}
|
||||
if (strchr(filename, '/'))
|
||||
return execve(filename, argv, envp);
|
||||
|
||||
|
||||
path = getenv("PATH");
|
||||
if (!path)
|
||||
path = (char *)"/bin:/usr/bin";
|
||||
@ -2851,7 +2851,7 @@ static int my_execvpe(const char *filename, char **argv, char **envp)
|
||||
buf[path_len] = '/';
|
||||
memcpy(buf + path_len + 1, filename, filename_len);
|
||||
buf[path_len + 1 + filename_len] = '\0';
|
||||
|
||||
|
||||
execve(buf, argv, envp);
|
||||
|
||||
switch(errno) {
|
||||
@ -2884,7 +2884,7 @@ static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
|
||||
static const char *std_name[3] = { "stdin", "stdout", "stderr" };
|
||||
int std_fds[3];
|
||||
uint32_t uid = -1, gid = -1;
|
||||
|
||||
|
||||
val = JS_GetPropertyStr(ctx, args, "length");
|
||||
if (JS_IsException(val))
|
||||
return JS_EXCEPTION;
|
||||
@ -2913,7 +2913,7 @@ static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
|
||||
|
||||
for(i = 0; i < 3; i++)
|
||||
std_fds[i] = i;
|
||||
|
||||
|
||||
/* get the options, if any */
|
||||
if (argc >= 2) {
|
||||
options = argv[1];
|
||||
@ -2922,7 +2922,7 @@ static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
|
||||
goto exception;
|
||||
if (get_bool_option(ctx, &use_path, options, "usePath"))
|
||||
goto exception;
|
||||
|
||||
|
||||
val = JS_GetPropertyStr(ctx, options, "file");
|
||||
if (JS_IsException(val))
|
||||
goto exception;
|
||||
@ -2967,7 +2967,7 @@ static JSValue js_os_exec(JSContext *ctx, JSValueConst this_val,
|
||||
if (!envp)
|
||||
goto exception;
|
||||
}
|
||||
|
||||
|
||||
val = JS_GetPropertyStr(ctx, options, "uid");
|
||||
if (JS_IsException(val))
|
||||
goto exception;
|
||||
@ -3081,7 +3081,7 @@ static JSValue js_os_waitpid(JSContext *ctx, JSValueConst this_val,
|
||||
{
|
||||
int pid, status, options, ret;
|
||||
JSValue obj;
|
||||
|
||||
|
||||
if (JS_ToInt32(ctx, &pid, argv[0]))
|
||||
return JS_EXCEPTION;
|
||||
if (JS_ToInt32(ctx, &options, argv[1]))
|
||||
@ -3101,7 +3101,7 @@ static JSValue js_os_waitpid(JSContext *ctx, JSValueConst this_val,
|
||||
JS_DefinePropertyValueUint32(ctx, obj, 1, JS_NewInt32(ctx, status),
|
||||
JS_PROP_C_W_E);
|
||||
return obj;
|
||||
}
|
||||
}
|
||||
|
||||
/* pipe() -> [read_fd, write_fd] or null if error */
|
||||
static JSValue js_os_pipe(JSContext *ctx, JSValueConst this_val,
|
||||
@ -3109,7 +3109,7 @@ static JSValue js_os_pipe(JSContext *ctx, JSValueConst this_val,
|
||||
{
|
||||
int pipe_fds[2], ret;
|
||||
JSValue obj;
|
||||
|
||||
|
||||
ret = pipe(pipe_fds);
|
||||
if (ret < 0)
|
||||
return JS_NULL;
|
||||
@ -3128,7 +3128,7 @@ static JSValue js_os_kill(JSContext *ctx, JSValueConst this_val,
|
||||
int argc, JSValueConst *argv)
|
||||
{
|
||||
int pid, sig, ret;
|
||||
|
||||
|
||||
if (JS_ToInt32(ctx, &pid, argv[0]))
|
||||
return JS_EXCEPTION;
|
||||
if (JS_ToInt32(ctx, &sig, argv[1]))
|
||||
@ -3142,7 +3142,7 @@ static JSValue js_os_dup(JSContext *ctx, JSValueConst this_val,
|
||||
int argc, JSValueConst *argv)
|
||||
{
|
||||
int fd, ret;
|
||||
|
||||
|
||||
if (JS_ToInt32(ctx, &fd, argv[0]))
|
||||
return JS_EXCEPTION;
|
||||
ret = js_get_errno(dup(fd));
|
||||
@ -3154,7 +3154,7 @@ static JSValue js_os_dup2(JSContext *ctx, JSValueConst this_val,
|
||||
int argc, JSValueConst *argv)
|
||||
{
|
||||
int fd, fd2, ret;
|
||||
|
||||
|
||||
if (JS_ToInt32(ctx, &fd, argv[0]))
|
||||
return JS_EXCEPTION;
|
||||
if (JS_ToInt32(ctx, &fd2, argv[1]))
|
||||
@ -3228,7 +3228,7 @@ static JSWorkerMessagePipe *js_new_message_pipe(void)
|
||||
{
|
||||
JSWorkerMessagePipe *ps;
|
||||
int pipe_fds[2];
|
||||
|
||||
|
||||
if (pipe(pipe_fds) < 0)
|
||||
return NULL;
|
||||
|
||||
@ -3269,10 +3269,10 @@ static void js_free_message_pipe(JSWorkerMessagePipe *ps)
|
||||
struct list_head *el, *el1;
|
||||
JSWorkerMessage *msg;
|
||||
int ref_count;
|
||||
|
||||
|
||||
if (!ps)
|
||||
return;
|
||||
|
||||
|
||||
ref_count = atomic_add_int(&ps->ref_count, -1);
|
||||
assert(ref_count >= 0);
|
||||
if (ref_count == 0) {
|
||||
@ -3311,7 +3311,7 @@ static void js_worker_finalizer(JSRuntime *rt, JSValue val)
|
||||
static JSClassDef js_worker_class = {
|
||||
"Worker",
|
||||
.finalizer = js_worker_finalizer,
|
||||
};
|
||||
};
|
||||
|
||||
static void *worker_func(void *opaque)
|
||||
{
|
||||
@ -3320,12 +3320,12 @@ static void *worker_func(void *opaque)
|
||||
JSThreadState *ts;
|
||||
JSContext *ctx;
|
||||
JSValue val;
|
||||
|
||||
|
||||
rt = JS_NewRuntime();
|
||||
if (rt == NULL) {
|
||||
fprintf(stderr, "JS_NewRuntime failure");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
js_std_init_handlers(rt);
|
||||
|
||||
JS_SetModuleLoaderFunc(rt, NULL, js_module_loader, NULL);
|
||||
@ -3334,7 +3334,7 @@ static void *worker_func(void *opaque)
|
||||
ts = JS_GetRuntimeOpaque(rt);
|
||||
ts->recv_pipe = args->recv_pipe;
|
||||
ts->send_pipe = args->send_pipe;
|
||||
|
||||
|
||||
/* function pointer to avoid linking the whole JS_NewContext() if
|
||||
not needed */
|
||||
ctx = js_worker_new_context_func(rt);
|
||||
@ -3369,7 +3369,7 @@ static JSValue js_worker_ctor_internal(JSContext *ctx, JSValueConst new_target,
|
||||
{
|
||||
JSValue obj = JS_UNDEFINED, proto;
|
||||
JSWorkerData *s;
|
||||
|
||||
|
||||
/* create the object */
|
||||
if (JS_IsUndefined(new_target)) {
|
||||
proto = JS_GetClassProto(ctx, js_worker_class_id);
|
||||
@ -3406,7 +3406,7 @@ static JSValue js_worker_ctor(JSContext *ctx, JSValueConst new_target,
|
||||
int ret;
|
||||
const char *filename = NULL, *basename;
|
||||
JSAtom basename_atom;
|
||||
|
||||
|
||||
/* XXX: in order to avoid problems with resource liberation, we
|
||||
don't support creating workers inside workers */
|
||||
if (!is_main_thread(rt))
|
||||
@ -3422,7 +3422,7 @@ static JSValue js_worker_ctor(JSContext *ctx, JSValueConst new_target,
|
||||
JS_FreeAtom(ctx, basename_atom);
|
||||
if (!basename)
|
||||
goto fail;
|
||||
|
||||
|
||||
/* module name */
|
||||
filename = JS_ToCString(ctx, argv[0]);
|
||||
if (!filename)
|
||||
@ -3447,7 +3447,7 @@ static JSValue js_worker_ctor(JSContext *ctx, JSValueConst new_target,
|
||||
args->send_pipe, args->recv_pipe);
|
||||
if (JS_IsException(obj))
|
||||
goto fail;
|
||||
|
||||
|
||||
pthread_attr_init(&attr);
|
||||
/* no join at the end */
|
||||
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
|
||||
@ -3485,10 +3485,10 @@ static JSValue js_worker_postMessage(JSContext *ctx, JSValueConst this_val,
|
||||
uint8_t *data;
|
||||
JSWorkerMessage *msg;
|
||||
uint8_t **sab_tab;
|
||||
|
||||
|
||||
if (!worker)
|
||||
return JS_EXCEPTION;
|
||||
|
||||
|
||||
data = JS_WriteObject2(ctx, &data_len, argv[0],
|
||||
JS_WRITE_OBJ_SAB | JS_WRITE_OBJ_REFERENCE,
|
||||
&sab_tab, &sab_tab_len);
|
||||
@ -3516,7 +3516,7 @@ static JSValue js_worker_postMessage(JSContext *ctx, JSValueConst this_val,
|
||||
|
||||
js_free(ctx, data);
|
||||
js_free(ctx, sab_tab);
|
||||
|
||||
|
||||
/* increment the SAB reference counts */
|
||||
for(i = 0; i < msg->sab_tab_len; i++) {
|
||||
js_sab_dup(NULL, msg->sab_tab[i]);
|
||||
@ -3548,7 +3548,7 @@ static JSValue js_worker_postMessage(JSContext *ctx, JSValueConst this_val,
|
||||
js_free(ctx, data);
|
||||
js_free(ctx, sab_tab);
|
||||
return JS_EXCEPTION;
|
||||
|
||||
|
||||
}
|
||||
|
||||
static JSValue js_worker_set_onmessage(JSContext *ctx, JSValueConst this_val,
|
||||
@ -3558,7 +3558,7 @@ static JSValue js_worker_set_onmessage(JSContext *ctx, JSValueConst this_val,
|
||||
JSThreadState *ts = JS_GetRuntimeOpaque(rt);
|
||||
JSWorkerData *worker = JS_GetOpaque2(ctx, this_val, js_worker_class_id);
|
||||
JSWorkerMessageHandler *port;
|
||||
|
||||
|
||||
if (!worker)
|
||||
return JS_EXCEPTION;
|
||||
|
||||
@ -3714,7 +3714,7 @@ static const JSCFunctionListEntry js_os_funcs[] = {
|
||||
static int js_os_init(JSContext *ctx, JSModuleDef *m)
|
||||
{
|
||||
os_poll_func = js_os_poll;
|
||||
|
||||
|
||||
#ifdef USE_WORKER
|
||||
{
|
||||
JSRuntime *rt = JS_GetRuntime(ctx);
|
||||
@ -3725,20 +3725,20 @@ static int js_os_init(JSContext *ctx, JSModuleDef *m)
|
||||
JS_NewClass(JS_GetRuntime(ctx), js_worker_class_id, &js_worker_class);
|
||||
proto = JS_NewObject(ctx);
|
||||
JS_SetPropertyFunctionList(ctx, proto, js_worker_proto_funcs, countof(js_worker_proto_funcs));
|
||||
|
||||
|
||||
obj = JS_NewCFunction2(ctx, js_worker_ctor, "Worker", 1,
|
||||
JS_CFUNC_constructor, 0);
|
||||
JS_SetConstructor(ctx, obj, proto);
|
||||
|
||||
|
||||
JS_SetClassProto(ctx, js_worker_class_id, proto);
|
||||
|
||||
|
||||
/* set 'Worker.parent' if necessary */
|
||||
if (ts->recv_pipe && ts->send_pipe) {
|
||||
JS_DefinePropertyValueStr(ctx, obj, "parent",
|
||||
js_worker_ctor_internal(ctx, JS_UNDEFINED, ts->recv_pipe, ts->send_pipe),
|
||||
JS_PROP_C_W_E);
|
||||
}
|
||||
|
||||
|
||||
JS_SetModuleExport(ctx, m, "Worker", obj);
|
||||
}
|
||||
#endif /* USE_WORKER */
|
||||
@ -3803,12 +3803,12 @@ void js_std_add_helpers(JSContext *ctx, int argc, char **argv)
|
||||
}
|
||||
JS_SetPropertyStr(ctx, global_obj, "scriptArgs", args);
|
||||
}
|
||||
|
||||
|
||||
JS_SetPropertyStr(ctx, global_obj, "print",
|
||||
JS_NewCFunction(ctx, js_print, "print", 1));
|
||||
JS_SetPropertyStr(ctx, global_obj, "__loadScript",
|
||||
JS_NewCFunction(ctx, js_loadScript, "__loadScript", 1));
|
||||
|
||||
|
||||
JS_FreeValue(ctx, global_obj);
|
||||
}
|
||||
|
||||
@ -3827,7 +3827,7 @@ void js_std_init_handlers(JSRuntime *rt)
|
||||
init_list_head(&ts->os_timers);
|
||||
init_list_head(&ts->port_list);
|
||||
ts->next_timer_id = 1;
|
||||
|
||||
|
||||
JS_SetRuntimeOpaque(rt, ts);
|
||||
|
||||
#ifdef USE_WORKER
|
||||
@ -3857,7 +3857,7 @@ void js_std_free_handlers(JSRuntime *rt)
|
||||
JSOSSignalHandler *sh = list_entry(el, JSOSSignalHandler, link);
|
||||
free_sh(rt, sh);
|
||||
}
|
||||
|
||||
|
||||
list_for_each_safe(el, el1, &ts->os_timers) {
|
||||
JSOSTimer *th = list_entry(el, JSOSTimer, link);
|
||||
free_timer(rt, th);
|
||||
@ -3876,7 +3876,7 @@ void js_std_free_handlers(JSRuntime *rt)
|
||||
static void js_dump_obj(JSContext *ctx, FILE *f, JSValueConst val)
|
||||
{
|
||||
const char *str;
|
||||
|
||||
|
||||
str = JS_ToCString(ctx, val);
|
||||
if (str) {
|
||||
fprintf(f, "%s\n", str);
|
||||
@ -3890,7 +3890,7 @@ static void js_std_dump_error1(JSContext *ctx, JSValueConst exception_val)
|
||||
{
|
||||
JSValue val;
|
||||
BOOL is_error;
|
||||
|
||||
|
||||
is_error = JS_IsError(ctx, exception_val);
|
||||
js_dump_obj(ctx, stderr, exception_val);
|
||||
if (is_error) {
|
||||
@ -3905,7 +3905,7 @@ static void js_std_dump_error1(JSContext *ctx, JSValueConst exception_val)
|
||||
void js_std_dump_error(JSContext *ctx)
|
||||
{
|
||||
JSValue exception_val;
|
||||
|
||||
|
||||
exception_val = JS_GetException(ctx);
|
||||
js_std_dump_error1(ctx, exception_val);
|
||||
JS_FreeValue(ctx, exception_val);
|
||||
|
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* QuickJS C library
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017-2018 Fabrice Bellard
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
@ -52,7 +52,7 @@ void js_std_promise_rejection_tracker(JSContext *ctx, JSValueConst promise,
|
||||
JSValueConst reason,
|
||||
JS_BOOL is_handled, void *opaque);
|
||||
void js_std_set_worker_new_context_func(JSContext *(*func)(JSRuntime *rt));
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
} /* extern "C" { */
|
||||
#endif
|
||||
|
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* QuickJS opcode definitions
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017-2018 Fabrice Bellard
|
||||
* Copyright (c) 2017-2018 Charlie Gordon
|
||||
*
|
||||
@ -165,7 +165,7 @@ DEF( set_loc, 3, 1, 1, loc) /* must come after put_loc */
|
||||
DEF( get_arg, 3, 0, 1, arg)
|
||||
DEF( put_arg, 3, 1, 0, arg) /* must come after get_arg */
|
||||
DEF( set_arg, 3, 1, 1, arg) /* must come after put_arg */
|
||||
DEF( get_var_ref, 3, 0, 1, var_ref)
|
||||
DEF( get_var_ref, 3, 0, 1, var_ref)
|
||||
DEF( put_var_ref, 3, 1, 0, var_ref) /* must come after get_var_ref */
|
||||
DEF( set_var_ref, 3, 1, 1, var_ref) /* must come after put_var_ref */
|
||||
DEF(set_loc_uninitialized, 3, 0, 0, loc)
|
||||
@ -173,7 +173,7 @@ DEF( get_loc_check, 3, 0, 1, loc)
|
||||
DEF( put_loc_check, 3, 1, 0, loc) /* must come after get_loc_check */
|
||||
DEF( put_loc_check_init, 3, 1, 0, loc)
|
||||
DEF(get_loc_checkthis, 3, 0, 1, loc)
|
||||
DEF(get_var_ref_check, 3, 0, 1, var_ref)
|
||||
DEF(get_var_ref_check, 3, 0, 1, var_ref)
|
||||
DEF(put_var_ref_check, 3, 1, 0, var_ref) /* must come after get_var_ref_check */
|
||||
DEF(put_var_ref_check_init, 3, 1, 0, var_ref)
|
||||
DEF( close_loc, 3, 0, 0, loc)
|
||||
@ -263,7 +263,7 @@ DEF( mul_pow10, 1, 2, 1, none)
|
||||
DEF( math_mod, 1, 2, 1, none)
|
||||
#endif
|
||||
/* must be the last non short and non temporary opcode */
|
||||
DEF( nop, 1, 0, 0, none)
|
||||
DEF( nop, 1, 0, 0, none)
|
||||
|
||||
/* temporary opcodes: never emitted in the final bytecode */
|
||||
|
||||
@ -289,7 +289,7 @@ def(scope_in_private_field, 7, 1, 1, atom_u16) /* obj -> res emitted in phase 1,
|
||||
def(get_field_opt_chain, 5, 1, 1, atom) /* emitted in phase 1, removed in phase 2 */
|
||||
def(get_array_el_opt_chain, 1, 2, 1, none) /* emitted in phase 1, removed in phase 2 */
|
||||
def( set_class_name, 5, 1, 1, u32) /* emitted in phase 1, removed in phase 2 */
|
||||
|
||||
|
||||
def( line_num, 5, 0, 0, u32) /* emitted in phase 1, removed in phase 3 */
|
||||
|
||||
#if SHORT_OPCODES
|
||||
|
@ -126,7 +126,7 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
#elif defined(JS_NAN_BOXING)
|
||||
|
||||
typedef uint64_t JSValue;
|
||||
@ -191,7 +191,7 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
|
||||
tag = JS_VALUE_GET_TAG(v);
|
||||
return tag == (JS_NAN >> 32);
|
||||
}
|
||||
|
||||
|
||||
#else /* !JS_NAN_BOXING */
|
||||
|
||||
typedef union JSValueUnion {
|
||||
@ -309,7 +309,7 @@ static inline JS_BOOL JS_VALUE_IS_NAN(JSValue v)
|
||||
#define JS_EVAL_FLAG_BACKTRACE_BARRIER (1 << 6)
|
||||
/* allow top-level await in normal script. JS_Eval() returns a
|
||||
promise. Only allowed with JS_EVAL_TYPE_GLOBAL */
|
||||
#define JS_EVAL_FLAG_ASYNC (1 << 7)
|
||||
#define JS_EVAL_FLAG_ASYNC (1 << 7)
|
||||
|
||||
typedef JSValue JSCFunction(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv);
|
||||
typedef JSValue JSCFunctionMagic(JSContext *ctx, JSValueConst this_val, int argc, JSValueConst *argv, int magic);
|
||||
@ -969,7 +969,7 @@ static inline JSValue JS_NewCFunctionMagic(JSContext *ctx, JSCFunctionMagic *fun
|
||||
{
|
||||
return JS_NewCFunction2(ctx, (JSCFunction *)func, name, length, cproto, magic);
|
||||
}
|
||||
void JS_SetConstructor(JSContext *ctx, JSValueConst func_obj,
|
||||
void JS_SetConstructor(JSContext *ctx, JSValueConst func_obj,
|
||||
JSValueConst proto);
|
||||
|
||||
/* C property definition */
|
||||
|
@ -9,7 +9,7 @@ if [ "$1" = "-h" ] ; then
|
||||
echo "release.sh [release_list]"
|
||||
echo ""
|
||||
echo "release_list: extras binary win_binary quickjs"
|
||||
|
||||
|
||||
exit 1
|
||||
fi
|
||||
|
||||
@ -29,7 +29,7 @@ name="quickjs-extras-${version}"
|
||||
outdir="/tmp/${d}"
|
||||
|
||||
rm -rf $outdir
|
||||
mkdir -p $outdir $outdir/unicode $outdir/tests
|
||||
mkdir -p $outdir $outdir/unicode $outdir/tests
|
||||
|
||||
cp unicode/* $outdir/unicode
|
||||
cp -a tests/bench-v8 $outdir/tests
|
||||
@ -83,7 +83,7 @@ cp $dlldir/libwinpthread-1.dll $outdir
|
||||
( cd /tmp/$d && rm -f ../${d}.zip && zip -r ../${d}.zip . )
|
||||
|
||||
fi
|
||||
|
||||
|
||||
#################################################"
|
||||
# Linux binary release
|
||||
|
||||
@ -151,7 +151,7 @@ cp examples/*.js examples/*.c $outdir/examples
|
||||
|
||||
cp doc/quickjs.texi doc/quickjs.pdf doc/quickjs.html \
|
||||
doc/jsbignum.texi doc/jsbignum.html doc/jsbignum.pdf \
|
||||
$outdir/doc
|
||||
$outdir/doc
|
||||
|
||||
( cd /tmp && tar Jcvf /tmp/${d}.tar.xz ${d} )
|
||||
|
||||
|
64
repl.js
64
repl.js
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* QuickJS Read Eval Print Loop
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017-2020 Fabrice Bellard
|
||||
* Copyright (c) 2017-2020 Charlie Gordon
|
||||
*
|
||||
@ -31,7 +31,7 @@ import * as os from "os";
|
||||
/* add 'os' and 'std' bindings */
|
||||
g.os = os;
|
||||
g.std = std;
|
||||
|
||||
|
||||
/* close global objects */
|
||||
var Object = g.Object;
|
||||
var String = g.String;
|
||||
@ -45,7 +45,7 @@ import * as os from "os";
|
||||
var config_numcalc = (typeof os.open === "undefined");
|
||||
var has_jscalc = (typeof Fraction === "function");
|
||||
var has_bignum = (typeof BigFloat === "function");
|
||||
|
||||
|
||||
var colors = {
|
||||
none: "\x1b[0m",
|
||||
black: "\x1b[30m",
|
||||
@ -105,7 +105,7 @@ import * as os from "os";
|
||||
var prec;
|
||||
var expBits;
|
||||
var log2_10;
|
||||
|
||||
|
||||
var pstate = "";
|
||||
var prompt = "";
|
||||
var plen = 0;
|
||||
@ -120,7 +120,7 @@ import * as os from "os";
|
||||
var show_colors = true;
|
||||
var eval_start_time;
|
||||
var eval_time = 0;
|
||||
|
||||
|
||||
var mexpr = "";
|
||||
var level = 0;
|
||||
var cmd = "";
|
||||
@ -138,12 +138,12 @@ import * as os from "os";
|
||||
var term_read_buf;
|
||||
var term_width;
|
||||
/* current X position of the cursor in the terminal */
|
||||
var term_cursor_x = 0;
|
||||
|
||||
var term_cursor_x = 0;
|
||||
|
||||
function termInit() {
|
||||
var tab;
|
||||
term_fd = std.in.fileno();
|
||||
|
||||
|
||||
/* get the terminal size */
|
||||
term_width = 80;
|
||||
if (os.isatty(term_fd)) {
|
||||
@ -170,14 +170,14 @@ import * as os from "os";
|
||||
/* send Ctrl-C to readline */
|
||||
handle_byte(3);
|
||||
}
|
||||
|
||||
|
||||
function term_read_handler() {
|
||||
var l, i;
|
||||
l = os.read(term_fd, term_read_buf.buffer, 0, term_read_buf.length);
|
||||
for(i = 0; i < l; i++)
|
||||
handle_byte(term_read_buf[i]);
|
||||
}
|
||||
|
||||
|
||||
function handle_byte(c) {
|
||||
if (!utf8) {
|
||||
handle_char(c);
|
||||
@ -195,12 +195,12 @@ import * as os from "os";
|
||||
handle_char(c);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
function is_alpha(c) {
|
||||
return typeof c === "string" &&
|
||||
((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z'));
|
||||
}
|
||||
|
||||
|
||||
function is_digit(c) {
|
||||
return typeof c === "string" && (c >= '0' && c <= '9');
|
||||
}
|
||||
@ -232,7 +232,7 @@ import * as os from "os";
|
||||
d = c.codePointAt(0); /* can be NaN if empty string */
|
||||
return d >= 0xdc00 && d < 0xe000;
|
||||
}
|
||||
|
||||
|
||||
function is_balanced(a, b) {
|
||||
switch (a + b) {
|
||||
case "()":
|
||||
@ -271,7 +271,7 @@ import * as os from "os";
|
||||
} else {
|
||||
l = Math.min(term_width - 1 - term_cursor_x, delta);
|
||||
print_csi(l, "C"); /* right */
|
||||
delta -= l;
|
||||
delta -= l;
|
||||
term_cursor_x += l;
|
||||
}
|
||||
}
|
||||
@ -399,7 +399,7 @@ import * as os from "os";
|
||||
|
||||
function backward_word() {
|
||||
cursor_pos = skip_word_backward(cursor_pos);
|
||||
}
|
||||
}
|
||||
|
||||
function accept_line() {
|
||||
std.puts("\n");
|
||||
@ -577,7 +577,7 @@ import * as os from "os";
|
||||
readline_print_prompt();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
function reset() {
|
||||
cmd = "";
|
||||
cursor_pos = 0;
|
||||
@ -731,7 +731,7 @@ import * as os from "os";
|
||||
readline_print_prompt();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
var commands = { /* command table */
|
||||
"\x01": beginning_of_line, /* ^A - bol */
|
||||
"\x02": backward_char, /* ^B - backward-char */
|
||||
@ -807,9 +807,9 @@ import * as os from "os";
|
||||
cursor_pos = cmd.length;
|
||||
history_index = history.length;
|
||||
readline_cb = cb;
|
||||
|
||||
|
||||
prompt = pstate;
|
||||
|
||||
|
||||
if (mexpr) {
|
||||
prompt += dupstr(" ", plen - prompt.length);
|
||||
prompt += ps2;
|
||||
@ -894,7 +894,7 @@ import * as os from "os";
|
||||
} else {
|
||||
alert(); /* beep! */
|
||||
}
|
||||
|
||||
|
||||
cursor_pos = (cursor_pos < 0) ? 0 :
|
||||
(cursor_pos > cmd.length) ? cmd.length : cursor_pos;
|
||||
update();
|
||||
@ -992,13 +992,13 @@ import * as os from "os";
|
||||
s += "n";
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
function print(a) {
|
||||
var stack = [];
|
||||
|
||||
function print_rec(a) {
|
||||
var n, i, keys, key, type, s;
|
||||
|
||||
|
||||
type = typeof(a);
|
||||
if (type === "object") {
|
||||
if (a === null) {
|
||||
@ -1072,7 +1072,7 @@ import * as os from "os";
|
||||
}
|
||||
print_rec(a);
|
||||
}
|
||||
|
||||
|
||||
function extract_directive(a) {
|
||||
var pos;
|
||||
if (a[0] !== '\\')
|
||||
@ -1087,7 +1087,7 @@ import * as os from "os";
|
||||
/* return true if the string after cmd can be evaluted as JS */
|
||||
function handle_directive(cmd, expr) {
|
||||
var param, prec1, expBits1;
|
||||
|
||||
|
||||
if (cmd === "h" || cmd === "?" || cmd == "help") {
|
||||
help();
|
||||
} else if (cmd === "load") {
|
||||
@ -1197,7 +1197,7 @@ import * as os from "os";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
function help() {
|
||||
function sel(n) {
|
||||
return n ? "*": " ";
|
||||
@ -1247,7 +1247,7 @@ import * as os from "os";
|
||||
function cmd_readline_start() {
|
||||
readline_start(dupstr(" ", level), readline_handle_cmd);
|
||||
}
|
||||
|
||||
|
||||
function readline_handle_cmd(expr) {
|
||||
if (!handle_cmd(expr)) {
|
||||
cmd_readline_start();
|
||||
@ -1257,7 +1257,7 @@ import * as os from "os";
|
||||
/* return true if async termination */
|
||||
function handle_cmd(expr) {
|
||||
var colorstate, cmd;
|
||||
|
||||
|
||||
if (expr === null) {
|
||||
expr = "";
|
||||
return false;
|
||||
@ -1275,7 +1275,7 @@ import * as os from "os";
|
||||
}
|
||||
if (expr === "")
|
||||
return false;
|
||||
|
||||
|
||||
if (mexpr)
|
||||
expr = mexpr + '\n' + expr;
|
||||
colorstate = colorize_js(expr);
|
||||
@ -1286,7 +1286,7 @@ import * as os from "os";
|
||||
return false;
|
||||
}
|
||||
mexpr = "";
|
||||
|
||||
|
||||
if (has_bignum) {
|
||||
/* XXX: async is not supported in this case */
|
||||
BigFloatEnv.setPrec(eval_and_print_start.bind(null, expr, false),
|
||||
@ -1299,7 +1299,7 @@ import * as os from "os";
|
||||
|
||||
function eval_and_print_start(expr, is_async) {
|
||||
var result;
|
||||
|
||||
|
||||
try {
|
||||
if (eval_mode === "math")
|
||||
expr = '"use math"; void 0;' + expr;
|
||||
@ -1342,7 +1342,7 @@ import * as os from "os";
|
||||
console.log(error);
|
||||
}
|
||||
std.puts(colors.none);
|
||||
|
||||
|
||||
handle_cmd_end();
|
||||
}
|
||||
|
||||
@ -1585,7 +1585,7 @@ import * as os from "os";
|
||||
}
|
||||
|
||||
termInit();
|
||||
|
||||
|
||||
cmd_start();
|
||||
|
||||
})(globalThis);
|
||||
|
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* ECMA Test 262 Runner for QuickJS
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017-2021 Fabrice Bellard
|
||||
* Copyright (c) 2017-2021 Charlie Gordon
|
||||
*
|
||||
@ -321,7 +321,7 @@ void namelist_load(namelist_t *lp, const char *filename)
|
||||
char *p = str_strip(buf);
|
||||
if (*p == '#' || *p == ';' || *p == '\0')
|
||||
continue; /* line comment */
|
||||
|
||||
|
||||
namelist_add(lp, base_name, p);
|
||||
}
|
||||
free(base_name);
|
||||
@ -457,11 +457,11 @@ static void *agent_start(void *arg)
|
||||
JSContext *ctx;
|
||||
JSValue ret_val;
|
||||
int ret;
|
||||
|
||||
|
||||
rt = JS_NewRuntime();
|
||||
if (rt == NULL) {
|
||||
fatal(1, "JS_NewRuntime failure");
|
||||
}
|
||||
}
|
||||
ctx = JS_NewContext(rt);
|
||||
if (ctx == NULL) {
|
||||
JS_FreeRuntime(rt);
|
||||
@ -470,7 +470,7 @@ static void *agent_start(void *arg)
|
||||
JS_SetContextOpaque(ctx, agent);
|
||||
JS_SetRuntimeInfo(rt, "agent");
|
||||
JS_SetCanBlock(rt, TRUE);
|
||||
|
||||
|
||||
add_helpers(ctx);
|
||||
ret_val = JS_Eval(ctx, agent->script, strlen(agent->script),
|
||||
"<evalScript>", JS_EVAL_TYPE_GLOBAL);
|
||||
@ -479,7 +479,7 @@ static void *agent_start(void *arg)
|
||||
if (JS_IsException(ret_val))
|
||||
js_std_dump_error(ctx);
|
||||
JS_FreeValue(ctx, ret_val);
|
||||
|
||||
|
||||
for(;;) {
|
||||
JSContext *ctx1;
|
||||
ret = JS_ExecutePendingJob(JS_GetRuntime(ctx), &ctx1);
|
||||
@ -491,12 +491,12 @@ static void *agent_start(void *arg)
|
||||
break;
|
||||
} else {
|
||||
JSValue args[2];
|
||||
|
||||
|
||||
pthread_mutex_lock(&agent_mutex);
|
||||
while (!agent->broadcast_pending) {
|
||||
pthread_cond_wait(&agent_cond, &agent_mutex);
|
||||
}
|
||||
|
||||
|
||||
agent->broadcast_pending = FALSE;
|
||||
pthread_cond_signal(&agent_cond);
|
||||
|
||||
@ -533,7 +533,7 @@ static JSValue js_agent_start(JSContext *ctx, JSValue this_val,
|
||||
|
||||
if (JS_GetContextOpaque(ctx) != NULL)
|
||||
return JS_ThrowTypeError(ctx, "cannot be called inside an agent");
|
||||
|
||||
|
||||
script = JS_ToCString(ctx, argv[0]);
|
||||
if (!script)
|
||||
return JS_EXCEPTION;
|
||||
@ -552,7 +552,7 @@ static void js_agent_free(JSContext *ctx)
|
||||
{
|
||||
struct list_head *el, *el1;
|
||||
Test262Agent *agent;
|
||||
|
||||
|
||||
list_for_each_safe(el, el1, &agent_list) {
|
||||
agent = list_entry(el, Test262Agent, link);
|
||||
pthread_join(agent->tid, NULL);
|
||||
@ -561,7 +561,7 @@ static void js_agent_free(JSContext *ctx)
|
||||
free(agent);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static JSValue js_agent_leaving(JSContext *ctx, JSValue this_val,
|
||||
int argc, JSValue *argv)
|
||||
{
|
||||
@ -593,16 +593,16 @@ static JSValue js_agent_broadcast(JSContext *ctx, JSValue this_val,
|
||||
uint8_t *buf;
|
||||
size_t buf_size;
|
||||
int32_t val;
|
||||
|
||||
|
||||
if (JS_GetContextOpaque(ctx) != NULL)
|
||||
return JS_ThrowTypeError(ctx, "cannot be called inside an agent");
|
||||
|
||||
|
||||
buf = JS_GetArrayBuffer(ctx, &buf_size, sab);
|
||||
if (!buf)
|
||||
return JS_EXCEPTION;
|
||||
if (JS_ToInt32(ctx, &val, argv[1]))
|
||||
return JS_EXCEPTION;
|
||||
|
||||
|
||||
/* broadcast the values and wait until all agents have started
|
||||
calling their callbacks */
|
||||
pthread_mutex_lock(&agent_mutex);
|
||||
@ -697,7 +697,7 @@ static JSValue js_agent_report(JSContext *ctx, JSValue this_val,
|
||||
rep = malloc(sizeof(*rep));
|
||||
rep->str = strdup(str);
|
||||
JS_FreeCString(ctx, str);
|
||||
|
||||
|
||||
pthread_mutex_lock(&report_mutex);
|
||||
list_add_tail(&rep->link, &report_list);
|
||||
pthread_mutex_unlock(&report_mutex);
|
||||
@ -717,7 +717,7 @@ static const JSCFunctionListEntry js_agent_funcs[] = {
|
||||
JS_CFUNC_DEF("sleep", 1, js_agent_sleep ),
|
||||
JS_CFUNC_DEF("monotonicNow", 0, js_agent_monotonicNow ),
|
||||
};
|
||||
|
||||
|
||||
static JSValue js_new_agent(JSContext *ctx)
|
||||
{
|
||||
JSValue agent;
|
||||
@ -733,7 +733,7 @@ static JSValue js_createRealm(JSContext *ctx, JSValue this_val,
|
||||
{
|
||||
JSContext *ctx1;
|
||||
JSValue ret;
|
||||
|
||||
|
||||
ctx1 = JS_NewContext(JS_GetRuntime(ctx));
|
||||
if (!ctx1)
|
||||
return JS_ThrowOutOfMemory(ctx);
|
||||
@ -753,7 +753,7 @@ static JSValue add_helpers1(JSContext *ctx)
|
||||
{
|
||||
JSValue global_obj;
|
||||
JSValue obj262, obj;
|
||||
|
||||
|
||||
global_obj = JS_GetGlobalObject(ctx);
|
||||
|
||||
JS_SetPropertyStr(ctx, global_obj, "print",
|
||||
@ -784,7 +784,7 @@ static JSValue add_helpers1(JSContext *ctx)
|
||||
JS_SetPropertyStr(ctx, obj262, "IsHTMLDDA", obj);
|
||||
|
||||
JS_SetPropertyStr(ctx, global_obj, "$262", JS_DupValue(ctx, obj262));
|
||||
|
||||
|
||||
JS_FreeValue(ctx, global_obj);
|
||||
return obj262;
|
||||
}
|
||||
@ -813,14 +813,14 @@ static JSModuleDef *js_module_loader_test(JSContext *ctx,
|
||||
uint8_t *buf;
|
||||
JSModuleDef *m;
|
||||
JSValue func_val;
|
||||
|
||||
|
||||
buf = js_load_file(ctx, &buf_len, module_name);
|
||||
if (!buf) {
|
||||
JS_ThrowReferenceError(ctx, "could not load module filename '%s'",
|
||||
module_name);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
/* compile the module */
|
||||
func_val = JS_Eval(ctx, (char *)buf, buf_len, module_name,
|
||||
JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);
|
||||
@ -929,14 +929,14 @@ void load_config(const char *filename)
|
||||
perror_exit(1, filename);
|
||||
}
|
||||
base_name = get_basename(filename);
|
||||
|
||||
|
||||
while (fgets(buf, sizeof(buf), f) != NULL) {
|
||||
char *p, *q;
|
||||
lineno++;
|
||||
p = str_strip(buf);
|
||||
if (*p == '#' || *p == ';' || *p == '\0')
|
||||
continue; /* line comment */
|
||||
|
||||
|
||||
if (*p == "[]"[0]) {
|
||||
/* new section */
|
||||
p++;
|
||||
@ -1002,7 +1002,7 @@ void load_config(const char *filename)
|
||||
test_mode = TEST_STRICT;
|
||||
else if (str_equal(q, "all") || str_equal(q, "both"))
|
||||
test_mode = TEST_ALL;
|
||||
else
|
||||
else
|
||||
fatal(2, "unknown test mode: %s", q);
|
||||
continue;
|
||||
}
|
||||
@ -1143,7 +1143,7 @@ int longest_match(const char *str, const char *find, int pos, int *ppos, int lin
|
||||
int len, maxlen;
|
||||
|
||||
maxlen = 0;
|
||||
|
||||
|
||||
if (*find) {
|
||||
const char *p;
|
||||
for (p = str + pos; *p; p++) {
|
||||
@ -1176,7 +1176,7 @@ static int eval_buf(JSContext *ctx, const char *buf, size_t buf_len,
|
||||
int ret, error_line, pos, pos_line;
|
||||
BOOL is_error, has_error_line, ret_promise;
|
||||
const char *error_name;
|
||||
|
||||
|
||||
pos = skip_comments(buf, 1, &pos_line);
|
||||
error_line = pos_line;
|
||||
has_error_line = FALSE;
|
||||
@ -1186,7 +1186,7 @@ static int eval_buf(JSContext *ctx, const char *buf, size_t buf_len,
|
||||
/* a module evaluation returns a promise */
|
||||
ret_promise = ((eval_flags & JS_EVAL_TYPE_MODULE) != 0);
|
||||
async_done = 0; /* counter of "Test262:AsyncTestComplete" messages */
|
||||
|
||||
|
||||
res_val = JS_Eval(ctx, buf, buf_len, filename, eval_flags);
|
||||
|
||||
if ((is_async || ret_promise) && !JS_IsException(res_val)) {
|
||||
@ -1239,7 +1239,7 @@ static int eval_buf(JSContext *ctx, const char *buf, size_t buf_len,
|
||||
if (is_error) {
|
||||
JSValue name, stack;
|
||||
const char *stack_str;
|
||||
|
||||
|
||||
name = JS_GetPropertyStr(ctx, exception_val, "name");
|
||||
error_name = JS_ToCString(ctx, name);
|
||||
stack = JS_GetPropertyStr(ctx, exception_val, "stack");
|
||||
@ -1248,10 +1248,10 @@ static int eval_buf(JSContext *ctx, const char *buf, size_t buf_len,
|
||||
if (stack_str) {
|
||||
const char *p;
|
||||
int len;
|
||||
|
||||
|
||||
if (outfile)
|
||||
fprintf(outfile, "%s", stack_str);
|
||||
|
||||
|
||||
len = strlen(filename);
|
||||
p = strstr(stack_str, filename);
|
||||
if (p != NULL && p[len] == ':') {
|
||||
@ -1269,7 +1269,7 @@ static int eval_buf(JSContext *ctx, const char *buf, size_t buf_len,
|
||||
if (error_type) {
|
||||
char *error_class;
|
||||
const char *msg;
|
||||
|
||||
|
||||
msg = JS_ToCString(ctx, exception_val);
|
||||
error_class = strdup_len(msg, strcspn(msg, ":"));
|
||||
if (!str_equal(error_class, error_type))
|
||||
@ -1393,7 +1393,7 @@ char *extract_desc(const char *buf, char style)
|
||||
const char *p, *desc_start;
|
||||
char *desc;
|
||||
int len;
|
||||
|
||||
|
||||
p = buf;
|
||||
while (*p != '\0') {
|
||||
if (p[0] == '/' && p[1] == '*' && p[2] == style && p[3] != '/') {
|
||||
@ -1525,11 +1525,11 @@ int run_test_buf(const char *filename, const char *harness, namelist_t *ip,
|
||||
JSRuntime *rt;
|
||||
JSContext *ctx;
|
||||
int i, ret;
|
||||
|
||||
|
||||
rt = JS_NewRuntime();
|
||||
if (rt == NULL) {
|
||||
fatal(1, "JS_NewRuntime failure");
|
||||
}
|
||||
}
|
||||
ctx = JS_NewContext(rt);
|
||||
if (ctx == NULL) {
|
||||
JS_FreeRuntime(rt);
|
||||
@ -1538,10 +1538,10 @@ int run_test_buf(const char *filename, const char *harness, namelist_t *ip,
|
||||
JS_SetRuntimeInfo(rt, filename);
|
||||
|
||||
JS_SetCanBlock(rt, can_block);
|
||||
|
||||
|
||||
/* loader for ES6 modules */
|
||||
JS_SetModuleLoaderFunc(rt, NULL, js_module_loader_test, NULL);
|
||||
|
||||
|
||||
add_helpers(ctx);
|
||||
|
||||
for (i = 0; i < ip->count; i++) {
|
||||
@ -1554,7 +1554,7 @@ int run_test_buf(const char *filename, const char *harness, namelist_t *ip,
|
||||
ret = eval_buf(ctx, buf, buf_len, filename, TRUE, is_negative,
|
||||
error_type, outfile, eval_flags, is_async);
|
||||
ret = (ret != 0);
|
||||
|
||||
|
||||
if (dump_memory) {
|
||||
update_stats(rt, filename);
|
||||
}
|
||||
@ -1587,7 +1587,7 @@ int run_test(const char *filename, int index)
|
||||
BOOL is_negative, is_nostrict, is_onlystrict, is_async, is_module, skip;
|
||||
BOOL can_block;
|
||||
namelist_t include_list = { 0 }, *ip = &include_list;
|
||||
|
||||
|
||||
is_nostrict = is_onlystrict = is_negative = is_async = is_module = skip = FALSE;
|
||||
can_block = TRUE;
|
||||
error_type = NULL;
|
||||
@ -1823,13 +1823,13 @@ int run_test262_harness_test(const char *filename, BOOL is_module)
|
||||
int eval_flags, ret_code, ret;
|
||||
JSValue res_val;
|
||||
BOOL can_block;
|
||||
|
||||
|
||||
outfile = stdout; /* for js_print */
|
||||
|
||||
rt = JS_NewRuntime();
|
||||
if (rt == NULL) {
|
||||
fatal(1, "JS_NewRuntime failure");
|
||||
}
|
||||
}
|
||||
ctx = JS_NewContext(rt);
|
||||
if (ctx == NULL) {
|
||||
JS_FreeRuntime(rt);
|
||||
@ -1839,10 +1839,10 @@ int run_test262_harness_test(const char *filename, BOOL is_module)
|
||||
|
||||
can_block = TRUE;
|
||||
JS_SetCanBlock(rt, can_block);
|
||||
|
||||
|
||||
/* loader for ES6 modules */
|
||||
JS_SetModuleLoaderFunc(rt, NULL, js_module_loader_test, NULL);
|
||||
|
||||
|
||||
add_helpers(ctx);
|
||||
|
||||
buf = load_file(filename, &buf_len);
|
||||
@ -2035,14 +2035,14 @@ int main(int argc, char **argv)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (optind >= argc && !test_list.count)
|
||||
help();
|
||||
|
||||
if (is_test262_harness) {
|
||||
return run_test262_harness_test(argv[optind], is_module);
|
||||
}
|
||||
|
||||
|
||||
error_out = stdout;
|
||||
if (error_filename) {
|
||||
error_file = load_file(error_filename, NULL);
|
||||
|
@ -15,7 +15,7 @@ mode=default
|
||||
|
||||
# handle tests flagged as [async]: yes, no, skip
|
||||
# for these, load 'harness/doneprintHandle.js' prior to test
|
||||
# and expect `print('Test262:AsyncTestComplete')` to be called for
|
||||
# and expect `print('Test262:AsyncTestComplete')` to be called for
|
||||
# successful termination
|
||||
async=yes
|
||||
|
||||
|
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* QuickJS: binary JSON module (test only)
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017-2019 Fabrice Bellard
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
@ -32,7 +32,7 @@ static JSValue js_bjson_read(JSContext *ctx, JSValueConst this_val,
|
||||
JSValue obj;
|
||||
size_t size;
|
||||
int flags;
|
||||
|
||||
|
||||
if (JS_ToIndex(ctx, &pos, argv[1]))
|
||||
return JS_EXCEPTION;
|
||||
if (JS_ToIndex(ctx, &len, argv[2]))
|
||||
@ -56,7 +56,7 @@ static JSValue js_bjson_write(JSContext *ctx, JSValueConst this_val,
|
||||
uint8_t *buf;
|
||||
JSValue array;
|
||||
int flags;
|
||||
|
||||
|
||||
flags = 0;
|
||||
if (JS_ToBool(ctx, argv[1]))
|
||||
flags |= JS_WRITE_OBJ_REFERENCE;
|
||||
|
@ -61,7 +61,7 @@ function toPrec(n, prec) {
|
||||
s = s.substring(0, i) + "." + s.substring(i);
|
||||
return s;
|
||||
}
|
||||
|
||||
|
||||
var ref_data;
|
||||
var log_data;
|
||||
|
||||
@ -987,7 +987,7 @@ function main(argc, argv, g)
|
||||
];
|
||||
var tests = [];
|
||||
var i, j, n, f, name;
|
||||
|
||||
|
||||
if (typeof BigInt == "function") {
|
||||
/* BigInt test */
|
||||
test_list.push(bigint64_arith);
|
||||
@ -997,7 +997,7 @@ function main(argc, argv, g)
|
||||
/* BigFloat test */
|
||||
test_list.push(float256_arith);
|
||||
}
|
||||
|
||||
|
||||
for (i = 1; i < argc;) {
|
||||
name = argv[i++];
|
||||
if (name == "-a") {
|
||||
@ -1047,7 +1047,7 @@ function main(argc, argv, g)
|
||||
log_line("total", "", total[2], total[3], total_score * 100 / total_scale);
|
||||
else
|
||||
log_line("total", "", total[2]);
|
||||
|
||||
|
||||
if (tests == test_list)
|
||||
save_result("microbench-new.txt", log_data);
|
||||
}
|
||||
|
@ -28,7 +28,7 @@ index be7039fda0..7b38abf8df 100644
|
||||
@@ -6,24 +6,27 @@ description: |
|
||||
defines: [buildString, testPropertyEscapes, matchValidator]
|
||||
---*/
|
||||
|
||||
|
||||
+if ($262 && typeof $262.codePointRange === "function") {
|
||||
+ /* use C function to build the codePointRange (much faster with
|
||||
+ slow JS engines) */
|
||||
@ -67,5 +67,5 @@ index be7039fda0..7b38abf8df 100644
|
||||
- return result;
|
||||
+ return result;
|
||||
}
|
||||
|
||||
|
||||
function testPropertyEscapes(regex, string, expression) {
|
||||
|
@ -94,7 +94,7 @@ function test_bigint1()
|
||||
|
||||
r = 1n << 31n;
|
||||
assert(r, 2147483648n, "1 << 31n === 2147483648n");
|
||||
|
||||
|
||||
r = 1n << 32n;
|
||||
assert(r, 4294967296n, "1 << 32n === 4294967296n");
|
||||
}
|
||||
@ -150,7 +150,7 @@ function test_bigint_ext()
|
||||
function test_bigfloat()
|
||||
{
|
||||
var e, a, b, sqrt2;
|
||||
|
||||
|
||||
assert(typeof 1n === "bigint");
|
||||
assert(typeof 1l === "bigfloat");
|
||||
assert(1 == 1.0l);
|
||||
@ -164,7 +164,7 @@ function test_bigfloat()
|
||||
|
||||
test_less(2.1, 3l);
|
||||
test_eq(Math.sqrt(9), 3l);
|
||||
|
||||
|
||||
test_less(2n, 3l);
|
||||
test_eq(3n, 3l);
|
||||
|
||||
@ -174,7 +174,7 @@ function test_bigfloat()
|
||||
assert(a === BigFloat.parseFloat("0x1.6a09e667f3bcc908b2fb1366ea957d3e", 0, e));
|
||||
assert(e.inexact === true);
|
||||
assert(BigFloat.fpRound(a) == 0x1.6a09e667f3bcc908b2fb1366ea95l);
|
||||
|
||||
|
||||
b = BigFloatEnv.setPrec(BigFloat.sqrt.bind(null, 2), 128);
|
||||
assert(a === b);
|
||||
|
||||
@ -188,7 +188,7 @@ function test_bigfloat()
|
||||
assert(BigFloat.exp(0.2l) === 1.2214027581601698339210719946396742l);
|
||||
assert(BigFloat.log(3l) === 1.0986122886681096913952452369225256l);
|
||||
assert(BigFloat.pow(2.1l, 1.6l) === 3.277561666451861947162828744873745l);
|
||||
|
||||
|
||||
assert(BigFloat.sin(-1l) === -0.841470984807896506652502321630299l);
|
||||
assert(BigFloat.cos(1l) === 0.5403023058681397174009366074429766l);
|
||||
assert(BigFloat.tan(0.1l) === 0.10033467208545054505808004578111154l);
|
||||
@ -241,16 +241,16 @@ function test_bigdecimal()
|
||||
assert(1m !== 2m);
|
||||
test_less(1m, 2m);
|
||||
test_eq(2m, 2m);
|
||||
|
||||
|
||||
test_less(1, 2m);
|
||||
test_eq(2, 2m);
|
||||
|
||||
test_less(1.1, 2m);
|
||||
test_eq(Math.sqrt(4), 2m);
|
||||
|
||||
|
||||
test_less(2n, 3m);
|
||||
test_eq(3n, 3m);
|
||||
|
||||
|
||||
assert(BigDecimal("1234.1") === 1234.1m);
|
||||
assert(BigDecimal(" 1234.1") === 1234.1m);
|
||||
assert(BigDecimal(" 1234.1 ") === 1234.1m);
|
||||
@ -272,7 +272,7 @@ function test_bigdecimal()
|
||||
assert(1234.5m ** 3m === 1881365963.625m);
|
||||
assertThrows(RangeError, () => { 2m ** 3.1m } );
|
||||
assertThrows(RangeError, () => { 2m ** -3m } );
|
||||
|
||||
|
||||
assert(BigDecimal.sqrt(2m,
|
||||
{ roundingMode: "half-even",
|
||||
maximumSignificantDigits: 4 }) === 1.414m);
|
||||
@ -282,7 +282,7 @@ function test_bigdecimal()
|
||||
assert(BigDecimal.sqrt(0.002m,
|
||||
{ roundingMode: "half-even",
|
||||
maximumFractionDigits: 3 }) === 0.045m);
|
||||
|
||||
|
||||
assert(BigDecimal.round(3.14159m,
|
||||
{ roundingMode: "half-even",
|
||||
maximumFractionDigits: 3 }) === 3.142m);
|
||||
|
@ -34,7 +34,7 @@ function toHex(a)
|
||||
|
||||
function isArrayLike(a)
|
||||
{
|
||||
return Array.isArray(a) ||
|
||||
return Array.isArray(a) ||
|
||||
(a instanceof Uint8ClampedArray) ||
|
||||
(a instanceof Uint8Array) ||
|
||||
(a instanceof Uint16Array) ||
|
||||
@ -147,7 +147,7 @@ function bjson_test_reference()
|
||||
function bjson_test_all()
|
||||
{
|
||||
var obj;
|
||||
|
||||
|
||||
bjson_test({x:1, y:2, if:3});
|
||||
bjson_test([1, 2, 3]);
|
||||
bjson_test([1.0, "aa", true, false, undefined, null, NaN, -Infinity, -0.0]);
|
||||
@ -174,7 +174,7 @@ function bjson_test_all()
|
||||
|
||||
bjson_test(new Int32Array([123123, 222111, -32222]));
|
||||
bjson_test(new Float64Array([123123, 222111.5]));
|
||||
|
||||
|
||||
/* tested with a circular reference */
|
||||
obj = {};
|
||||
obj.x = obj;
|
||||
|
@ -57,7 +57,7 @@ function test_function()
|
||||
}
|
||||
|
||||
var r, g;
|
||||
|
||||
|
||||
r = my_func.call(null, 1, 2);
|
||||
assert(r, 3, "call");
|
||||
|
||||
@ -70,10 +70,10 @@ function test_function()
|
||||
assert_throws(TypeError, (function() {
|
||||
Reflect.apply((function () { return 1; }), null, undefined);
|
||||
}));
|
||||
|
||||
|
||||
r = new Function("a", "b", "return a + b;");
|
||||
assert(r(2,3), 5, "function");
|
||||
|
||||
|
||||
g = f.bind(1, 2);
|
||||
assert(g.length, 1);
|
||||
assert(g.name, "bound f");
|
||||
@ -103,7 +103,7 @@ function test()
|
||||
assert(a.z, 4, "get");
|
||||
a.z = 5;
|
||||
assert(a.z_val, 5, "set");
|
||||
|
||||
|
||||
a = { get z() { return 4; }, set z(val) { this.z_val = val; } };
|
||||
assert(a.z, 4, "get");
|
||||
a.z = 5;
|
||||
@ -207,7 +207,7 @@ function test_string()
|
||||
assert(a.charAt(1), "b");
|
||||
assert(a.charAt(-1), "");
|
||||
assert(a.charAt(3), "");
|
||||
|
||||
|
||||
a = "abcd";
|
||||
assert(a.substring(1, 3), "bc", "substring");
|
||||
a = String.fromCharCode(0x20ac);
|
||||
@ -216,7 +216,7 @@ function test_string()
|
||||
assert(a, "\u20ac", "unicode");
|
||||
assert(a, "\u{20ac}", "unicode");
|
||||
assert("a", "\x61", "unicode");
|
||||
|
||||
|
||||
a = "\u{10ffff}";
|
||||
assert(a.length, 2, "unicode");
|
||||
assert(a, "\u{dbff}\u{dfff}", "unicode");
|
||||
@ -379,7 +379,7 @@ function test_eval()
|
||||
assert(eval("if (0) 2; else 3;"), 3);
|
||||
|
||||
assert(f.call(1, "this"), 1);
|
||||
|
||||
|
||||
a = 2;
|
||||
assert(eval("a"), 2);
|
||||
|
||||
@ -424,7 +424,7 @@ function test_typed_array()
|
||||
a[2] = 0.5;
|
||||
a[3] = 1233.5;
|
||||
assert(a.toString(), "0,2,0,255");
|
||||
|
||||
|
||||
buffer = new ArrayBuffer(16);
|
||||
assert(buffer.byteLength, 16);
|
||||
a = new Uint32Array(buffer, 12, 1);
|
||||
@ -436,7 +436,7 @@ function test_typed_array()
|
||||
|
||||
a = new Float32Array(buffer, 8, 1);
|
||||
a[0] = 1;
|
||||
|
||||
|
||||
a = new Uint8Array(buffer);
|
||||
|
||||
str = a.toString();
|
||||
@ -525,7 +525,7 @@ function test_regexp()
|
||||
|
||||
a = /(\.(?!com|org)|\/)/.exec("ah.com");
|
||||
assert(a, null);
|
||||
|
||||
|
||||
a = /(?=(a+))/.exec("baaabac");
|
||||
assert(a.index === 1 && a[0] === "" && a[1] === "aaa");
|
||||
|
||||
@ -602,7 +602,7 @@ function test_map()
|
||||
}
|
||||
|
||||
i = 0;
|
||||
a.forEach(function (v, o) {
|
||||
a.forEach(function (v, o) {
|
||||
assert(o, tab[i++][0]);
|
||||
assert(a.has(o));
|
||||
assert(a.delete(o));
|
||||
@ -625,7 +625,7 @@ function test_weak_map()
|
||||
a.set(o, v);
|
||||
}
|
||||
o = null;
|
||||
|
||||
|
||||
n2 = n >> 1;
|
||||
for(i = 0; i < n2; i++) {
|
||||
a.delete(tab[i][0]);
|
||||
|
@ -54,7 +54,7 @@ function test_closure1()
|
||||
function f2()
|
||||
{
|
||||
var val = 1;
|
||||
|
||||
|
||||
function set(a) {
|
||||
val = a;
|
||||
}
|
||||
@ -63,7 +63,7 @@ function test_closure1()
|
||||
}
|
||||
return { "set": set, "get": get };
|
||||
}
|
||||
|
||||
|
||||
var obj = f2();
|
||||
obj.set(10);
|
||||
var r;
|
||||
|
@ -68,10 +68,10 @@ function test_op1()
|
||||
|
||||
r = 1 << 31;
|
||||
assert(r, -2147483648, "1 << 31 === -2147483648");
|
||||
|
||||
|
||||
r = 1 << 32;
|
||||
assert(r, 1, "1 << 32 === 1");
|
||||
|
||||
|
||||
r = (1 << 31) < 0;
|
||||
assert(r, true, "(1 << 31) < 0 === true");
|
||||
|
||||
@ -113,7 +113,7 @@ function test_cvt()
|
||||
assert(("12345" | 0) === 12345);
|
||||
assert(("0x12345" | 0) === 0x12345);
|
||||
assert(((4294967296 * 3 - 4) | 0) === -4);
|
||||
|
||||
|
||||
assert(("12345" >>> 0) === 12345);
|
||||
assert(("0x12345" >>> 0) === 0x12345);
|
||||
assert((NaN >>> 0) === 0);
|
||||
@ -141,7 +141,7 @@ function test_eq()
|
||||
function test_inc_dec()
|
||||
{
|
||||
var a, r;
|
||||
|
||||
|
||||
a = 1;
|
||||
r = a++;
|
||||
assert(r === 1 && a === 2, true, "++");
|
||||
@ -169,19 +169,19 @@ function test_inc_dec()
|
||||
a = [true];
|
||||
a[0]++;
|
||||
assert(a[0], 2, "++");
|
||||
|
||||
|
||||
a = {x:true};
|
||||
r = a.x++;
|
||||
assert(r === 1 && a.x === 2, true, "++");
|
||||
|
||||
|
||||
a = {x:true};
|
||||
r = a.x--;
|
||||
assert(r === 1 && a.x === 0, true, "--");
|
||||
|
||||
|
||||
a = [true];
|
||||
r = a[0]++;
|
||||
assert(r === 1 && a[0] === 2, true, "++");
|
||||
|
||||
|
||||
a = [true];
|
||||
r = a[0]--;
|
||||
assert(r === 1 && a[0] === 0, true, "--");
|
||||
@ -213,7 +213,7 @@ function test_op2()
|
||||
assert((typeof Object), "function", "typeof");
|
||||
assert((typeof null), "object", "typeof");
|
||||
assert((typeof unknown_var), "undefined", "typeof");
|
||||
|
||||
|
||||
a = {x: 1, if: 2, async: 3};
|
||||
assert(a.if === 2);
|
||||
assert(a.async === 3);
|
||||
@ -226,7 +226,7 @@ function test_delete()
|
||||
a = {x: 1, y: 1};
|
||||
assert((delete a.x), true, "delete");
|
||||
assert(("x" in a), false, "delete");
|
||||
|
||||
|
||||
/* the following are not tested by test262 */
|
||||
assert(delete "abc"[100], true);
|
||||
|
||||
@ -311,7 +311,7 @@ function test_class()
|
||||
o = new C();
|
||||
assert(o.f() === 1);
|
||||
assert(o.x === 10);
|
||||
|
||||
|
||||
assert(D.F() === -1);
|
||||
assert(D.G() === -2);
|
||||
assert(D.H() === -1);
|
||||
@ -374,7 +374,7 @@ function test_regexp_skip()
|
||||
var a, b;
|
||||
[a, b = /abc\(/] = [1];
|
||||
assert(a === 1);
|
||||
|
||||
|
||||
[a, b =/abc\(/] = [2];
|
||||
assert(a === 2);
|
||||
}
|
||||
@ -419,7 +419,7 @@ function test_argument_scope()
|
||||
{
|
||||
var f;
|
||||
var c = "global";
|
||||
|
||||
|
||||
f = function(a = eval("var arguments")) {};
|
||||
assert_throws(SyntaxError, f);
|
||||
|
||||
@ -490,7 +490,7 @@ function test_function_expr_name()
|
||||
|
||||
/* non strict mode test : assignment to the function name silently
|
||||
fails */
|
||||
|
||||
|
||||
f = function myfunc() {
|
||||
myfunc = 1;
|
||||
return myfunc;
|
||||
@ -511,7 +511,7 @@ function test_function_expr_name()
|
||||
return myfunc;
|
||||
};
|
||||
assert(f(), f);
|
||||
|
||||
|
||||
/* strict mode test : assignment to the function name raises a
|
||||
TypeError exception */
|
||||
|
||||
@ -581,7 +581,7 @@ function test_optional_chaining()
|
||||
assert(delete z?.b["c"], true);
|
||||
assert(delete a?.b["c"], true);
|
||||
assert(JSON.stringify(a), '{"b":{}}');
|
||||
|
||||
|
||||
a = {
|
||||
b() { return this._b; },
|
||||
_b: { c: 42 }
|
||||
|
@ -356,7 +356,7 @@ function test_try_catch7()
|
||||
function test_try_catch8()
|
||||
{
|
||||
var i, s;
|
||||
|
||||
|
||||
s = "";
|
||||
for(var i in {x:1, y:2}) {
|
||||
try {
|
||||
|
@ -35,7 +35,7 @@ function test_operators_create() {
|
||||
return "Vec2(" + this.x + "," + this.y + ")";
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
Vec2.prototype[Symbol.operatorSet] = Operators.create(
|
||||
{
|
||||
"+"(p1, p2) {
|
||||
@ -172,7 +172,7 @@ function test_operators()
|
||||
return "Vec2(" + this.x + "," + this.y + ")";
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
var a = new Vec2(1, 2);
|
||||
var b = new Vec2(3, 4);
|
||||
var r;
|
||||
|
@ -60,10 +60,10 @@ function test_integer()
|
||||
|
||||
r = 1 << 31;
|
||||
assert(r, 2147483648, "1 << 31 === 2147483648");
|
||||
|
||||
|
||||
r = 1 << 32;
|
||||
assert(r, 4294967296, "1 << 32 === 4294967296");
|
||||
|
||||
|
||||
r = (1 << 31) < 0;
|
||||
assert(r, false, "(1 << 31) < 0 === false");
|
||||
|
||||
@ -115,7 +115,7 @@ function test_fraction()
|
||||
function test_mod()
|
||||
{
|
||||
var a, b, p;
|
||||
|
||||
|
||||
a = Mod(3, 101);
|
||||
b = Mod(-1, 101);
|
||||
assert((a + b) == Mod(2, 101));
|
||||
@ -131,7 +131,7 @@ function test_polynomial()
|
||||
var a, b, q, r, t, i;
|
||||
a = (1 + X) ^ 4;
|
||||
assert(a == X^4+4*X^3+6*X^2+4*X+1);
|
||||
|
||||
|
||||
r = (1 + X);
|
||||
q = (1+X+X^2);
|
||||
b = (1 - X^2);
|
||||
|
@ -46,7 +46,7 @@ function test_file1()
|
||||
f.seek(0, std.SEEK_SET);
|
||||
str1 = f.readAsString();
|
||||
assert(str1 === str);
|
||||
|
||||
|
||||
f.seek(0, std.SEEK_END);
|
||||
size = f.tell();
|
||||
assert(size === str.length);
|
||||
@ -81,7 +81,7 @@ function test_file2()
|
||||
function test_getline()
|
||||
{
|
||||
var f, line, line_count, lines, i;
|
||||
|
||||
|
||||
lines = ["hello world", "line 1", "line 2" ];
|
||||
f = std.tmpfile();
|
||||
for(i = 0; i < lines.length; i++) {
|
||||
@ -103,7 +103,7 @@ function test_getline()
|
||||
|
||||
f.close();
|
||||
}
|
||||
|
||||
|
||||
function test_popen()
|
||||
{
|
||||
var str, f, fname = "tmp_file.txt";
|
||||
@ -115,7 +115,7 @@ function test_popen()
|
||||
|
||||
/* test loadFile */
|
||||
assert(std.loadFile(fname), content);
|
||||
|
||||
|
||||
/* execute the 'cat' shell command */
|
||||
f = std.popen("cat " + fname, "r");
|
||||
str = f.readAsString();
|
||||
@ -150,17 +150,17 @@ function test_os()
|
||||
fname = "tmp_file.txt";
|
||||
fpath = fdir + "/" + fname;
|
||||
link_path = fdir + "/test_link";
|
||||
|
||||
|
||||
os.remove(link_path);
|
||||
os.remove(fpath);
|
||||
os.remove(fdir);
|
||||
|
||||
err = os.mkdir(fdir, 0o755);
|
||||
assert(err === 0);
|
||||
|
||||
|
||||
fd = os.open(fpath, os.O_RDWR | os.O_CREAT | os.O_TRUNC);
|
||||
assert(fd >= 0);
|
||||
|
||||
|
||||
buf = new Uint8Array(10);
|
||||
for(i = 0; i < buf.length; i++)
|
||||
buf[i] = i;
|
||||
@ -169,16 +169,16 @@ function test_os()
|
||||
assert(os.seek(fd, 0, std.SEEK_SET) === 0);
|
||||
buf2 = new Uint8Array(buf.length);
|
||||
assert(os.read(fd, buf2.buffer, 0, buf2.length) === buf2.length);
|
||||
|
||||
|
||||
for(i = 0; i < buf.length; i++)
|
||||
assert(buf[i] == buf2[i]);
|
||||
|
||||
|
||||
if (typeof BigInt !== "undefined") {
|
||||
assert(os.seek(fd, BigInt(6), std.SEEK_SET), BigInt(6));
|
||||
assert(os.read(fd, buf2.buffer, 0, 1) === 1);
|
||||
assert(buf[6] == buf2[0]);
|
||||
}
|
||||
|
||||
|
||||
assert(os.close(fd) === 0);
|
||||
|
||||
[files, err] = os.readdir(fdir);
|
||||
@ -189,7 +189,7 @@ function test_os()
|
||||
|
||||
err = os.utimes(fpath, fdate, fdate);
|
||||
assert(err, 0);
|
||||
|
||||
|
||||
[st, err] = os.stat(fpath);
|
||||
assert(err, 0);
|
||||
assert(st.mode & os.S_IFMT, os.S_IFREG);
|
||||
@ -197,7 +197,7 @@ function test_os()
|
||||
|
||||
err = os.symlink(fname, link_path);
|
||||
assert(err === 0);
|
||||
|
||||
|
||||
[st, err] = os.lstat(link_path);
|
||||
assert(err, 0);
|
||||
assert(st.mode & os.S_IFMT, os.S_IFLNK);
|
||||
@ -205,7 +205,7 @@ function test_os()
|
||||
[buf, err] = os.readlink(link_path);
|
||||
assert(err, 0);
|
||||
assert(buf, fname);
|
||||
|
||||
|
||||
assert(os.remove(link_path) === 0);
|
||||
|
||||
[buf, err] = os.getcwd();
|
||||
@ -215,7 +215,7 @@ function test_os()
|
||||
assert(err, 0);
|
||||
|
||||
assert(buf, buf2);
|
||||
|
||||
|
||||
assert(os.remove(fpath) === 0);
|
||||
|
||||
fd = os.open(fpath, os.O_RDONLY);
|
||||
@ -233,7 +233,7 @@ function test_os_exec()
|
||||
|
||||
ret = os.exec(["/bin/sh", "-c", "exit 1"], { usePath: false });
|
||||
assert(ret, 1);
|
||||
|
||||
|
||||
fds = os.pipe();
|
||||
pid = os.exec(["sh", "-c", "echo $FOO"], {
|
||||
stdout: fds[1],
|
||||
@ -277,16 +277,16 @@ function test_async_gc()
|
||||
{
|
||||
(async function run () {
|
||||
let obj = {}
|
||||
|
||||
|
||||
let done = () => {
|
||||
obj
|
||||
std.gc();
|
||||
}
|
||||
|
||||
|
||||
Promise.resolve().then(done)
|
||||
|
||||
|
||||
const p = new Promise(() => {})
|
||||
|
||||
|
||||
await p
|
||||
})();
|
||||
}
|
||||
|
@ -22,10 +22,10 @@ function handle_msg(e) {
|
||||
|
||||
function worker_main() {
|
||||
var i;
|
||||
|
||||
|
||||
parent.onmessage = handle_msg;
|
||||
for(i = 0; i < 10; i++) {
|
||||
parent.postMessage({ type: "num", num: i });
|
||||
parent.postMessage({ type: "num", num: i });
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -15,5 +15,5 @@ for f in $files; do
|
||||
g="${url}/${f}"
|
||||
wget $g -O unicode/$f
|
||||
done
|
||||
|
||||
|
||||
wget $emoji_url -O unicode/emoji-data.txt
|
||||
|
140
unicode_gen.c
140
unicode_gen.c
@ -1,6 +1,6 @@
|
||||
/*
|
||||
* Generation of Unicode tables
|
||||
*
|
||||
*
|
||||
* Copyright (c) 2017-2018 Fabrice Bellard
|
||||
* Copyright (c) 2017-2018 Charlie Gordon
|
||||
*
|
||||
@ -291,7 +291,7 @@ void parse_unicode_data(const char *filename)
|
||||
const char *p;
|
||||
int code, lc, uc, last_code;
|
||||
CCInfo *ci, *tab = unicode_db;
|
||||
|
||||
|
||||
f = fopen(filename, "rb");
|
||||
if (!f) {
|
||||
perror(filename);
|
||||
@ -314,7 +314,7 @@ void parse_unicode_data(const char *filename)
|
||||
code = strtoul(p, NULL, 16);
|
||||
lc = 0;
|
||||
uc = 0;
|
||||
|
||||
|
||||
p = get_field(line, 12);
|
||||
if (p && *p != ';') {
|
||||
uc = strtoul(p, NULL, 16);
|
||||
@ -350,7 +350,7 @@ void parse_unicode_data(const char *filename)
|
||||
}
|
||||
ci->general_category = i;
|
||||
}
|
||||
|
||||
|
||||
p = get_field(line, 3);
|
||||
if (p && *p != ';' && *p != '\0') {
|
||||
int cc;
|
||||
@ -402,7 +402,7 @@ void parse_unicode_data(const char *filename)
|
||||
if (p && *p == 'Y') {
|
||||
set_prop(code, PROP_Bidi_Mirrored, 1);
|
||||
}
|
||||
|
||||
|
||||
/* handle ranges */
|
||||
get_field_buf(buf1, sizeof(buf1), line, 1);
|
||||
if (strstr(buf1, " Last>")) {
|
||||
@ -416,7 +416,7 @@ void parse_unicode_data(const char *filename)
|
||||
}
|
||||
last_code = code;
|
||||
}
|
||||
|
||||
|
||||
fclose(f);
|
||||
}
|
||||
|
||||
@ -427,7 +427,7 @@ void parse_special_casing(CCInfo *tab, const char *filename)
|
||||
const char *p;
|
||||
int code;
|
||||
CCInfo *ci;
|
||||
|
||||
|
||||
f = fopen(filename, "rb");
|
||||
if (!f) {
|
||||
perror(filename);
|
||||
@ -458,8 +458,8 @@ void parse_special_casing(CCInfo *tab, const char *filename)
|
||||
if (*p != '#' && *p != '\0')
|
||||
continue;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
p = get_field(line, 1);
|
||||
if (p && *p != ';') {
|
||||
ci->l_len = 0;
|
||||
@ -492,7 +492,7 @@ void parse_special_casing(CCInfo *tab, const char *filename)
|
||||
ci->u_len = 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fclose(f);
|
||||
}
|
||||
|
||||
@ -503,7 +503,7 @@ void parse_case_folding(CCInfo *tab, const char *filename)
|
||||
const char *p;
|
||||
int code, status;
|
||||
CCInfo *ci;
|
||||
|
||||
|
||||
f = fopen(filename, "rb");
|
||||
if (!f) {
|
||||
perror(filename);
|
||||
@ -535,7 +535,7 @@ void parse_case_folding(CCInfo *tab, const char *filename)
|
||||
status = *p;
|
||||
if (status != 'C' && status != 'S' && status != 'F')
|
||||
continue;
|
||||
|
||||
|
||||
p = get_field(line, 2);
|
||||
assert(p != NULL);
|
||||
if (status == 'S') {
|
||||
@ -555,7 +555,7 @@ void parse_case_folding(CCInfo *tab, const char *filename)
|
||||
ci->f_data[ci->f_len++] = strtoul(p, (char **)&p, 16);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fclose(f);
|
||||
}
|
||||
|
||||
@ -564,7 +564,7 @@ void parse_composition_exclusions(const char *filename)
|
||||
FILE *f;
|
||||
char line[4096], *p;
|
||||
uint32_t c0;
|
||||
|
||||
|
||||
f = fopen(filename, "rb");
|
||||
if (!f) {
|
||||
perror(filename);
|
||||
@ -592,7 +592,7 @@ void parse_derived_core_properties(const char *filename)
|
||||
char line[4096], *p, buf[256], *q;
|
||||
uint32_t c0, c1, c;
|
||||
int i;
|
||||
|
||||
|
||||
f = fopen(filename, "rb");
|
||||
if (!f) {
|
||||
perror(filename);
|
||||
@ -648,7 +648,7 @@ void parse_derived_norm_properties(const char *filename)
|
||||
FILE *f;
|
||||
char line[4096], *p, buf[256], *q;
|
||||
uint32_t c0, c1, c;
|
||||
|
||||
|
||||
f = fopen(filename, "rb");
|
||||
if (!f) {
|
||||
perror(filename);
|
||||
@ -698,7 +698,7 @@ void parse_prop_list(const char *filename)
|
||||
char line[4096], *p, buf[256], *q;
|
||||
uint32_t c0, c1, c;
|
||||
int i;
|
||||
|
||||
|
||||
f = fopen(filename, "rb");
|
||||
if (!f) {
|
||||
perror(filename);
|
||||
@ -752,7 +752,7 @@ void parse_scripts(const char *filename)
|
||||
char line[4096], *p, buf[256], *q;
|
||||
uint32_t c0, c1, c;
|
||||
int i;
|
||||
|
||||
|
||||
f = fopen(filename, "rb");
|
||||
if (!f) {
|
||||
perror(filename);
|
||||
@ -807,7 +807,7 @@ void parse_script_extensions(const char *filename)
|
||||
int i;
|
||||
uint8_t script_ext[255];
|
||||
int script_ext_len;
|
||||
|
||||
|
||||
f = fopen(filename, "rb");
|
||||
if (!f) {
|
||||
perror(filename);
|
||||
@ -972,7 +972,7 @@ void find_run_type(TableEntry *te, CCInfo *tab, int code)
|
||||
ci1 = &tab[code + 1];
|
||||
ci2 = &tab[code + 2];
|
||||
te->code = code;
|
||||
|
||||
|
||||
if (ci->l_len == 1 && ci->l_data[0] == code + 2 &&
|
||||
ci->f_len == 1 && ci->f_data[0] == ci->l_data[0] &&
|
||||
ci->u_len == 0 &&
|
||||
@ -1140,7 +1140,7 @@ void find_run_type(TableEntry *te, CCInfo *tab, int code)
|
||||
te->data = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
ci = &tab[code];
|
||||
is_lower = ci->l_len > 0;
|
||||
len = 1;
|
||||
@ -1221,7 +1221,7 @@ void build_conv_table(CCInfo *tab)
|
||||
int code, i, j;
|
||||
CCInfo *ci;
|
||||
TableEntry *te;
|
||||
|
||||
|
||||
te = conv_table;
|
||||
for(code = 0; code <= CHARCODE_MAX; code++) {
|
||||
ci = &tab[code];
|
||||
@ -1245,7 +1245,7 @@ void build_conv_table(CCInfo *tab)
|
||||
for(i = 0; i < conv_table_len; i++) {
|
||||
int data_index;
|
||||
te = &conv_table[i];
|
||||
|
||||
|
||||
switch(te->type) {
|
||||
case RUN_TYPE_U:
|
||||
case RUN_TYPE_L:
|
||||
@ -1374,7 +1374,7 @@ static int sp_cc_cmp(const void *p1, const void *p2)
|
||||
return memcmp(c1->f_data, c2->f_data, sizeof(c1->f_data[0]) * c1->f_len);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* dump the case special cases (multi character results which are
|
||||
identical and need specific handling in lre_canonicalize() */
|
||||
void dump_case_folding_special_cases(CCInfo *tab)
|
||||
@ -1394,7 +1394,7 @@ void dump_case_folding_special_cases(CCInfo *tab)
|
||||
len = 1;
|
||||
while ((i + len) <= CHARCODE_MAX && !sp_cc_cmp(&perm[i], &perm[i + len]))
|
||||
len++;
|
||||
|
||||
|
||||
if (len > 1) {
|
||||
for(j = i; j < i + len; j++)
|
||||
dump_cc_info(&tab[perm[j]], perm[j]);
|
||||
@ -1405,7 +1405,7 @@ void dump_case_folding_special_cases(CCInfo *tab)
|
||||
free(perm);
|
||||
global_tab = NULL;
|
||||
}
|
||||
|
||||
|
||||
|
||||
int tabcmp(const int *tab1, const int *tab2, int n)
|
||||
{
|
||||
@ -1490,7 +1490,7 @@ void build_prop_table(FILE *f, int prop_index, BOOL add_index)
|
||||
const uint32_t *buf;
|
||||
int buf_len, block_end_pos, bit;
|
||||
char cname[128];
|
||||
|
||||
|
||||
dbuf_init(dbuf1);
|
||||
|
||||
for(i = 0; i <= CHARCODE_MAX;) {
|
||||
@ -1506,15 +1506,15 @@ void build_prop_table(FILE *f, int prop_index, BOOL add_index)
|
||||
dbuf_put_u32(dbuf1, n - 1);
|
||||
i += n;
|
||||
}
|
||||
|
||||
|
||||
dbuf_init(dbuf);
|
||||
dbuf_init(dbuf2);
|
||||
buf = (uint32_t *)dbuf1->buf;
|
||||
buf_len = dbuf1->size / sizeof(buf[0]);
|
||||
|
||||
|
||||
/* the first value is assumed to be 0 */
|
||||
assert(get_prop(0, prop_index) == 0);
|
||||
|
||||
|
||||
block_end_pos = PROP_BLOCK_LEN;
|
||||
i = 0;
|
||||
code = 0;
|
||||
@ -1575,7 +1575,7 @@ void build_prop_table(FILE *f, int prop_index, BOOL add_index)
|
||||
snprintf(cname, sizeof(cname), "unicode_prop_%s_index", unicode_prop_name[prop_index]);
|
||||
dump_byte_table(f, cname, dbuf2->buf, dbuf2->size);
|
||||
}
|
||||
|
||||
|
||||
dbuf_free(dbuf);
|
||||
dbuf_free(dbuf1);
|
||||
dbuf_free(dbuf2);
|
||||
@ -1690,7 +1690,7 @@ void build_general_category_table(FILE *f)
|
||||
printf(" %d", cw_len_count[i]);
|
||||
printf(" ], length=%d bytes\n", (int)dbuf->size);
|
||||
#endif
|
||||
|
||||
|
||||
dump_byte_table(f, "unicode_gc_table", dbuf->buf, dbuf->size);
|
||||
|
||||
dbuf_free(dbuf);
|
||||
@ -1760,7 +1760,7 @@ void build_script_table(FILE *f)
|
||||
printf(" %d", cw_len_count[i]);
|
||||
printf(" ], length=%d bytes\n", (int)dbuf->size);
|
||||
#endif
|
||||
|
||||
|
||||
dump_byte_table(f, "unicode_script_table", dbuf->buf, dbuf->size);
|
||||
|
||||
dbuf_free(dbuf);
|
||||
@ -1810,7 +1810,7 @@ void build_script_ext_table(FILE *f)
|
||||
cw_count);
|
||||
printf(", length=%d bytes\n", (int)dbuf->size);
|
||||
#endif
|
||||
|
||||
|
||||
dump_byte_table(f, "unicode_script_ext_table", dbuf->buf, dbuf->size);
|
||||
|
||||
dbuf_free(dbuf);
|
||||
@ -1822,7 +1822,7 @@ void build_script_ext_table(FILE *f)
|
||||
void build_prop_list_table(FILE *f)
|
||||
{
|
||||
int i;
|
||||
|
||||
|
||||
for(i = 0; i < PROP_TABLE_COUNT; i++) {
|
||||
if (i == PROP_ID_Start ||
|
||||
i == PROP_Case_Ignorable ||
|
||||
@ -1832,7 +1832,7 @@ void build_prop_list_table(FILE *f)
|
||||
build_prop_table(f, i, FALSE);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
fprintf(f, "typedef enum {\n");
|
||||
for(i = 0; i < PROP_COUNT; i++)
|
||||
fprintf(f, " UNICODE_PROP_%s,\n", unicode_prop_name[i]);
|
||||
@ -1870,7 +1870,7 @@ void check_case_conv(void)
|
||||
int l, error;
|
||||
CCInfo ci_s, *ci1, *ci = &ci_s;
|
||||
int code;
|
||||
|
||||
|
||||
for(code = 0; code <= CHARCODE_MAX; code++) {
|
||||
ci1 = &tab[code];
|
||||
*ci = *ci1;
|
||||
@ -1986,7 +1986,7 @@ void build_cc_table(FILE *f)
|
||||
DynBuf dbuf1_s, *dbuf1 = &dbuf1_s;
|
||||
int cw_len_tab[3], cw_start, block_end_pos;
|
||||
uint32_t v;
|
||||
|
||||
|
||||
dbuf_init(dbuf);
|
||||
dbuf_init(dbuf1);
|
||||
cc_table_len = 0;
|
||||
@ -2058,7 +2058,7 @@ void build_cc_table(FILE *f)
|
||||
dbuf_putc(dbuf1, v);
|
||||
dbuf_putc(dbuf1, v >> 8);
|
||||
dbuf_putc(dbuf1, v >> 16);
|
||||
|
||||
|
||||
dump_byte_table(f, "unicode_cc_table", dbuf->buf, dbuf->size);
|
||||
dump_byte_table(f, "unicode_cc_index", dbuf1->buf, dbuf1->size);
|
||||
|
||||
@ -2163,7 +2163,7 @@ const int decomp_incr_tab[4][4] = {
|
||||
/*
|
||||
entry size:
|
||||
type bits
|
||||
code 18
|
||||
code 18
|
||||
len 7
|
||||
compat 1
|
||||
type 5
|
||||
@ -2272,7 +2272,7 @@ void find_decomp_run(DecompEntry *tab_de, int i)
|
||||
DecompEntry de_s, *de = &de_s;
|
||||
CCInfo *ci, *ci1, *ci2;
|
||||
int l, j, n, len_max;
|
||||
|
||||
|
||||
ci = &unicode_db[i];
|
||||
l = ci->decomp_len;
|
||||
if (l == 0) {
|
||||
@ -2283,12 +2283,12 @@ void find_decomp_run(DecompEntry *tab_de, int i)
|
||||
/* the offset for the compose table has only 6 bits, so we must
|
||||
limit if it can be used by the compose table */
|
||||
if (!ci->is_compat && !ci->is_excluded && l == 2)
|
||||
len_max = 64;
|
||||
len_max = 64;
|
||||
else
|
||||
len_max = 127;
|
||||
|
||||
|
||||
tab_de[i].cost = 0x7fffffff;
|
||||
|
||||
|
||||
if (!is_16bit(ci->decomp_data, l)) {
|
||||
assert(l <= 2);
|
||||
|
||||
@ -2331,7 +2331,7 @@ void find_decomp_run(DecompEntry *tab_de, int i)
|
||||
if (de->cost < tab_de[i].cost) {
|
||||
tab_de[i] = *de;
|
||||
}
|
||||
|
||||
|
||||
if (!((i + n) <= CHARCODE_MAX && n < len_max))
|
||||
break;
|
||||
ci1 = &unicode_db[i + n];
|
||||
@ -2344,7 +2344,7 @@ void find_decomp_run(DecompEntry *tab_de, int i)
|
||||
n++;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if (l <= 8 || l == 18) {
|
||||
int c_min, c_max, c;
|
||||
c_min = c_max = -1;
|
||||
@ -2415,7 +2415,7 @@ void find_decomp_run(DecompEntry *tab_de, int i)
|
||||
/* check if a single char is increasing */
|
||||
if (l <= 4) {
|
||||
int idx1, idx;
|
||||
|
||||
|
||||
for(idx1 = 1; (idx = decomp_incr_tab[l - 1][idx1]) >= 0; idx1++) {
|
||||
n = 1;
|
||||
for(;;) {
|
||||
@ -2499,7 +2499,7 @@ void find_decomp_run(DecompEntry *tab_de, int i)
|
||||
|
||||
if (l == 2) {
|
||||
BOOL is_16bit;
|
||||
|
||||
|
||||
n = 0;
|
||||
is_16bit = FALSE;
|
||||
for(;;) {
|
||||
@ -2544,7 +2544,7 @@ void add_decomp_data(uint8_t *data_buf, int *pidx, DecompEntry *de)
|
||||
{
|
||||
int i, j, idx, c;
|
||||
CCInfo *ci;
|
||||
|
||||
|
||||
idx = *pidx;
|
||||
de->data_index = idx;
|
||||
if (de->type <= DECOMP_TYPE_C1) {
|
||||
@ -2695,9 +2695,9 @@ void build_decompose_table(FILE *f)
|
||||
int i, array_len, code_max, data_len, count;
|
||||
DecompEntry *tab_de, de_s, *de = &de_s;
|
||||
uint8_t *data_buf;
|
||||
|
||||
|
||||
code_max = CHARCODE_MAX;
|
||||
|
||||
|
||||
tab_de = mallocz((code_max + 2) * sizeof(*tab_de));
|
||||
|
||||
for(i = code_max; i >= 0; i--) {
|
||||
@ -2721,7 +2721,7 @@ void build_decompose_table(FILE *f)
|
||||
/* dump */
|
||||
{
|
||||
int size, size1;
|
||||
|
||||
|
||||
printf("START LEN TYPE L C SIZE\n");
|
||||
size = 0;
|
||||
for(i = 0; i <= code_max; i++) {
|
||||
@ -2735,7 +2735,7 @@ void build_decompose_table(FILE *f)
|
||||
size += size1;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
printf("array_len=%d estimated size=%d bytes actual=%d bytes\n",
|
||||
array_len, size, array_len * 6 + data_len);
|
||||
}
|
||||
@ -2773,7 +2773,7 @@ void build_decompose_table(FILE *f)
|
||||
}
|
||||
}
|
||||
fprintf(f, "\n};\n\n");
|
||||
|
||||
|
||||
fprintf(f, "static const uint8_t unicode_decomp_data[%u] = {",
|
||||
data_len);
|
||||
for(i = 0; i < data_len; i++) {
|
||||
@ -2786,7 +2786,7 @@ void build_decompose_table(FILE *f)
|
||||
build_compose_table(f, tab_de);
|
||||
|
||||
free(data_buf);
|
||||
|
||||
|
||||
free(tab_de);
|
||||
}
|
||||
|
||||
@ -2817,7 +2817,7 @@ static int get_decomp_pos(const DecompEntry *tab_de, int c)
|
||||
{
|
||||
int i, v, k;
|
||||
const DecompEntry *de;
|
||||
|
||||
|
||||
k = 0;
|
||||
for(i = 0; i <= CHARCODE_MAX; i++) {
|
||||
de = &tab_de[i];
|
||||
@ -2840,14 +2840,14 @@ void build_compose_table(FILE *f, const DecompEntry *tab_de)
|
||||
{
|
||||
int i, v, tab_ce_len;
|
||||
ComposeEntry *ce, *tab_ce;
|
||||
|
||||
|
||||
tab_ce = malloc(sizeof(*tab_ce) * COMPOSE_LEN_MAX);
|
||||
tab_ce_len = 0;
|
||||
for(i = 0; i <= CHARCODE_MAX; i++) {
|
||||
CCInfo *ci = &unicode_db[i];
|
||||
if (ci->decomp_len == 2 && !ci->is_compat &&
|
||||
!ci->is_excluded) {
|
||||
assert(tab_ce_len < COMPOSE_LEN_MAX);
|
||||
assert(tab_ce_len < COMPOSE_LEN_MAX);
|
||||
ce = &tab_ce[tab_ce_len++];
|
||||
ce->c[0] = ci->decomp_data[0];
|
||||
ce->c[1] = ci->decomp_data[1];
|
||||
@ -2865,7 +2865,7 @@ void build_compose_table(FILE *f, const DecompEntry *tab_de)
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
fprintf(f, "static const uint16_t unicode_comp_table[%u] = {",
|
||||
tab_ce_len);
|
||||
for(i = 0; i < tab_ce_len; i++) {
|
||||
@ -2880,7 +2880,7 @@ void build_compose_table(FILE *f, const DecompEntry *tab_de)
|
||||
fprintf(f, " 0x%04x,", v);
|
||||
}
|
||||
fprintf(f, "\n};\n\n");
|
||||
|
||||
|
||||
free(tab_ce);
|
||||
}
|
||||
|
||||
@ -2929,7 +2929,7 @@ void check_compose_table(void)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
@ -2969,7 +2969,7 @@ void check_cc_table(void)
|
||||
#ifdef PROFILE
|
||||
{
|
||||
int64_t ti, count;
|
||||
|
||||
|
||||
ti = get_time_ns();
|
||||
count = 0;
|
||||
/* only do it on meaningful chars */
|
||||
@ -2992,7 +2992,7 @@ void normalization_test(const char *filename)
|
||||
int *in_str, *nfc_str, *nfd_str, *nfkc_str, *nfkd_str;
|
||||
int in_len, nfc_len, nfd_len, nfkc_len, nfkd_len;
|
||||
int *buf, buf_len, pos;
|
||||
|
||||
|
||||
f = fopen(filename, "rb");
|
||||
if (!f) {
|
||||
perror(filename);
|
||||
@ -3023,7 +3023,7 @@ void normalization_test(const char *filename)
|
||||
buf_len = unicode_normalize((uint32_t **)&buf, (uint32_t *)in_str, in_len, UNICODE_NFKD, NULL, NULL);
|
||||
check_str("nfkd", pos, in_str, in_len, buf, buf_len, nfkd_str, nfkd_len);
|
||||
free(buf);
|
||||
|
||||
|
||||
buf_len = unicode_normalize((uint32_t **)&buf, (uint32_t *)in_str, in_len, UNICODE_NFC, NULL, NULL);
|
||||
check_str("nfc", pos, in_str, in_len, buf, buf_len, nfc_str, nfc_len);
|
||||
free(buf);
|
||||
@ -3046,7 +3046,7 @@ int main(int argc, char **argv)
|
||||
{
|
||||
const char *unicode_db_path, *outfilename;
|
||||
char filename[1024];
|
||||
|
||||
|
||||
if (argc < 2) {
|
||||
printf("usage: %s unicode_db_path [output_file]\n"
|
||||
"\n"
|
||||
@ -3067,13 +3067,13 @@ int main(int argc, char **argv)
|
||||
|
||||
snprintf(filename, sizeof(filename), "%s/SpecialCasing.txt", unicode_db_path);
|
||||
parse_special_casing(unicode_db, filename);
|
||||
|
||||
|
||||
snprintf(filename, sizeof(filename), "%s/CaseFolding.txt", unicode_db_path);
|
||||
parse_case_folding(unicode_db, filename);
|
||||
|
||||
snprintf(filename, sizeof(filename), "%s/CompositionExclusions.txt", unicode_db_path);
|
||||
parse_composition_exclusions(filename);
|
||||
|
||||
|
||||
snprintf(filename, sizeof(filename), "%s/DerivedCoreProperties.txt", unicode_db_path);
|
||||
parse_derived_core_properties(filename);
|
||||
|
||||
@ -3089,7 +3089,7 @@ int main(int argc, char **argv)
|
||||
snprintf(filename, sizeof(filename), "%s/ScriptExtensions.txt",
|
||||
unicode_db_path);
|
||||
parse_script_extensions(filename);
|
||||
|
||||
|
||||
snprintf(filename, sizeof(filename), "%s/emoji-data.txt",
|
||||
unicode_db_path);
|
||||
parse_prop_list(filename);
|
||||
@ -3098,7 +3098,7 @@ int main(int argc, char **argv)
|
||||
build_conv_table(unicode_db);
|
||||
|
||||
#ifdef DUMP_CASE_FOLDING_SPECIAL_CASES
|
||||
dump_case_folding_special_cases(unicode_db);
|
||||
dump_case_folding_special_cases(unicode_db);
|
||||
#endif
|
||||
|
||||
if (!outfilename) {
|
||||
@ -3117,7 +3117,7 @@ int main(int argc, char **argv)
|
||||
} else
|
||||
{
|
||||
FILE *fo = fopen(outfilename, "wb");
|
||||
|
||||
|
||||
if (!fo) {
|
||||
perror(outfilename);
|
||||
exit(1);
|
||||
|
Loading…
Reference in New Issue
Block a user