regexp.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	RECapture
struct	match_state_t
struct	regexp_t

Macros
#define	REG_FOLD   0x01 /* fold uppercase to lowercase */
#define	REG_GLOB   0x02 /* global exec, creates array of matches */
#define	REG_MULTILINE   0x04 /* treat ^ and $ as begin and end of line */
#define	REG_STICKY   0x08 /* only match starting at lastIndex */

Typedefs
typedef struct RECapture	RECapture
typedef struct match_state_t	match_state_t
typedef BYTE	jsbytecode
typedef struct regexp_t	regexp_t

Functions
regexp_t *	regexp_new (void *, heap_pool_t *, const WCHAR *, DWORD, WORD, BOOL) DECLSPEC_HIDDEN
void	regexp_destroy (regexp_t *) DECLSPEC_HIDDEN
HRESULT	regexp_execute (regexp_t *, void *, heap_pool_t *, const WCHAR *, DWORD, match_state_t *) DECLSPEC_HIDDEN
static match_state_t *	alloc_match_state (regexp_t *regexp, heap_pool_t *pool, const WCHAR *pos)

Macro Definition Documentation

REG_FOLD

#define REG_FOLD   0x01 /* fold uppercase to lowercase */

Definition at line 36 of file regexp.h.

REG_GLOB

#define REG_GLOB   0x02 /* global exec, creates array of matches */

Definition at line 37 of file regexp.h.

REG_MULTILINE

#define REG_MULTILINE   0x04 /* treat ^ and $ as begin and end of line */

Definition at line 38 of file regexp.h.

REG_STICKY

#define REG_STICKY   0x08 /* only match starting at lastIndex */

Definition at line 39 of file regexp.h.

Typedef Documentation

jsbytecode

typedef BYTE jsbytecode

Definition at line 54 of file regexp.h.

match_state_t

typedef struct match_state_t match_state_t

RECapture

typedef struct RECapture RECapture

regexp_t

typedef struct regexp_t regexp_t

Function Documentation

alloc_match_state()

static match_state_t * alloc_match_state ( regexp_t *  regexp, heap_pool_t *  pool, const WCHAR *  pos  )

inlinestatic

Definition at line 71 of file regexp.h.

{
    size_t size = offsetof(match_state_t, parens) + regexp->parenCount*sizeof(RECapture);
    match_state_t *ret;
 
    ret = pool ? heap_pool_alloc(pool, size) : heap_alloc(size);
    if(!ret)
        return NULL;
 
    ret->cp = pos;
    return ret;
}

Referenced by RegExp2_Execute(), RegExp2_Test(), regexp_match(), regexp_match_next(), regexp_string_match(), and run_exec().

regexp_destroy()

void regexp_destroy

(

regexp_t *

re

)

Definition at line 3181 of file regexp.c.

{
    if (re->classList) {
        UINT i;
        for (i = 0; i < re->classCount; i++) {
            if (re->classList[i].converted)
                heap_free(re->classList[i].u.bits);
            re->classList[i].u.bits = NULL;
        }
        heap_free(re->classList);
    }
    heap_free(re);
}

regexp_execute()

HRESULT regexp_execute	(	regexp_t *	regexp,
		void *	cx,
		heap_pool_t *	pool,
		const WCHAR *	str,
		DWORD	str_len,
		match_state_t *	result
	)

Definition at line 3140 of file regexp.c.

{
    match_state_t *res;
    REGlobalData gData;
    heap_pool_t *mark = heap_pool_mark(pool);
    const WCHAR *str_beg = result->cp;
    HRESULT hres;
 
    assert(result->cp != NULL);
 
    gData.cpbegin = str;
    gData.cpend = str+str_len;
    gData.start = result->cp-str;
    gData.skipped = 0;
    gData.pool = pool;
 
    hres = InitMatch(regexp, cx, pool, &gData);
    if(FAILED(hres)) {
        WARN("InitMatch failed\n");
        heap_pool_clear(mark);
        return hres;
    }
 
    res = MatchRegExp(&gData, result);
    heap_pool_clear(mark);
    if(!gData.ok) {
        WARN("MatchRegExp failed\n");
        return E_FAIL;
    }
 
    if(!res) {
        result->match_len = 0;
        return S_FALSE;
    }
 
    result->match_len = (result->cp-str_beg) - gData.skipped;
    result->paren_count = regexp->parenCount;
    return S_OK;
}

regexp_new()

regexp_t * regexp_new	(	void *	cx,
		heap_pool_t *	pool,
		const WCHAR *	str,
		DWORD	str_len,
		WORD	flags,
		BOOL	flat
	)

Definition at line 3195 of file regexp.c.

{
    regexp_t *re;
    heap_pool_t *mark;
    CompilerState state;
    size_t resize;
    jsbytecode *endPC;
    UINT i;
    size_t len;
 
    re = NULL;
    mark = heap_pool_mark(pool);
    len = str_len;
 
    state.context = cx;
    state.pool = pool;
    state.cp = str;
    if (!state.cp)
        goto out;
    state.cpbegin = state.cp;
    state.cpend = state.cp + len;
    state.flags = flags;
    state.parenCount = 0;
    state.classCount = 0;
    state.progLength = 0;
    state.treeDepth = 0;
    state.classBitmapsMem = 0;
    for (i = 0; i < CLASS_CACHE_SIZE; i++)
        state.classCache[i].start = NULL;
 
    if (len != 0 && flat) {
        state.result = NewRENode(&state, REOP_FLAT);
        if (!state.result)
            goto out;
        state.result->u.flat.chr = *state.cpbegin;
        state.result->u.flat.length = len;
        state.result->kid = (void *) state.cpbegin;
        /* Flat bytecode: REOP_FLAT compact(string_offset) compact(len). */
        state.progLength += 1 + GetCompactIndexWidth(0)
                          + GetCompactIndexWidth(len);
    } else {
        if (!ParseRegExp(&state))
            goto out;
    }
    resize = offsetof(regexp_t, program) + state.progLength + 1;
    re = heap_alloc(resize);
    if (!re)
        goto out;
 
    assert(state.classBitmapsMem <= CLASS_BITMAPS_MEM_LIMIT);
    re->classCount = state.classCount;
    if (re->classCount) {
        re->classList = heap_alloc(re->classCount * sizeof(RECharSet));
        if (!re->classList) {
            regexp_destroy(re);
            re = NULL;
            goto out;
        }
        for (i = 0; i < re->classCount; i++)
            re->classList[i].converted = FALSE;
    } else {
        re->classList = NULL;
    }
    endPC = EmitREBytecode(&state, re, state.treeDepth, re->program, state.result);
    if (!endPC) {
        regexp_destroy(re);
        re = NULL;
        goto out;
    }
    *endPC++ = REOP_END;
    /*
     * Check whether size was overestimated and shrink using realloc.
     * This is safe since no pointers to newly parsed regexp or its parts
     * besides re exist here.
     */
    if ((size_t)(endPC - re->program) != state.progLength + 1) {
        regexp_t *tmp;
        assert((size_t)(endPC - re->program) < state.progLength + 1);
        resize = offsetof(regexp_t, program) + (endPC - re->program);
        tmp = heap_realloc(re, resize);
        if (tmp)
            re = tmp;
    }
 
    re->flags = flags;
    re->parenCount = state.parenCount;
    re->source = str;
    re->source_len = str_len;
 
out:
    heap_pool_clear(mark);
    return re;
}