| /* | |
| tre_regcomp.c - TRE POSIX compatible regex compilation functions. | |
| This software is released under a BSD-style license. | |
| See the file LICENSE for details and copyright. | |
| */ | |
| #ifdef HAVE_CONFIG_H | |
| #include <config.h> | |
| #endif /* HAVE_CONFIG_H */ | |
| #include <string.h> | |
| #include <errno.h> | |
| #include <stdlib.h> | |
| #include "tre.h" | |
| #include "tre-internal.h" | |
| #include "xmalloc.h" | |
| int | |
| tre_regncomp(regex_t *preg, const char *regex, size_t n, int cflags) | |
| { | |
| int ret; | |
| #if TRE_WCHAR | |
| tre_char_t *wregex; | |
| size_t wlen; | |
| wregex = xmalloc(sizeof(tre_char_t) * (n + 1)); | |
| if (wregex == NULL) | |
| return REG_ESPACE; | |
| /* If the current locale uses the standard single byte encoding of | |
| characters, we don't do a multibyte string conversion. If we did, | |
| many applications which use the default locale would break since | |
| the default "C" locale uses the 7-bit ASCII character set, and | |
| all characters with the eighth bit set would be considered invalid. */ | |
| #if TRE_MULTIBYTE | |
| if (TRE_MB_CUR_MAX == 1) | |
| #endif /* TRE_MULTIBYTE */ | |
| { | |
| size_t i; | |
| const unsigned char *str = (const unsigned char *)regex; | |
| tre_char_t *wstr = wregex; | |
| for (i = 0; i < n; i++) | |
| *(wstr++) = *(str++); | |
| wlen = n; | |
| } | |
| #if TRE_MULTIBYTE | |
| else | |
| { | |
| size_t consumed; | |
| tre_char_t *wcptr = wregex; | |
| #ifdef HAVE_MBSTATE_T | |
| mbstate_t state; | |
| memset(&state, '\0', sizeof(state)); | |
| #endif /* HAVE_MBSTATE_T */ | |
| while (n > 0) | |
| { | |
| consumed = tre_mbrtowc(wcptr, regex, n, &state); | |
| switch (consumed) | |
| { | |
| case 0: | |
| if (*regex == '\0') | |
| consumed = 1; | |
| else | |
| { | |
| xfree(wregex); | |
| return REG_BADPAT; | |
| } | |
| break; | |
| case (size_t)-1: | |
| DPRINT(("mbrtowc: error %d: %s.\n", errno, strerror(errno))); | |
| xfree(wregex); | |
| return REG_BADPAT; | |
| case (size_t)-2: | |
| /* The last character wasn't complete. Let's not call it a | |
| fatal error. */ | |
| consumed = n; | |
| break; | |
| } | |
| regex += consumed; | |
| n -= consumed; | |
| wcptr++; | |
| } | |
| wlen = wcptr - wregex; | |
| } | |
| #endif /* TRE_MULTIBYTE */ | |
| wregex[wlen] = L'\0'; | |
| ret = tre_compile(preg, wregex, wlen, cflags); | |
| xfree(wregex); | |
| #else /* !TRE_WCHAR */ | |
| ret = tre_compile(preg, (const tre_char_t *)regex, n, cflags); | |
| #endif /* !TRE_WCHAR */ | |
| return ret; | |
| } | |
| /* this version takes bytes literally, to be used with raw vectors */ | |
| int | |
| tre_regncompb(regex_t *preg, const char *regex, size_t n, int cflags) | |
| { | |
| int ret; | |
| #if TRE_WCHAR /* wide chars = we need to convert it all to the wide format */ | |
| tre_char_t *wregex; | |
| size_t i; | |
| wregex = xmalloc(sizeof(tre_char_t) * n); | |
| if (wregex == NULL) | |
| return REG_ESPACE; | |
| for (i = 0; i < n; i++) | |
| wregex[i] = (tre_char_t) ((unsigned char) regex[i]); | |
| ret = tre_compile(preg, wregex, n, cflags | REG_USEBYTES); | |
| xfree(wregex); | |
| #else /* !TRE_WCHAR */ | |
| ret = tre_compile(preg, (const tre_char_t *)regex, n, cflags | REG_USEBYTES); | |
| #endif /* !TRE_WCHAR */ | |
| return ret; | |
| } | |
| int | |
| tre_regcomp(regex_t *preg, const char *regex, int cflags) | |
| { | |
| return tre_regncomp(preg, regex, regex ? strlen(regex) : 0, cflags); | |
| } | |
| int | |
| tre_regcompb(regex_t *preg, const char *regex, int cflags) | |
| { | |
| int ret; | |
| tre_char_t *wregex; | |
| size_t wlen, n = strlen(regex); | |
| unsigned int i; | |
| const unsigned char *str = (const unsigned char *)regex; | |
| tre_char_t *wstr; | |
| wregex = xmalloc(sizeof(tre_char_t) * (n + 1)); | |
| if (wregex == NULL) return REG_ESPACE; | |
| wstr = wregex; | |
| for (i = 0; i < n; i++) *(wstr++) = *(str++); | |
| wlen = n; | |
| wregex[wlen] = L'\0'; | |
| ret = tre_compile(preg, wregex, wlen, cflags | REG_USEBYTES); | |
| xfree(wregex); | |
| return ret; | |
| } | |
| #ifdef TRE_WCHAR | |
| int | |
| tre_regwncomp(regex_t *preg, const wchar_t *regex, size_t n, int cflags) | |
| { | |
| return tre_compile(preg, regex, n, cflags); | |
| } | |
| int | |
| tre_regwcomp(regex_t *preg, const wchar_t *regex, int cflags) | |
| { | |
| return tre_compile(preg, regex, regex ? wcslen(regex) : 0, cflags); | |
| } | |
| #endif /* TRE_WCHAR */ | |
| void | |
| tre_regfree(regex_t *preg) | |
| { | |
| tre_free(preg); | |
| } | |
| /* EOF */ |