R_API int r_regex_match (const char *pattern, const char *flags, const char *text) {
int ret;
RRegex rx;
int re_flags = r_regex_flags (flags);
if (r_regex_comp (&rx, pattern, re_flags)) {
eprintf ("FAIL TO COMPILE %s\n", pattern);
return 0;
}
ret = r_regex_exec (&rx, text, 0, 0, re_flags);
if (!ret) {
eprintf ("OK! (%s)\n", text);
if (!strstr (text, "raxq")) {
eprintf ("FALSE POSITIVE with (%s)\n", pattern);
}
}
r_regex_fini (&rx);
return ret? 0: 1;
#if 0
regex_t preg;
regmatch_t pmatch[NUM_MATCHES];
if (regcomp(&preg, reg, REG_EXTENDED))
return -1;
return (regexec (&preg, str, NUM_MATCHES, pmatch, 0))?1:0;
#endif
}
R_API int r_regex_match (const char *pattern, const char *flags, const char *text) {
int ret;
RRegex rx;
if (r_regex_comp (&rx, pattern, r_regex_flags (flags)))
return -1;
ret = r_regex_exec (&rx, text, 0, 0, 0);
r_regex_fini (&rx);
return ret? 0: 1;
#if 0
regex_t preg;
regmatch_t pmatch[NUM_MATCHES];
if (regcomp(&preg, reg, REG_EXTENDED))
return -1;
return (regexec (&preg, str, NUM_MATCHES, pmatch, 0))?1:0;
#endif
}
static int check_fmt(RMagic *ms, struct r_magic *m) {
RRegex rx;
int rc;
if (strchr (R_MAGIC_DESC, '%') == NULL)
return 0;
rc = r_regex_comp (&rx, "%[-0-9\\.]*s", R_REGEX_EXTENDED|R_REGEX_NOSUB);
if (rc) {
char errmsg[512];
r_regex_error (rc, &rx, errmsg, sizeof (errmsg));
file_magerror (ms, "regex error %d, (%s)", rc, errmsg);
return -1;
} else {
rc = r_regex_exec (&rx, R_MAGIC_DESC, 0, 0, 0);
r_regex_fini (&rx);
return !rc;
}
}
/*
- regcomp - interface for parser and compilation
*/
R_API int /* 0 success, otherwise R_REGEX_something */
r_regex_comp(RRegex *preg, const char *pattern, int cflags)
{
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)&~R_REGEX_DUMP)
#endif
cflags = GOODFLAGS(cflags);
if ((cflags&R_REGEX_EXTENDED) && (cflags&R_REGEX_NOSPEC))
return(R_REGEX_INVARG);
if (cflags&R_REGEX_PEND) {
if (preg->re_endp < pattern)
return(R_REGEX_INVARG);
len = preg->re_endp - pattern;
} else
len = strlen((char *)pattern);
/* do the mallocs early so failure handling is easy */
g = (struct re_guts *)malloc(sizeof(struct re_guts) +
(NC-1)*sizeof(cat_t));
if (g == NULL)
return(R_REGEX_ESPACE);
p->ssize = len/(size_t)2*(size_t)3 + (size_t)1; /* ugh */
p->strip = (sop *)calloc(p->ssize, sizeof(sop));
p->slen = 0;
if (p->strip == NULL) {
free((char *)g);
return(R_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&R_REGEX_EXTENDED)
p_ere(p, OUT);
else if (cflags&R_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 assert() in regexec() */
if (g->iflags&BAD)
SETERROR(R_REGEX_ASSERT);
#endif
/* win or lose, we're done */
if (p->error != 0) /* lose */
r_regex_fini(preg);
return(p->error);
}
R_API void r_regex_free(RRegex *preg) {
r_regex_fini (preg);
free (preg);
}
