153 |
{ |
{ |
154 |
char *mb_properties = xmalloc(size); |
char *mb_properties = xmalloc(size); |
155 |
mbstate_t cur_state; |
mbstate_t cur_state; |
156 |
|
wchar_t wc; |
157 |
int i; |
int i; |
158 |
|
|
159 |
memset(&cur_state, 0, sizeof(mbstate_t)); |
memset(&cur_state, 0, sizeof(mbstate_t)); |
160 |
memset(mb_properties, 0, sizeof(char)*size); |
memset(mb_properties, 0, sizeof(char)*size); |
161 |
|
|
162 |
for (i = 0; i < size ;) |
for (i = 0; i < size ;) |
163 |
{ |
{ |
164 |
size_t mbclen; |
size_t mbclen; |
165 |
mbclen = mbrlen(buf + i, size - i, &cur_state); |
mbclen = mbrtowc(&wc, buf + i, size - i, &cur_state); |
166 |
|
|
167 |
if (mbclen == (size_t) -1 || mbclen == (size_t) -2 || mbclen == 0) |
if (mbclen == (size_t) -1 || mbclen == (size_t) -2 || mbclen == 0) |
168 |
{ |
{ |
170 |
We treat it as a singlebyte character. */ |
We treat it as a singlebyte character. */ |
171 |
mbclen = 1; |
mbclen = 1; |
172 |
} |
} |
173 |
|
else if (match_icase) |
174 |
|
{ |
175 |
|
if (iswupper((wint_t)wc)) |
176 |
|
{ |
177 |
|
wc = towlower((wint_t)wc); |
178 |
|
wcrtomb(buf + i, wc, &cur_state); |
179 |
|
} |
180 |
|
} |
181 |
mb_properties[i] = mbclen; |
mb_properties[i] = mbclen; |
182 |
i += mbclen; |
i += mbclen; |
183 |
} |
} |
352 |
char eol = eolbyte; |
char eol = eolbyte; |
353 |
int backref, start, len; |
int backref, start, len; |
354 |
struct kwsmatch kwsm; |
struct kwsmatch kwsm; |
355 |
size_t i; |
size_t i, ret_val; |
356 |
#ifdef MBS_SUPPORT |
#ifdef MBS_SUPPORT |
357 |
char *mb_properties = NULL; |
char *mb_properties = NULL; |
358 |
#endif /* MBS_SUPPORT */ |
if (MB_CUR_MAX > 1) |
359 |
|
{ |
360 |
#ifdef MBS_SUPPORT |
if (match_icase) |
361 |
if (MB_CUR_MAX > 1 && kwset) |
{ |
362 |
mb_properties = check_multibyte_string(buf, size); |
char *case_buf = malloc(size); |
363 |
|
memcpy(case_buf, buf, size); |
364 |
|
buf = case_buf; |
365 |
|
} |
366 |
|
if (kwset) |
367 |
|
mb_properties = check_multibyte_string(buf, size); |
368 |
|
} |
369 |
#endif /* MBS_SUPPORT */ |
#endif /* MBS_SUPPORT */ |
370 |
|
|
371 |
buflim = buf + size; |
buflim = buf + size; |
382 |
{ |
{ |
383 |
#ifdef MBS_SUPPORT |
#ifdef MBS_SUPPORT |
384 |
if (MB_CUR_MAX > 1) |
if (MB_CUR_MAX > 1) |
385 |
free(mb_properties); |
{ |
386 |
#endif |
if (match_icase) |
387 |
|
free ((char*)buf); |
388 |
|
free(mb_properties); |
389 |
|
} |
390 |
|
#endif /* MBS_SUPPORT */ |
391 |
return (size_t)-1; |
return (size_t)-1; |
392 |
} |
} |
393 |
beg += offset; |
beg += offset; |
485 |
} /* for Regex patterns. */ |
} /* for Regex patterns. */ |
486 |
} /* for (beg = end ..) */ |
} /* for (beg = end ..) */ |
487 |
#ifdef MBS_SUPPORT |
#ifdef MBS_SUPPORT |
488 |
if (MB_CUR_MAX > 1 && mb_properties) |
if (MB_CUR_MAX > 1) |
489 |
free (mb_properties); |
{ |
490 |
|
if (match_icase) |
491 |
|
free((char*)buf); |
492 |
|
if (mb_properties) |
493 |
|
free(mb_properties); |
494 |
|
} |
495 |
#endif /* MBS_SUPPORT */ |
#endif /* MBS_SUPPORT */ |
496 |
return (size_t) -1; |
return (size_t) -1; |
497 |
|
|
498 |
success: |
success: |
499 |
|
ret_val = beg - buf; |
500 |
#ifdef MBS_SUPPORT |
#ifdef MBS_SUPPORT |
501 |
if (MB_CUR_MAX > 1 && mb_properties) |
if (MB_CUR_MAX > 1) |
502 |
free (mb_properties); |
{ |
503 |
|
if (match_icase) |
504 |
|
free((char*)buf); |
505 |
|
if (mb_properties) |
506 |
|
free(mb_properties); |
507 |
|
} |
508 |
#endif /* MBS_SUPPORT */ |
#endif /* MBS_SUPPORT */ |
509 |
*match_size = end - beg; |
*match_size = end - beg; |
510 |
return beg - buf; |
return ret_val; |
511 |
} |
} |
512 |
|
|
513 |
static void |
static void |
540 |
register size_t len; |
register size_t len; |
541 |
char eol = eolbyte; |
char eol = eolbyte; |
542 |
struct kwsmatch kwsmatch; |
struct kwsmatch kwsmatch; |
543 |
|
size_t ret_val; |
544 |
#ifdef MBS_SUPPORT |
#ifdef MBS_SUPPORT |
545 |
char *mb_properties; |
char *mb_properties = NULL; |
546 |
if (MB_CUR_MAX > 1) |
if (MB_CUR_MAX > 1) |
547 |
mb_properties = check_multibyte_string (buf, size); |
{ |
548 |
|
if (match_icase) |
549 |
|
{ |
550 |
|
char *case_buf = malloc(size); |
551 |
|
memcpy(case_buf, buf, size); |
552 |
|
buf = case_buf; |
553 |
|
} |
554 |
|
mb_properties = check_multibyte_string(buf, size); |
555 |
|
} |
556 |
#endif /* MBS_SUPPORT */ |
#endif /* MBS_SUPPORT */ |
557 |
|
|
558 |
for (beg = buf; beg <= buf + size; ++beg) |
for (beg = buf; beg <= buf + size; ++beg) |
561 |
if (offset == (size_t) -1) |
if (offset == (size_t) -1) |
562 |
{ |
{ |
563 |
#ifdef MBS_SUPPORT |
#ifdef MBS_SUPPORT |
564 |
if (MB_CUR_MAX > 1) |
if (MB_CUR_MAX > 1) |
565 |
free(mb_properties); |
{ |
566 |
|
if (match_icase) |
567 |
|
free ((char*)buf); |
568 |
|
free(mb_properties); |
569 |
|
} |
570 |
#endif /* MBS_SUPPORT */ |
#endif /* MBS_SUPPORT */ |
571 |
return offset; |
return offset; |
572 |
} |
} |
579 |
if (exact) |
if (exact) |
580 |
{ |
{ |
581 |
*match_size = len; |
*match_size = len; |
582 |
|
ret_val = beg - buf; |
583 |
#ifdef MBS_SUPPORT |
#ifdef MBS_SUPPORT |
584 |
if (MB_CUR_MAX > 1) |
if (MB_CUR_MAX > 1) |
585 |
free (mb_properties); |
{ |
586 |
|
if (match_icase) |
587 |
|
free ((char*)buf); |
588 |
|
free(mb_properties); |
589 |
|
} |
590 |
#endif /* MBS_SUPPORT */ |
#endif /* MBS_SUPPORT */ |
591 |
return beg - buf; |
return ret_val; |
592 |
} |
} |
593 |
if (match_lines) |
if (match_lines) |
594 |
{ |
{ |
609 |
if (offset == (size_t) -1) |
if (offset == (size_t) -1) |
610 |
{ |
{ |
611 |
#ifdef MBS_SUPPORT |
#ifdef MBS_SUPPORT |
612 |
if (MB_CUR_MAX > 1) |
if (MB_CUR_MAX > 1) |
613 |
free (mb_properties); |
{ |
614 |
|
if (match_icase) |
615 |
|
free ((char*)buf); |
616 |
|
free(mb_properties); |
617 |
|
} |
618 |
#endif /* MBS_SUPPORT */ |
#endif /* MBS_SUPPORT */ |
619 |
return offset; |
return offset; |
620 |
} |
} |
630 |
|
|
631 |
#ifdef MBS_SUPPORT |
#ifdef MBS_SUPPORT |
632 |
if (MB_CUR_MAX > 1) |
if (MB_CUR_MAX > 1) |
633 |
free (mb_properties); |
{ |
634 |
|
if (match_icase) |
635 |
|
free((char*)buf); |
636 |
|
if (mb_properties) |
637 |
|
free(mb_properties); |
638 |
|
} |
639 |
#endif /* MBS_SUPPORT */ |
#endif /* MBS_SUPPORT */ |
640 |
return -1; |
return -1; |
641 |
|
|
645 |
while (buf < beg && beg[-1] != eol) |
while (buf < beg && beg[-1] != eol) |
646 |
--beg; |
--beg; |
647 |
*match_size = end - beg; |
*match_size = end - beg; |
648 |
|
ret_val = beg - buf; |
649 |
#ifdef MBS_SUPPORT |
#ifdef MBS_SUPPORT |
650 |
if (MB_CUR_MAX > 1) |
if (MB_CUR_MAX > 1) |
651 |
free (mb_properties); |
{ |
652 |
|
if (match_icase) |
653 |
|
free((char*)buf); |
654 |
|
if (mb_properties) |
655 |
|
free(mb_properties); |
656 |
|
} |
657 |
#endif /* MBS_SUPPORT */ |
#endif /* MBS_SUPPORT */ |
658 |
return beg - buf; |
return ret_val; |
659 |
} |
} |
660 |
|
|
661 |
#if HAVE_LIBPCRE |
#if HAVE_LIBPCRE |