Data Structures
struct	duk_re_matcher_ctx

struct	duk_re_compiler_ctx

Macros
#define	DUK_RE_MAX_ATOM_COPIES 1000

#define	DUK_RE_COMPILE_TOKEN_LIMIT 100000000L /* 1e8 */

#define	DUK_RE_EXECUTE_STEPS_LIMIT 1000000000L /* 1e9 */

#define	DUK_REOP_MATCH 1

#define	DUK_REOP_CHAR 2

#define	DUK_REOP_PERIOD 3

#define	DUK_REOP_RANGES 4

#define	DUK_REOP_INVRANGES 5

#define	DUK_REOP_JUMP 6

#define	DUK_REOP_SPLIT1 7

#define	DUK_REOP_SPLIT2 8

#define	DUK_REOP_SQMINIMAL 9

#define	DUK_REOP_SQGREEDY 10

#define	DUK_REOP_SAVE 11

#define	DUK_REOP_WIPERANGE 12

#define	DUK_REOP_LOOKPOS 13

#define	DUK_REOP_LOOKNEG 14

#define	DUK_REOP_BACKREFERENCE 15

#define	DUK_REOP_ASSERT_START 16

#define	DUK_REOP_ASSERT_END 17

#define	DUK_REOP_ASSERT_WORD_BOUNDARY 18

#define	DUK_REOP_ASSERT_NOT_WORD_BOUNDARY 19

#define	DUK_RE_FLAG_GLOBAL (1 << 0)

#define	DUK_RE_FLAG_IGNORE_CASE (1 << 1)

#define	DUK_RE_FLAG_MULTILINE (1 << 2)

Functions
DUK_INTERNAL_DECL void	duk_regexp_compile (duk_hthread *thr)

DUK_INTERNAL_DECL void	duk_regexp_create_instance (duk_hthread *thr)

DUK_INTERNAL_DECL void	duk_regexp_match (duk_hthread *thr)

DUK_INTERNAL_DECL void	duk_regexp_match_force_global (duk_hthread *thr)

Macro Definition Documentation

◆ DUK_RE_COMPILE_TOKEN_LIMIT

#define DUK_RE_COMPILE_TOKEN_LIMIT 100000000L /* 1e8 */

Definition at line 12 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_RE_EXECUTE_STEPS_LIMIT

#define DUK_RE_EXECUTE_STEPS_LIMIT 1000000000L /* 1e9 */

Definition at line 15 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_RE_FLAG_GLOBAL

#define DUK_RE_FLAG_GLOBAL (1 << 0)

Definition at line 39 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_RE_FLAG_IGNORE_CASE

#define DUK_RE_FLAG_IGNORE_CASE (1 << 1)

Definition at line 40 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_RE_FLAG_MULTILINE

#define DUK_RE_FLAG_MULTILINE (1 << 2)

Definition at line 41 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_RE_MAX_ATOM_COPIES

#define DUK_RE_MAX_ATOM_COPIES 1000

Definition at line 9 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_ASSERT_END

#define DUK_REOP_ASSERT_END 17

Definition at line 34 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_ASSERT_NOT_WORD_BOUNDARY

#define DUK_REOP_ASSERT_NOT_WORD_BOUNDARY 19

Definition at line 36 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_ASSERT_START

#define DUK_REOP_ASSERT_START 16

Definition at line 33 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_ASSERT_WORD_BOUNDARY

#define DUK_REOP_ASSERT_WORD_BOUNDARY 18

Definition at line 35 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_BACKREFERENCE

#define DUK_REOP_BACKREFERENCE 15

Definition at line 32 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_CHAR

#define DUK_REOP_CHAR 2

Definition at line 19 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_INVRANGES

#define DUK_REOP_INVRANGES 5

Definition at line 22 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_JUMP

#define DUK_REOP_JUMP 6

Definition at line 23 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_LOOKNEG

#define DUK_REOP_LOOKNEG 14

Definition at line 31 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_LOOKPOS

#define DUK_REOP_LOOKPOS 13

Definition at line 30 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_MATCH

#define DUK_REOP_MATCH 1

Definition at line 18 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_PERIOD

#define DUK_REOP_PERIOD 3

Definition at line 20 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_RANGES

#define DUK_REOP_RANGES 4

Definition at line 21 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_SAVE

#define DUK_REOP_SAVE 11

Definition at line 28 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_SPLIT1

#define DUK_REOP_SPLIT1 7

Definition at line 24 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_SPLIT2

#define DUK_REOP_SPLIT2 8

Definition at line 25 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_SQGREEDY

#define DUK_REOP_SQGREEDY 10

Definition at line 27 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_SQMINIMAL

#define DUK_REOP_SQMINIMAL 9

Definition at line 26 of file duktape-1.5.2/src-separate/duk_regexp.h.

◆ DUK_REOP_WIPERANGE

#define DUK_REOP_WIPERANGE 12

Definition at line 29 of file duktape-1.5.2/src-separate/duk_regexp.h.

Function Documentation

◆ duk_regexp_compile()

DUK_INTERNAL_DECL void duk_regexp_compile ( duk_hthread * thr )

Definition at line 78146 of file duktape-1.5.2/src-noline/duktape.c.

                                                       {
    duk_context *ctx = (duk_context *) thr;
    duk_re_compiler_ctx re_ctx;
    duk_lexer_point lex_point;
    duk_hstring *h_pattern;
    duk_hstring *h_flags;
    duk__re_disjunction_info ign_disj;
 
    DUK_ASSERT(thr != NULL);
    DUK_ASSERT(ctx != NULL);
 
    /*
     *  Args validation
     */
 
    /* TypeError if fails */
    h_pattern = duk_require_hstring(ctx, -2);
    h_flags = duk_require_hstring(ctx, -1);
 
    /*
     *  Create normalized 'source' property (E5 Section 15.10.3).
     */
 
    /* [ ... pattern flags ] */
 
    duk__create_escaped_source(thr, -2);
 
    /* [ ... pattern flags escaped_source ] */
 
    /*
     *  Init compilation context
     */
 
    /* [ ... pattern flags escaped_source buffer ] */
 
    DUK_MEMZERO(&re_ctx, sizeof(re_ctx));
    DUK_LEXER_INITCTX(&re_ctx.lex);  /* duplicate zeroing, expect for (possible) NULL inits */
    re_ctx.thr = thr;
    re_ctx.lex.thr = thr;
    re_ctx.lex.input = DUK_HSTRING_GET_DATA(h_pattern);
    re_ctx.lex.input_length = DUK_HSTRING_GET_BYTELEN(h_pattern);
    re_ctx.lex.token_limit = DUK_RE_COMPILE_TOKEN_LIMIT;
    re_ctx.recursion_limit = DUK_USE_REGEXP_COMPILER_RECLIMIT;
    re_ctx.re_flags = duk__parse_regexp_flags(thr, h_flags);
 
    DUK_BW_INIT_PUSHBUF(thr, &re_ctx.bw, DUK__RE_INITIAL_BUFSIZE);
 
    DUK_DD(DUK_DDPRINT("regexp compiler ctx initialized, flags=0x%08lx, recursion_limit=%ld",
                       (unsigned long) re_ctx.re_flags, (long) re_ctx.recursion_limit));
 
    /*
     *  Init lexer
     */
 
    lex_point.offset = 0;  /* expensive init, just want to fill window */
    lex_point.line = 1;
    DUK_LEXER_SETPOINT(&re_ctx.lex, &lex_point);
 
    /*
     *  Compilation
     */
 
    DUK_DD(DUK_DDPRINT("starting regexp compilation"));
 
    duk__append_u32(&re_ctx, DUK_REOP_SAVE);
    duk__append_u32(&re_ctx, 0);
    duk__parse_disjunction(&re_ctx, 1 /*expect_eof*/, &ign_disj);
    duk__append_u32(&re_ctx, DUK_REOP_SAVE);
    duk__append_u32(&re_ctx, 1);
    duk__append_u32(&re_ctx, DUK_REOP_MATCH);
 
    /*
     *  Check for invalid backreferences; note that it is NOT an error
     *  to back-reference a capture group which has not yet been introduced
     *  in the pattern (as in /\1(foo)/); in fact, the backreference will
     *  always match!  It IS an error to back-reference a capture group
     *  which will never be introduced in the pattern.  Thus, we can check
     *  for such references only after parsing is complete.
     */
 
    if (re_ctx.highest_backref > re_ctx.captures) {
        DUK_ERROR_SYNTAX(thr, DUK_STR_INVALID_BACKREFS);
    }
 
    /*
     *  Emit compiled regexp header: flags, ncaptures
     *  (insertion order inverted on purpose)
     */
 
    duk__insert_u32(&re_ctx, 0, (re_ctx.captures + 1) * 2);
    duk__insert_u32(&re_ctx, 0, re_ctx.re_flags);
 

◆ duk_regexp_create_instance()

DUK_INTERNAL_DECL void duk_regexp_create_instance ( duk_hthread * thr )

Definition at line 78266 of file duktape-1.5.2/src-noline/duktape.c.

                                                               : %!T, escaped source: %!T",
                       (duk_tval *) duk_get_tval(ctx, -1), (duk_tval *) duk_get_tval(ctx, -2)));
}
 
/*
 *  Create a RegExp instance (E5 Section 15.10.7).
 *
 *  Note: the output stack left by duk_regexp_compile() is directly compatible
 *  with the input here.
 *
 *  Input stack:  [ escaped_source bytecode ]  (both as strings)
 *  Output stack: [ RegExp ]
 */
 
DUK_INTERNAL void duk_regexp_create_instance(duk_hthread *thr) {
    duk_context *ctx = (duk_context *) thr;
    duk_hobject *h;
    duk_hstring *h_bc;
    duk_small_int_t re_flags;
 
    /* [ ... escape_source bytecode ] */
 
    h_bc = duk_get_hstring(ctx, -1);
    DUK_ASSERT(h_bc != NULL);
    DUK_ASSERT(DUK_HSTRING_GET_BYTELEN(h_bc) >= 1);          /* always at least the header */
    DUK_ASSERT(DUK_HSTRING_GET_CHARLEN(h_bc) >= 1);
    DUK_ASSERT((duk_small_int_t) DUK_HSTRING_GET_DATA(h_bc)[0] < 0x80);  /* flags always encodes to 1 byte */
    re_flags = (duk_small_int_t) DUK_HSTRING_GET_DATA(h_bc)[0];
 
    /* [ ... escaped_source bytecode ] */
 
    duk_push_object(ctx);
    h = duk_get_hobject(ctx, -1);
    DUK_ASSERT(h != NULL);
    duk_insert(ctx, -3);
 
    /* [ ... regexp_object escaped_source bytecode ] */
 
    DUK_HOBJECT_SET_CLASS_NUMBER(h, DUK_HOBJECT_CLASS_REGEXP);
    DUK_HOBJECT_SET_PROTOTYPE_UPDREF(thr, h, thr->builtins[DUK_BIDX_REGEXP_PROTOTYPE]);
 
    duk_xdef_prop_stridx(ctx, -3, DUK_STRIDX_INT_BYTECODE, DUK_PROPDESC_FLAGS_NONE);
 
    /* [ ... regexp_object escaped_source ] */
 
    duk_xdef_prop_stridx(ctx, -2, DUK_STRIDX_SOURCE, DUK_PROPDESC_FLAGS_NONE);

◆ duk_regexp_match()

DUK_INTERNAL_DECL void duk_regexp_match ( duk_hthread * thr )

Definition at line 79315 of file duktape-1.5.2/src-noline/duktape.c.

◆ duk_regexp_match_force_global()

DUK_INTERNAL_DECL void duk_regexp_match_force_global ( duk_hthread * thr )

Definition at line 79322 of file duktape-1.5.2/src-noline/duktape.c.

Data Structures

Macros

Functions