rz_regex.h File Reference

#include <rz_types.h>
#include <rz_list.h>
#include <sys/types.h>

Go to the source code of this file.

Classes
struct	rz_regex_t
struct	rz_regmatch_t

Macros
#define	RZ_REGEX_BASIC   0000
#define	RZ_REGEX_EXTENDED   0001
#define	RZ_REGEX_ICASE   0002
#define	RZ_REGEX_NOSUB   0004
#define	RZ_REGEX_NEWLINE   0010
#define	RZ_REGEX_NOSPEC   0020
#define	RZ_REGEX_PEND   0040
#define	RZ_REGEX_DUMP   0200
#define	RZ_REGEX_ENOSYS   (-1) /* Reserved */
#define	RZ_REGEX_NOMATCH   1
#define	RZ_REGEX_BADPAT   2
#define	RZ_REGEX_ECOLLATE   3
#define	RZ_REGEX_ECTYPE   4
#define	RZ_REGEX_EESCAPE   5
#define	RZ_REGEX_ESUBREG   6
#define	RZ_REGEX_EBRACK   7
#define	RZ_REGEX_EPAREN   8
#define	RZ_REGEX_EBRACE   9
#define	RZ_REGEX_BADBR   10
#define	RZ_REGEX_ERANGE   11
#define	RZ_REGEX_ESPACE   12
#define	RZ_REGEX_BADRPT   13
#define	RZ_REGEX_EMPTY   14
#define	RZ_REGEX_ASSERT   15
#define	RZ_REGEX_INVARG   16
#define	RZ_REGEX_ILLSEQ   17
#define	RZ_REGEX_ATOI   255 /* convert name to number (!) */
#define	RZ_REGEX_ITOA   0400 /* convert number to name (!) */
#define	RZ_REGEX_NOTBOL   00001
#define	RZ_REGEX_NOTEOL   00002
#define	RZ_REGEX_STARTEND   00004
#define	RZ_REGEX_TRACE   00400 /* tracing of execution */
#define	RZ_REGEX_LARGE   01000 /* force large representation */
#define	RZ_REGEX_BACKR   02000 /* force use of backref code */

Typedefs
typedef struct rz_regex_t	RzRegex
typedef struct rz_regmatch_t	RzRegexMatch

Functions
RZ_API RzRegex *	rz_regex_new (const char *pattern, const char *cflags)
RZ_API int	rz_regex_match (const char *pattern, const char *flags, const char *text)
RZ_API RzList *	rz_regex_get_match_list (const char *pattern, const char *flags, const char *text)
RZ_API int	rz_regex_flags (const char *flags)
RZ_API int	rz_regex_comp (RzRegex *, const char *, int)
RZ_API size_t	rz_regex_error (int, const RzRegex *, char *, size_t)
RZ_API bool	rz_regex_check (const RzRegex *rr, const char *str)
RZ_API int	rz_regex_exec (const RzRegex *preg, const char *string, size_t nmatch, RzRegexMatch __pmatch[], int eflags)
RZ_API void	rz_regex_free (RzRegex *)
RZ_API void	rz_regex_fini (RzRegex *)

Macro Definition Documentation

RZ_REGEX_ASSERT

#define RZ_REGEX_ASSERT   15

Definition at line 47 of file rz_regex.h.

RZ_REGEX_ATOI

#define RZ_REGEX_ATOI   255 /* convert name to number (!) */

Definition at line 50 of file rz_regex.h.

RZ_REGEX_BACKR

#define RZ_REGEX_BACKR   02000 /* force use of backref code */

Definition at line 59 of file rz_regex.h.

RZ_REGEX_BADBR

#define RZ_REGEX_BADBR   10

Definition at line 42 of file rz_regex.h.

RZ_REGEX_BADPAT

#define RZ_REGEX_BADPAT   2

Definition at line 34 of file rz_regex.h.

RZ_REGEX_BADRPT

#define RZ_REGEX_BADRPT   13

Definition at line 45 of file rz_regex.h.

RZ_REGEX_BASIC

#define RZ_REGEX_BASIC   0000

Definition at line 22 of file rz_regex.h.

RZ_REGEX_DUMP

#define RZ_REGEX_DUMP   0200

Definition at line 29 of file rz_regex.h.

RZ_REGEX_EBRACE

#define RZ_REGEX_EBRACE   9

Definition at line 41 of file rz_regex.h.

RZ_REGEX_EBRACK

#define RZ_REGEX_EBRACK   7

Definition at line 39 of file rz_regex.h.

RZ_REGEX_ECOLLATE

#define RZ_REGEX_ECOLLATE   3

Definition at line 35 of file rz_regex.h.

RZ_REGEX_ECTYPE

#define RZ_REGEX_ECTYPE   4

Definition at line 36 of file rz_regex.h.

RZ_REGEX_EESCAPE

#define RZ_REGEX_EESCAPE   5

Definition at line 37 of file rz_regex.h.

RZ_REGEX_EMPTY

#define RZ_REGEX_EMPTY   14

Definition at line 46 of file rz_regex.h.

RZ_REGEX_ENOSYS

#define RZ_REGEX_ENOSYS   (-1) /* Reserved */

Definition at line 32 of file rz_regex.h.

RZ_REGEX_EPAREN

#define RZ_REGEX_EPAREN   8

Definition at line 40 of file rz_regex.h.

RZ_REGEX_ERANGE

#define RZ_REGEX_ERANGE   11

Definition at line 43 of file rz_regex.h.

RZ_REGEX_ESPACE

#define RZ_REGEX_ESPACE   12

Definition at line 44 of file rz_regex.h.

RZ_REGEX_ESUBREG

#define RZ_REGEX_ESUBREG   6

Definition at line 38 of file rz_regex.h.

RZ_REGEX_EXTENDED

#define RZ_REGEX_EXTENDED   0001

Definition at line 23 of file rz_regex.h.

RZ_REGEX_ICASE

#define RZ_REGEX_ICASE   0002

Definition at line 24 of file rz_regex.h.

RZ_REGEX_ILLSEQ

#define RZ_REGEX_ILLSEQ   17

Definition at line 49 of file rz_regex.h.

RZ_REGEX_INVARG

#define RZ_REGEX_INVARG   16

Definition at line 48 of file rz_regex.h.

RZ_REGEX_ITOA

#define RZ_REGEX_ITOA   0400 /* convert number to name (!) */

Definition at line 51 of file rz_regex.h.

RZ_REGEX_LARGE

#define RZ_REGEX_LARGE   01000 /* force large representation */

Definition at line 58 of file rz_regex.h.

RZ_REGEX_NEWLINE

#define RZ_REGEX_NEWLINE   0010

Definition at line 26 of file rz_regex.h.

RZ_REGEX_NOMATCH

#define RZ_REGEX_NOMATCH   1

Definition at line 33 of file rz_regex.h.

RZ_REGEX_NOSPEC

#define RZ_REGEX_NOSPEC   0020

Definition at line 27 of file rz_regex.h.

RZ_REGEX_NOSUB

#define RZ_REGEX_NOSUB   0004

Definition at line 25 of file rz_regex.h.

RZ_REGEX_NOTBOL

#define RZ_REGEX_NOTBOL   00001

Definition at line 54 of file rz_regex.h.

RZ_REGEX_NOTEOL

#define RZ_REGEX_NOTEOL   00002

Definition at line 55 of file rz_regex.h.

RZ_REGEX_PEND

#define RZ_REGEX_PEND   0040

Definition at line 28 of file rz_regex.h.

RZ_REGEX_STARTEND

#define RZ_REGEX_STARTEND   00004

Definition at line 56 of file rz_regex.h.

RZ_REGEX_TRACE

#define RZ_REGEX_TRACE   00400 /* tracing of execution */

Definition at line 57 of file rz_regex.h.

Typedef Documentation

RzRegex

typedef struct rz_regex_t RzRegex

RzRegexMatch

typedef struct rz_regmatch_t RzRegexMatch

Function Documentation

rz_regex_check()

RZ_API bool rz_regex_check	(	const RzRegex *	rr,
		const char *	str
	)

Definition at line 138 of file regexec.c.

                                                               {
    return rz_regex_exec(rr, str, 0, NULL, rr->re_flags);
}

References NULL, rz_regex_t::re_flags, rz_regex_exec(), and cmd_descs_generate::str.

Referenced by test_or().

rz_regex_comp()

RZ_API int rz_regex_comp	(	RzRegex *	preg,
		const char *	pattern,
		int	cflags
	)

Definition at line 258 of file regcomp.c.

                                                                         {
    struct parse pa;
    struct re_guts *g;
    struct parse *p = &pa;
    int i;
    size_t len;
#ifdef REDEBUG
#define GOODFLAGS(f) (f)
#else
#define GOODFLAGS(f) ((f) & ~RZ_REGEX_DUMP)
#endif
    cflags = GOODFLAGS(cflags);
    if (!preg || ((cflags & RZ_REGEX_EXTENDED) && (cflags & RZ_REGEX_NOSPEC))) {
        return RZ_REGEX_INVARG;
    }
    if (cflags & RZ_REGEX_PEND) {
        if (preg->re_endp < pattern) {
            return RZ_REGEX_INVARG;
        }
        len = preg->re_endp - pattern;
    } else {
        len = strlen((char *)pattern);
    }
    /* do the mallocs early so failure handling is easy */
    g = calloc(1, sizeof(struct re_guts) + (NC - 1));
    if (!g) {
        return RZ_REGEX_ESPACE;
    }
    /*
     * Limit the pattern space to avoid a 32-bit overflow on buffer
     * extension.  Also avoid any signed overflow in case of conversion
     * so make the real limit based on a 31-bit overflow.
     *
     * Likely not applicable on 64-bit systems but handle the case
     * generically (who are we to stop people from using ~715MB+
     * patterns?).
     */
    size_t maxlen = ((size_t)-1 >> 1) / sizeof(sop) * 2 / 3;
    if (len >= maxlen) {
        free(g);
        return RZ_REGEX_ESPACE;
    }
    preg->re_flags = cflags;
    p->ssize = len / (size_t)2 * (size_t)3 + (size_t)1; /* ugh */
    if (p->ssize < len) {
        free(g);
        return RZ_REGEX_ESPACE;
    }
 
    p->strip = (sop *)calloc(p->ssize, sizeof(sop));
    if (!p->strip) {
        free(g);
        return RZ_REGEX_ESPACE;
    }
    p->slen = 0;
    if (!p->strip) {
        free(g);
        return RZ_REGEX_ESPACE;
    }
 
    /* set things up */
    p->g = g;
    p->next = (char *)pattern; /* convenience; we do not modify it */
    p->end = p->next + len;
    p->error = 0;
    p->ncsalloc = 0;
    for (i = 0; i < NPAREN; i++) {
        p->pbegin[i] = 0;
        p->pend[i] = 0;
    }
    g->csetsize = NC;
    g->sets = NULL;
    g->setbits = NULL;
    g->ncsets = 0;
    g->cflags = cflags;
    g->iflags = 0;
    g->nbol = 0;
    g->neol = 0;
    g->must = NULL;
    g->mlen = 0;
    g->nsub = 0;
    g->ncategories = 1; /* category 0 is "everything else" */
    g->categories = &g->catspace[-(CHAR_MIN)];
    (void)memset((char *)g->catspace, 0, NC * sizeof(cat_t));
    g->backrefs = 0;
 
    /* do it */
    EMIT(OEND, 0);
    g->firststate = THERE();
    if (cflags & RZ_REGEX_EXTENDED) {
        p_ere(p, OUT);
    } else if (cflags & RZ_REGEX_NOSPEC) {
        p_str(p);
    } else {
        p_bre(p, OUT, OUT);
    }
    EMIT(OEND, 0);
    g->laststate = THERE();
 
    /* tidy up loose ends and fill things in */
    categorize(p, g);
    stripsnug(p, g);
    findmust(p, g);
    g->nplus = pluscount(p, g);
    g->magic = MAGIC2;
    preg->re_nsub = g->nsub;
    preg->re_g = g;
    preg->re_magic = MAGIC1;
#ifndef REDEBUG
    /* not debugging, so can't rely on the asssert() in regexec() */
    if (g->iflags & BAD) {
        SETERROR(RZ_REGEX_ASSERT);
    }
#endif
    if (p->error) {
        rz_regex_fini(preg);
    }
    return p->error;
}

References BAD, calloc(), categorize(), EMIT, findmust(), free(), g, GOODFLAGS, i, len, MAGIC1, MAGIC2, maxlen, memset(), NC, NPAREN, NULL, OEND, OUT, p, p_bre(), p_ere(), p_str(), pluscount(), rz_regex_t::re_endp, rz_regex_t::re_flags, rz_regex_t::re_g, rz_regex_t::re_magic, rz_regex_t::re_nsub, RZ_REGEX_ASSERT, RZ_REGEX_ESPACE, RZ_REGEX_EXTENDED, rz_regex_fini(), RZ_REGEX_INVARG, RZ_REGEX_NOSPEC, RZ_REGEX_PEND, SETERROR, stripsnug(), and THERE.

Referenced by _main(), check_fmt(), magiccheck(), rz_regex_get_match_list(), rz_regex_match(), rz_regex_new(), and rz_search_regexp_update().

rz_regex_error()

RZ_API size_t rz_regex_error	(	int	errcode,
		const RzRegex *	preg,
		char *	errbuf,
		size_t	errbuf_size
	)

Definition at line 78 of file regerror.c.

                                                                                                 {
    struct rerr *r;
    size_t len;
    int target = errcode & ~RZ_REGEX_ITOA;
    char *s;
    char convbuf[50];
 
    if (errcode == RZ_REGEX_ATOI) {
        s = regatoi(preg, convbuf, sizeof convbuf);
    } else {
        for (r = rerrs; r->code != 0; r++) {
            if (r->code == target) {
                break;
            }
        }
 
        if (errcode & RZ_REGEX_ITOA) {
            if (r->code != 0) {
                STRLCPY(convbuf, r->name, sizeof(convbuf) - 1);
            } else {
                snprintf(convbuf, sizeof convbuf, "RZ_REGEX_0x%x", target);
            }
            s = convbuf;
        } else {
            s = r->explain;
        }
    }
 
    len = strlen(s) + 1;
    if (errbuf_size > 0) {
        STRLCPY(errbuf, s, errbuf_size - 1);
    }
 
    return len;
}

References len, r, regatoi(), rerrs, RZ_REGEX_ATOI, RZ_REGEX_ITOA, s, snprintf, and STRLCPY.

Referenced by check_fmt(), and magiccheck().

rz_regex_exec()

RZ_API int rz_regex_exec	(	const RzRegex *	preg,
		const char *	string,
		size_t	nmatch,
		RzRegexMatch	__pmatch[],
		int	eflags
	)

Definition at line 149 of file regexec.c.

                                       {
    struct re_guts *g;
#ifdef REDEBUG
#define GOODFLAGS(f) (f)
#else
#define GOODFLAGS(f) ((f) & (RZ_REGEX_NOTBOL | RZ_REGEX_NOTEOL | RZ_REGEX_STARTEND | RZ_REGEX_LARGE))
#endif
    if (!preg || !string) {
        return RZ_REGEX_ASSERT;
    }
 
    g = preg->re_g;
    if (preg->re_magic != MAGIC1 || g->magic != MAGIC2) {
        return (RZ_REGEX_BADPAT);
    }
    if (g->iflags & BAD) { /* backstop for no-debug case */
        return (RZ_REGEX_BADPAT);
    }
    eflags = GOODFLAGS(eflags);
    if (g->nstates <= CHAR_BIT * sizeof(states1) && !(eflags & RZ_REGEX_LARGE)) {
        return (smatcher(g, (char *)string, nmatch, pmatch, eflags));
    } else {
        return (lmatcher(g, (char *)string, nmatch, pmatch, eflags));
    }
}

References BAD, CHAR_BIT, g, GOODFLAGS, MAGIC1, MAGIC2, rz_regex_t::re_g, rz_regex_t::re_magic, RZ_REGEX_ASSERT, RZ_REGEX_BADPAT, RZ_REGEX_LARGE, and states1.

Referenced by _main(), check_fmt(), find_e_opts(), magiccheck(), main(), pager_all_matches(), rz_asm_tokenize_asm_regex(), rz_core_asm_strsearch(), rz_regex_check(), rz_regex_get_match_list(), rz_regex_match(), rz_search_regexp_update(), str_split_list_common_regex(), and test_or().

rz_regex_fini()

RZ_API void rz_regex_fini

(

RzRegex *

preg

)

Definition at line 226 of file regcomp.c.

                                         {
    struct re_guts *g;
    if (!preg) {
        return;
    }
    if (preg->re_magic != MAGIC1) { /* oops */
        return; /* nice to complain, but hard */
    }
 
    g = preg->re_g;
    if (!g || g->magic != MAGIC2) { /* oops again */
        return;
    }
    preg->re_magic = 0; /* mark it invalid */
    g->magic = 0; /* mark it invalid */
 
    free(g->strip);
    free(g->sets);
    free(g->setbits);
    free(g->must);
    free(g);
}

References free(), g, MAGIC1, MAGIC2, rz_regex_t::re_g, and rz_regex_t::re_magic.

Referenced by check_fmt(), magiccheck(), rz_regex_comp(), rz_regex_free(), rz_regex_get_match_list(), rz_regex_match(), and rz_search_regexp_update().

rz_regex_flags()

RZ_API int rz_regex_flags

(

const char *

flags

)

Definition at line 197 of file regcomp.c.

                                         {
    int flags = 0;
    if (!f || !*f) {
        return 0;
    }
    if (strchr(f, 'e')) {
        flags |= RZ_REGEX_EXTENDED;
    }
    if (strchr(f, 'i')) {
        flags |= RZ_REGEX_ICASE;
    }
    if (strchr(f, 's')) {
        flags |= RZ_REGEX_NOSUB;
    }
    if (strchr(f, 'n')) {
        flags |= RZ_REGEX_NEWLINE;
    }
    if (strchr(f, 'N')) {
        flags |= RZ_REGEX_NOSPEC;
    }
    if (strchr(f, 'p')) {
        flags |= RZ_REGEX_PEND;
    }
    if (strchr(f, 'd')) {
        flags |= RZ_REGEX_DUMP;
    }
    return flags;
}

References f, flags, RZ_REGEX_DUMP, RZ_REGEX_EXTENDED, RZ_REGEX_ICASE, RZ_REGEX_NEWLINE, RZ_REGEX_NOSPEC, RZ_REGEX_NOSUB, and RZ_REGEX_PEND.

Referenced by rz_regex_get_match_list(), rz_regex_match(), and rz_regex_new().

rz_regex_free()

RZ_API void rz_regex_free

(

RzRegex *

preg

)

Definition at line 249 of file regcomp.c.

                                         {
    rz_regex_fini(preg);
    free(preg);
}

References free(), and rz_regex_fini().

Referenced by _main(), find_e_opts(), main(), rz_asm_token_pattern_free(), rz_cons_less_str(), rz_core_asm_strsearch(), rz_str_split_duplist_n_regex(), rz_str_split_list_regex(), and test_or().

rz_regex_get_match_list()

RZ_API RzList* rz_regex_get_match_list	(	const char *	pattern,
		const char *	flags,
		const char *	text
	)

Definition at line 155 of file regcomp.c.

                                                                                                 {
    RzList *list = rz_list_newf(free);
    RzRegex rx;
    RzRegexMatch match;
    char *entry;
    size_t entry_len = 0;
    int re_flags = rz_regex_flags(flags);
    if (rz_regex_comp(&rx, pattern, re_flags)) {
        eprintf("Failed to compile regexp: %s\n", pattern);
        return NULL;
    }
 
    /* Initialize the boundaries for RZ_REGEX_STARTEND */
    match.rm_so = 0;
    match.rm_eo = strlen(text);
    while (!rz_regex_exec(&rx, text, 1, &match, re_flags | RZ_REGEX_STARTEND)) {
        entry_len = match.rm_eo - match.rm_so + 1;
        entry = RZ_NEWS0(char, entry_len);
        rz_str_ncpy(entry, text + match.rm_so, entry_len);
        rz_list_append(list, entry);
        /* Update the boundaries for RZ_REGEX_STARTEND */
        match.rm_so = match.rm_eo;
        match.rm_eo = strlen(text);
    }
    rz_regex_fini(&rx);
    return list;
}

References eprintf, flags, free(), list(), match, NULL, rz_list_append(), rz_list_newf(), RZ_NEWS0, rz_regex_comp(), rz_regex_exec(), rz_regex_fini(), rz_regex_flags(), RZ_REGEX_STARTEND, rz_str_ncpy(), and create_tags_rz::text.

Referenced by print_diff(), and rz_test_cmp_cmd_output().

rz_regex_match()

RZ_API int rz_regex_match	(	const char *	pattern,
		const char *	flags,
		const char *	text
	)

Definition at line 142 of file regcomp.c.

                                                                                    {
    int ret;
    RzRegex rx;
    int re_flags = rz_regex_flags(flags);
    if (rz_regex_comp(&rx, pattern, re_flags)) {
        eprintf("FAIL TO COMPILE %s\n", pattern);
        return 0;
    }
    ret = rz_regex_exec(&rx, text, 0, 0, re_flags);
    rz_regex_fini(&rx);
    return ret ? 0 : 1;
}

References eprintf, flags, rz_regex_comp(), rz_regex_exec(), rz_regex_fini(), rz_regex_flags(), and create_tags_rz::text.

Referenced by classdump_objc(), construct_rop_gadget(), is_lea(), step_until_inst(), and test_or().

rz_regex_new()

RZ_API RzRegex* rz_regex_new	(	const char *	pattern,
		const char *	cflags
	)

Definition at line 183 of file regcomp.c.

                                                                     {
    rz_return_val_if_fail(pattern, NULL);
    RzRegex *r, rx = { 0 };
    if (rz_regex_comp(&rx, pattern, rz_regex_flags(flags))) {
        return NULL;
    }
    r = RZ_NEW(RzRegex);
    if (!r) {
        return NULL;
    }
    memcpy(r, &rx, sizeof(RzRegex));
    return r;
}

References flags, memcpy(), NULL, r, RZ_NEW, rz_regex_comp(), rz_regex_flags(), and rz_return_val_if_fail.

Referenced by find_e_opts(), main(), rz_cons_less_str(), rz_core_asm_strsearch(), rz_str_split_duplist_n_regex(), rz_str_split_list_regex(), and test_or().