/* This file is part of GNU Dico.
Copyright (C) 2008-2024 Sergey Poznyakoff
GNU Dico is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
GNU Dico is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU Dico. If not, see . */
#include
#include
#include
#include
#include
#include
#define PCRE2_CODE_UNIT_WIDTH 8
#include
struct dico_pcre_flag
{
int c;
int flag;
};
static struct dico_pcre_flag flagtab[] = {
{ 'a', PCRE2_ANCHORED }, /* Force pattern anchoring */
{ 'e', PCRE2_EXTENDED }, /* Ignore whitespace and # comments */
{ 'i', PCRE2_CASELESS }, /* Do caseless matching */
{ 'G', PCRE2_UNGREEDY }, /* Invert greediness of quantifiers */
{ 0 },
};
static int
pcre_flag(int c, uint32_t *pflags)
{
struct dico_pcre_flag *p;
for (p = flagtab; p->c; p++) {
if (p->c == c) {
*pflags |= p->flag;
return 0;
} else if (p->c == tolower(c) || p->c == toupper(c)) {
*pflags &= ~p->flag;
return 0;
}
}
return 1;
}
static pcre2_code *
compile_pattern(const char *pattern)
{
uint32_t cflags = PCRE2_UTF|PCRE2_NEWLINE_ANY;
int error;
PCRE2_SIZE length;
PCRE2_SIZE error_offset;
pcre2_code *pre;
/*
* Pcre2 documentation claims that pattern length is measured in code
* points. This, however, doesn't seem to be the case. At least, with
* version 10.35, length is measured in characters.
*/
length = strlen(pattern);
if (pattern[0] == '/') {
char *p;
pattern++;
length--;
p = strrchr(pattern, '/');
if (!p) {
dico_log(L_ERR, 0, _("PCRE missing terminating /: %s"),
pattern - 1);
return NULL;
}
length -= strlen(p);
while (*++p) {
if (pcre_flag(*p, &cflags)) {
dico_log(L_ERR, 0, _("PCRE error: invalid flag %c"), *p);
return NULL;
}
}
}
pre = pcre2_compile((PCRE2_SPTR8)pattern, length, cflags, &error, &error_offset, NULL);
if (!pre) {
char errbuf[120];
switch (pcre2_get_error_message(error, (PCRE2_UCHAR8*)errbuf, sizeof errbuf)) {
case PCRE2_ERROR_NOMEMORY:
default:
break;
case PCRE2_ERROR_BADDATA:
strncpy(errbuf, "bad error code", sizeof(errbuf)-1);
break;
}
dico_log(L_ERR, 0,
_("pcre_compile(\"%s\") failed at offset %lu: %s"),
pattern, error_offset, errbuf);
}
return pre;
}
struct pcre_call_data
{
pcre2_code *code;
pcre2_match_data *md;
};
static int
pcre_sel(int cmd, dico_key_t key, const char *dict_word)
{
int rc = 0;
char const *word = key->word;
struct pcre_call_data *cdata = key->call_data;
switch (cmd) {
case DICO_SELECT_BEGIN:
if ((cdata = calloc(1, sizeof(cdata[0]))) == NULL) {
DICO_LOG_MEMERR();
return 1;
}
if ((cdata->code = compile_pattern(word)) == NULL) {
free(cdata);
return 1;
}
cdata->md = pcre2_match_data_create_from_pattern(cdata->code, NULL);
if (cdata->md == NULL) {
pcre2_code_free(cdata->code);
free(cdata);
return 1;
}
key->call_data = cdata;
break;
case DICO_SELECT_RUN:
rc = pcre2_match(cdata->code,
(PCRE2_SPTR8)dict_word, PCRE2_ZERO_TERMINATED,
0, 0, cdata->md, NULL) >= 0;
break;
case DICO_SELECT_END:
pcre2_match_data_free(cdata->md);
pcre2_code_free(cdata->code);
free(cdata);
break;
}
return rc;
}
static struct dico_strategy pcre_strat = {
"pcre",
"Match using Perl-compatible regular expressions",
pcre_sel
};
static int
pcre_init(int argc, char **argv)
{
dico_strategy_add(&pcre_strat);
return 0;
}
struct dico_database_module DICO_EXPORT(pcre, module) = {
DICO_MODULE_VERSION,
DICO_CAPA_NODB,
pcre_init,
};