#ifndef lint
static char rcsid[] = "$Id: utbm.c,v 1.2 2002/07/15 23:45:17 majka Exp $";
#endif
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include "utbm.h"
typedef struct {
ucs4_t lc;
ucs4_t uc;
ucs4_t tc;
} _utbm_char_t;
typedef struct {
_utbm_char_t *ch;
unsigned long skip;
} _utbm_skip_t;
typedef struct _utbm_pattern_t {
unsigned long flags;
_utbm_char_t *pat;
unsigned long pat_used;
unsigned long pat_size;
unsigned long patlen;
_utbm_skip_t *skip;
unsigned long skip_used;
unsigned long skip_size;
unsigned long md4;
} _utbm_pattern_t;
static unsigned long
_utbm_skip(utbm_pattern_t p, ucs2_t *start, ucs2_t *end)
{
unsigned long i;
ucs4_t c1, c2;
_utbm_skip_t *sp;
if (start >= end)
return 0;
c1 = *start;
c2 = (start + 1 < end) ? *(start + 1) : ~0;
if (0xd800 <= c1 && c1 <= 0xdbff && 0xdc00 <= c2 && c2 <= 0xdfff)
c1 = 0x10000 + (((c1 & 0x03ff) << 10) | (c2 & 0x03ff));
for (i = 0, sp = p->skip; i < p->skip_used; i++, sp++) {
if (!((c1 ^ sp->ch->uc) & (c1 ^ sp->ch->lc) & (c1 ^ sp->ch->tc))) {
return ((unsigned long) (end - start) < sp->skip) ?
end - start : sp->skip;
}
}
return p->patlen;
}
static int
_utbm_match(utbm_pattern_t pat, ucs2_t *text, ucs2_t *start, ucs2_t *end,
unsigned long *match_start, unsigned long *match_end)
{
int check_space;
ucs4_t c1, c2;
unsigned long count;
_utbm_char_t *cp;
*match_end = (start - text) + 1;
c1 = *start;
c2 = (start + 1 < end) ? *(start + 1) : ~0;
if (0xd800 <= c1 && c1 <= 0xdbff && 0xdc00 <= c2 && c2 <= 0xdfff) {
c1 = 0x10000 + (((c1 & 0x03ff) << 10) | (c2 & 0x03ff));
*match_end = *match_end + 1;
}
if (pat->pat_used == 1) {
*match_start = start - text;
return 1;
}
cp = pat->pat + (pat->pat_used - 1);
for (count = pat->patlen; start > text && count > 0;) {
if (pat->flags & UTBM_IGNORE_NONSPACING) {
while (start > text && _utbm_nonspacing(c1)) {
c2 = *--start;
c1 = (start - 1 > text) ? *(start - 1) : ~0;
if (0xdc00 <= c2 && c2 <= 0xdfff &&
0xd800 <= c1 && c1 <= 0xdbff) {
c1 = 0x10000 + (((c1 & 0x03ff) << 10) | (c2 & 0x03ff));
start--;
} else
c1 = c2;
}
}
if (pat->flags & UTBM_SPACE_COMPRESS) {
check_space = 0;
while (start > text &&
(_utbm_isspace(c1, 1) || _utbm_iscntrl(c1))) {
check_space = _utbm_isspace(c1, 1);
c2 = *--start;
c1 = (start - 1 > text) ? *(start - 1) : ~0;
if (0xdc00 <= c2 && c2 <= 0xdfff &&
0xd800 <= c1 && c1 <= 0xdbff) {
c1 = 0x10000 + (((c1 & 0x03ff) << 10) | (c2 & 0x03ff));
start--;
} else
c1 = c2;
}
if (check_space) {
if (cp->uc != ' ')
return 0;
cp--;
count--;
}
}
if (count > 0 && ((c1 ^ cp->uc) & (c1 ^ cp->lc) & (c1 ^ cp->tc)))
return 0;
count -= (c1 >= 0x10000) ? 2 : 1;
if (count > 0) {
cp--;
if (start > text) {
c2 = *--start;
c1 = (start - 1 > text) ? *(start - 1) : ~0;
if (0xdc00 <= c2 && c2 <= 0xdfff &&
0xd800 <= c1 && c1 <= 0xdbff) {
c1 = 0x10000 + (((c1 & 0x03ff) << 10) | (c2 & 0x03ff));
start--;
} else
c1 = c2;
}
}
}
*match_start = start - text;
return 1;
}
utbm_pattern_t
utbm_create_pattern(void)
{
utbm_pattern_t p;
p = (utbm_pattern_t) malloc(sizeof(_utbm_pattern_t));
(void) memset((char *) p, '\0', sizeof(_utbm_pattern_t));
return p;
}
void
utbm_free_pattern(utbm_pattern_t pattern)
{
if (pattern == 0)
return;
if (pattern->pat_size > 0)
free((char *) pattern->pat);
if (pattern->skip_size > 0)
free((char *) pattern->skip);
free((char *) pattern);
}
void
utbm_compile(ucs2_t *pat, unsigned long patlen, unsigned long flags,
utbm_pattern_t p)
{
int have_space;
unsigned long i, j, k, slen;
_utbm_char_t *cp;
_utbm_skip_t *sp;
ucs4_t c1, c2, sentinel;
if (p == 0 || pat == 0 || *pat == 0 || patlen == 0)
return;
p->patlen = p->pat_used = p->skip_used = 0;
p->flags = flags;
p->md4 = 1;
if (patlen > p->pat_size) {
if (p->pat_size == 0) {
p->pat = (_utbm_char_t *) malloc(sizeof(_utbm_char_t) * patlen);
p->skip = (_utbm_skip_t *) malloc(sizeof(_utbm_skip_t) * patlen);
} else {
p->pat = (_utbm_char_t *)
realloc((char *) p->pat, sizeof(_utbm_char_t) * patlen);
p->skip = (_utbm_skip_t *)
realloc((char *) p->skip, sizeof(_utbm_skip_t) * patlen);
}
p->pat_size = p->skip_size = patlen;
}
for (have_space = 0, cp = p->pat, i = 0; i < patlen; i++) {
c1 = pat[i];
c2 = (i + 1 < patlen) ? pat[i + 1] : ~0;
if (0xd800 <= c1 && c1 <= 0xdbff && 0xdc00 <= c2 && c2 <= 0xdfff)
c1 = 0x10000 + (((c1 & 0x03ff) << 10) | (c2 & 0x03ff));
if (!_utbm_isspace(c1, flags & UTBM_SPACE_COMPRESS))
have_space = 0;
if ((flags & UTBM_IGNORE_NONSPACING) && _utbm_nonspacing(c1))
continue;
if (flags & UTBM_SPACE_COMPRESS) {
if (_utbm_isspace(c1, 1)) {
if (!have_space) {
cp->uc = cp->lc = cp->tc = ' ';
cp++;
p->patlen++;
sentinel = ' ';
have_space = 1;
}
continue;
}
if (_utbm_iscntrl(c1))
continue;
}
if (flags & UTBM_CASEFOLD) {
cp->uc = _utbm_toupper(c1);
cp->lc = _utbm_tolower(c1);
cp->tc = _utbm_totitle(c1);
} else
cp->uc = cp->lc = cp->tc = c1;
sentinel = cp->uc;
cp++;
p->patlen += (c1 >= 0x10000) ? 2 : 1;
i += (c1 >= 0x10000) ? 1 : 0;
}
p->pat_used = cp - p->pat;
slen = p->patlen - 1;
cp = p->pat;
for (i = k = 0; i < p->pat_used; i++, cp++) {
for (sp = p->skip, j = 0;
j < p->skip_used && sp->ch->uc != cp->uc; j++, sp++) ;
if (j == p->skip_used) {
sp->ch = cp;
p->skip_used++;
}
sp->skip = slen - k;
if (cp->uc >= 0x10000 && k + 2 < slen)
sp->skip++;
if (((cp->uc >= 0x10000 && k + 2 <= slen) || k + 1 <= slen) &&
cp->uc == sentinel)
p->md4 = slen - k;
k += (cp->uc >= 0x10000) ? 2 : 1;
}
}
int
utbm_exec(utbm_pattern_t pat, ucs2_t *text, unsigned long textlen,
unsigned long *match_start, unsigned long *match_end)
{
unsigned long k;
ucs2_t *start, *end;
if (pat == 0 || pat->pat_used == 0 || text == 0 || textlen == 0 ||
textlen < pat->patlen)
return 0;
start = text + pat->patlen;
end = text + textlen;
if (0xdc00 <= *start && *start <= 0xdfff &&
0xd800 <= *(start - 1) && *(start - 1) <= 0xdbff)
start--;
while (start < end) {
while ((k = _utbm_skip(pat, start, end))) {
start += k;
if (start < end && 0xdc00 <= *start && *start <= 0xdfff &&
0xd800 <= *(start - 1) && *(start - 1) <= 0xdbff)
start--;
}
if (start < end &&
_utbm_match(pat, text, start, end, match_start, match_end))
return 1;
start += pat->md4;
if (start < end && 0xdc00 <= *start && *start <= 0xdfff &&
0xd800 <= *(start - 1) && *(start - 1) <= 0xdbff)
start--;
}
return 0;
}