user: implement mlibc as the libc, finally.
It's finally done.. Signed-off-by: kaguya <vpshinomiya@protonmail.com>
This commit is contained in:
kaguya
@@ -0,0 +1,321 @@
|
||||
/*
|
||||
* An implementation of what I call the "Sea of Stars" algorithm for
|
||||
* POSIX fnmatch(). The basic idea is that we factor the pattern into
|
||||
* a head component (which we match first and can reject without ever
|
||||
* measuring the length of the string), an optional tail component
|
||||
* (which only exists if the pattern contains at least one star), and
|
||||
* an optional "sea of stars", a set of star-separated components
|
||||
* between the head and tail. After the head and tail matches have
|
||||
* been removed from the input string, the components in the "sea of
|
||||
* stars" are matched sequentially by searching for their first
|
||||
* occurrence past the end of the previous match.
|
||||
*
|
||||
* - Rich Felker, April 2012
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
#include <fnmatch.h>
|
||||
#include <stdlib.h>
|
||||
#include <wchar.h>
|
||||
#include <wctype.h>
|
||||
// #include "locale_impl.h"
|
||||
|
||||
#define END 0
|
||||
#define UNMATCHABLE -2
|
||||
#define BRACKET -3
|
||||
#define QUESTION -4
|
||||
#define STAR -5
|
||||
|
||||
static int str_next(const char *str, size_t n, size_t *step)
|
||||
{
|
||||
if (!n) {
|
||||
*step = 0;
|
||||
return 0;
|
||||
}
|
||||
if (str[0] >= 128U) {
|
||||
wchar_t wc;
|
||||
int k = mbtowc(&wc, str, n);
|
||||
if (k<0) {
|
||||
*step = 1;
|
||||
return -1;
|
||||
}
|
||||
*step = k;
|
||||
return wc;
|
||||
}
|
||||
*step = 1;
|
||||
return str[0];
|
||||
}
|
||||
|
||||
static int pat_next(const char *pat, size_t m, size_t *step, int flags)
|
||||
{
|
||||
int esc = 0;
|
||||
if (!m || !*pat) {
|
||||
*step = 0;
|
||||
return END;
|
||||
}
|
||||
*step = 1;
|
||||
if (pat[0]=='\\' && pat[1] && !(flags & FNM_NOESCAPE)) {
|
||||
*step = 2;
|
||||
pat++;
|
||||
esc = 1;
|
||||
goto escaped;
|
||||
}
|
||||
if (pat[0]=='[') {
|
||||
size_t k = 1;
|
||||
if (k<m) if (pat[k] == '^' || pat[k] == '!') k++;
|
||||
if (k<m) if (pat[k] == ']') k++;
|
||||
for (; k<m && pat[k] && pat[k]!=']'; k++) {
|
||||
if (k+1<m && pat[k+1] && pat[k]=='[' && (pat[k+1]==':' || pat[k+1]=='.' || pat[k+1]=='=')) {
|
||||
int z = pat[k+1];
|
||||
k+=2;
|
||||
if (k<m && pat[k]) k++;
|
||||
while (k<m && pat[k] && (pat[k-1]!=z || pat[k]!=']')) k++;
|
||||
if (k==m || !pat[k]) break;
|
||||
}
|
||||
}
|
||||
if (k==m || !pat[k]) {
|
||||
*step = 1;
|
||||
return '[';
|
||||
}
|
||||
*step = k+1;
|
||||
return BRACKET;
|
||||
}
|
||||
if (pat[0] == '*')
|
||||
return STAR;
|
||||
if (pat[0] == '?')
|
||||
return QUESTION;
|
||||
escaped:
|
||||
if (pat[0] >= 128U) {
|
||||
wchar_t wc;
|
||||
int k = mbtowc(&wc, pat, m);
|
||||
if (k<0) {
|
||||
*step = 0;
|
||||
return UNMATCHABLE;
|
||||
}
|
||||
*step = k + esc;
|
||||
return wc;
|
||||
}
|
||||
return pat[0];
|
||||
}
|
||||
|
||||
static int casefold(int k)
|
||||
{
|
||||
int c = towupper(k);
|
||||
return c == k ? towlower(k) : c;
|
||||
}
|
||||
|
||||
static int match_bracket(const char *p, int k, int kfold)
|
||||
{
|
||||
wchar_t wc;
|
||||
int inv = 0;
|
||||
p++;
|
||||
if (*p=='^' || *p=='!') {
|
||||
inv = 1;
|
||||
p++;
|
||||
}
|
||||
if (*p==']') {
|
||||
if (k==']') return !inv;
|
||||
p++;
|
||||
} else if (*p=='-') {
|
||||
if (k=='-') return !inv;
|
||||
p++;
|
||||
}
|
||||
wc = p[-1];
|
||||
for (; *p != ']'; p++) {
|
||||
if (p[0]=='-' && p[1]!=']') {
|
||||
wchar_t wc2;
|
||||
int l = mbtowc(&wc2, p+1, 4);
|
||||
if (l < 0) return 0;
|
||||
if (wc <= wc2)
|
||||
if ((unsigned)k-wc <= wc2-wc ||
|
||||
(unsigned)kfold-wc <= wc2-wc)
|
||||
return !inv;
|
||||
p += l-1;
|
||||
continue;
|
||||
}
|
||||
if (p[0]=='[' && (p[1]==':' || p[1]=='.' || p[1]=='=')) {
|
||||
const char *p0 = p+2;
|
||||
int z = p[1];
|
||||
p+=3;
|
||||
while (p[-1]!=z || p[0]!=']') p++;
|
||||
if (z == ':' && p-1-p0 < 16) {
|
||||
char buf[16];
|
||||
memcpy(buf, p0, p-1-p0);
|
||||
buf[p-1-p0] = 0;
|
||||
if (iswctype(k, wctype(buf)) ||
|
||||
iswctype(kfold, wctype(buf)))
|
||||
return !inv;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (*p < 128U) {
|
||||
wc = (unsigned char)*p;
|
||||
} else {
|
||||
int l = mbtowc(&wc, p, 4);
|
||||
if (l < 0) return 0;
|
||||
p += l-1;
|
||||
}
|
||||
if (wc==(wchar_t)k || wc==(wchar_t)kfold) return !inv;
|
||||
}
|
||||
return inv;
|
||||
}
|
||||
|
||||
static int fnmatch_internal(const char *pat, size_t m, const char *str, size_t n, int flags)
|
||||
{
|
||||
const char *p, *ptail, *endpat;
|
||||
const char *s, *stail, *endstr;
|
||||
size_t pinc, sinc, tailcnt=0;
|
||||
int c, k, kfold;
|
||||
|
||||
if (flags & FNM_PERIOD) {
|
||||
if (*str == '.' && *pat != '.')
|
||||
return FNM_NOMATCH;
|
||||
}
|
||||
for (;;) {
|
||||
switch ((c = pat_next(pat, m, &pinc, flags))) {
|
||||
case UNMATCHABLE:
|
||||
return FNM_NOMATCH;
|
||||
case STAR:
|
||||
pat++;
|
||||
m--;
|
||||
break;
|
||||
default:
|
||||
k = str_next(str, n, &sinc);
|
||||
if (k <= 0)
|
||||
return (c==END) ? 0 : FNM_NOMATCH;
|
||||
str += sinc;
|
||||
n -= sinc;
|
||||
kfold = flags & FNM_CASEFOLD ? casefold(k) : k;
|
||||
if (c == BRACKET) {
|
||||
if (!match_bracket(pat, k, kfold))
|
||||
return FNM_NOMATCH;
|
||||
} else if (c != QUESTION && k != c && kfold != c) {
|
||||
return FNM_NOMATCH;
|
||||
}
|
||||
pat+=pinc;
|
||||
m-=pinc;
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
/* Compute real pat length if it was initially unknown/-1 */
|
||||
m = strnlen(pat, m);
|
||||
endpat = pat + m;
|
||||
|
||||
/* Find the last * in pat and count chars needed after it */
|
||||
for (p=ptail=pat; p<endpat; p+=pinc) {
|
||||
switch (pat_next(p, endpat-p, &pinc, flags)) {
|
||||
case UNMATCHABLE:
|
||||
return FNM_NOMATCH;
|
||||
case STAR:
|
||||
tailcnt=0;
|
||||
ptail = p+1;
|
||||
break;
|
||||
default:
|
||||
tailcnt++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Past this point we need not check for UNMATCHABLE in pat,
|
||||
* because all of pat has already been parsed once. */
|
||||
|
||||
/* Compute real str length if it was initially unknown/-1 */
|
||||
n = strnlen(str, n);
|
||||
endstr = str + n;
|
||||
if (n < tailcnt) return FNM_NOMATCH;
|
||||
|
||||
/* Find the final tailcnt chars of str, accounting for UTF-8.
|
||||
* On illegal sequences we may get it wrong, but in that case
|
||||
* we necessarily have a matching failure anyway. */
|
||||
for (s=endstr; s>str && tailcnt; tailcnt--) {
|
||||
if (s[-1] < 128U || MB_CUR_MAX==1) s--;
|
||||
else while ((unsigned char)*--s-0x80U<0x40 && s>str);
|
||||
}
|
||||
if (tailcnt) return FNM_NOMATCH;
|
||||
stail = s;
|
||||
|
||||
/* Check that the pat and str tails match */
|
||||
p = ptail;
|
||||
for (;;) {
|
||||
c = pat_next(p, endpat-p, &pinc, flags);
|
||||
p += pinc;
|
||||
if ((k = str_next(s, endstr-s, &sinc)) <= 0) {
|
||||
if (c != END) return FNM_NOMATCH;
|
||||
break;
|
||||
}
|
||||
s += sinc;
|
||||
kfold = flags & FNM_CASEFOLD ? casefold(k) : k;
|
||||
if (c == BRACKET) {
|
||||
if (!match_bracket(p-pinc, k, kfold))
|
||||
return FNM_NOMATCH;
|
||||
} else if (c != QUESTION && k != c && kfold != c) {
|
||||
return FNM_NOMATCH;
|
||||
}
|
||||
}
|
||||
|
||||
/* We're all done with the tails now, so throw them out */
|
||||
endstr = stail;
|
||||
endpat = ptail;
|
||||
|
||||
/* Match pattern components until there are none left */
|
||||
while (pat<endpat) {
|
||||
p = pat;
|
||||
s = str;
|
||||
for (;;) {
|
||||
c = pat_next(p, endpat-p, &pinc, flags);
|
||||
p += pinc;
|
||||
/* Encountering * completes/commits a component */
|
||||
if (c == STAR) {
|
||||
pat = p;
|
||||
str = s;
|
||||
break;
|
||||
}
|
||||
k = str_next(s, endstr-s, &sinc);
|
||||
if (!k)
|
||||
return FNM_NOMATCH;
|
||||
kfold = flags & FNM_CASEFOLD ? casefold(k) : k;
|
||||
if (c == BRACKET) {
|
||||
if (!match_bracket(p-pinc, k, kfold))
|
||||
break;
|
||||
} else if (c != QUESTION && k != c && kfold != c) {
|
||||
break;
|
||||
}
|
||||
s += sinc;
|
||||
}
|
||||
if (c == STAR) continue;
|
||||
/* If we failed, advance str, by 1 char if it's a valid
|
||||
* char, or past all invalid bytes otherwise. */
|
||||
k = str_next(str, endstr-str, &sinc);
|
||||
if (k > 0) str += sinc;
|
||||
else for (str++; str_next(str, endstr-str, &sinc)<0; str++);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int fnmatch(const char *pat, const char *str, int flags)
|
||||
{
|
||||
const char *s, *p;
|
||||
size_t inc;
|
||||
int c;
|
||||
if (flags & FNM_PATHNAME) for (;;) {
|
||||
for (s=str; *s && *s!='/'; s++);
|
||||
for (p=pat; (c=pat_next(p, -1, &inc, flags))!=END && c!='/'; p+=inc);
|
||||
if (c!=*s && (!*s || !(flags & FNM_LEADING_DIR)))
|
||||
return FNM_NOMATCH;
|
||||
if (fnmatch_internal(pat, p-pat, str, s-str, flags))
|
||||
return FNM_NOMATCH;
|
||||
if (!c) return 0;
|
||||
str = s+1;
|
||||
pat = p+inc;
|
||||
} else if (flags & FNM_LEADING_DIR) {
|
||||
for (s=str; *s; s++) {
|
||||
if (*s != '/') continue;
|
||||
if (!fnmatch_internal(pat, -1, str, s-str, flags))
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return fnmatch_internal(pat, -1, str, -1, flags);
|
||||
}
|
||||
@@ -0,0 +1,311 @@
|
||||
#define _BSD_SOURCE
|
||||
#include <glob.h>
|
||||
#include <fnmatch.h>
|
||||
#include <sys/stat.h>
|
||||
#include <dirent.h>
|
||||
#include <limits.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <errno.h>
|
||||
#include <stddef.h>
|
||||
#include <unistd.h>
|
||||
#include <pwd.h>
|
||||
|
||||
struct match
|
||||
{
|
||||
struct match *next;
|
||||
char name[];
|
||||
};
|
||||
|
||||
static int append(struct match **tail, const char *name, size_t len, int mark)
|
||||
{
|
||||
struct match *new = malloc(sizeof(struct match) + len + 2);
|
||||
if (!new) return -1;
|
||||
(*tail)->next = new;
|
||||
new->next = NULL;
|
||||
memcpy(new->name, name, len+1);
|
||||
if (mark && len && name[len-1]!='/') {
|
||||
new->name[len] = '/';
|
||||
new->name[len+1] = 0;
|
||||
}
|
||||
*tail = new;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int do_glob(char *buf, size_t pos, int type, char *pat, int flags, int (*errfunc)(const char *path, int err), struct match **tail)
|
||||
{
|
||||
/* If GLOB_MARK is unused, we don't care about type. */
|
||||
if (!type && !(flags & GLOB_MARK)) type = DT_REG;
|
||||
|
||||
/* Special-case the remaining pattern being all slashes, in
|
||||
* which case we can use caller-passed type if it's a dir. */
|
||||
if (*pat && type!=DT_DIR) type = 0;
|
||||
while (pos+1 < PATH_MAX && *pat=='/') buf[pos++] = *pat++;
|
||||
|
||||
/* Consume maximal [escaped-]literal prefix of pattern, copying
|
||||
* and un-escaping it to the running buffer as we go. */
|
||||
ptrdiff_t i=0, j=0;
|
||||
int in_bracket = 0, overflow = 0;
|
||||
for (; pat[i]!='*' && pat[i]!='?' && (!in_bracket || pat[i]!=']'); i++) {
|
||||
if (!pat[i]) {
|
||||
if (overflow) return 0;
|
||||
pat += i;
|
||||
pos += j;
|
||||
i = j = 0;
|
||||
break;
|
||||
} else if (pat[i] == '[') {
|
||||
in_bracket = 1;
|
||||
} else if (pat[i] == '\\' && !(flags & GLOB_NOESCAPE)) {
|
||||
/* Backslashes inside a bracket are (at least by
|
||||
* our interpretation) non-special, so if next
|
||||
* char is ']' we have a complete expression. */
|
||||
if (in_bracket && pat[i+1]==']') break;
|
||||
/* Unpaired final backslash never matches. */
|
||||
if (!pat[i+1]) return 0;
|
||||
i++;
|
||||
}
|
||||
if (pat[i] == '/') {
|
||||
if (overflow) return 0;
|
||||
in_bracket = 0;
|
||||
pat += i+1;
|
||||
i = -1;
|
||||
pos += j+1;
|
||||
j = -1;
|
||||
}
|
||||
/* Only store a character if it fits in the buffer, but if
|
||||
* a potential bracket expression is open, the overflow
|
||||
* must be remembered and handled later only if the bracket
|
||||
* is unterminated (and thereby a literal), so as not to
|
||||
* disallow long bracket expressions with short matches. */
|
||||
if (pos+(j+1) < PATH_MAX) {
|
||||
buf[pos+j++] = pat[i];
|
||||
} else if (in_bracket) {
|
||||
overflow = 1;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
/* If we consume any new components, the caller-passed type
|
||||
* or dummy type from above is no longer valid. */
|
||||
type = 0;
|
||||
}
|
||||
buf[pos] = 0;
|
||||
if (!*pat) {
|
||||
/* If we consumed any components above, or if GLOB_MARK is
|
||||
* requested and we don't yet know if the match is a dir,
|
||||
* we must confirm the file exists and/or determine its type.
|
||||
*
|
||||
* If marking dirs, symlink type is inconclusive; we need the
|
||||
* type for the symlink target, and therefore must try stat
|
||||
* first unless type is known not to be a symlink. Otherwise,
|
||||
* or if that fails, use lstat for determining existence to
|
||||
* avoid false negatives in the case of broken symlinks. */
|
||||
struct stat st;
|
||||
if ((flags & GLOB_MARK) && (!type||type==DT_LNK) && !stat(buf, &st)) {
|
||||
if (S_ISDIR(st.st_mode)) type = DT_DIR;
|
||||
else type = DT_REG;
|
||||
}
|
||||
if (!type && lstat(buf, &st)) {
|
||||
if (errno!=ENOENT && (errfunc(buf, errno) || (flags & GLOB_ERR)))
|
||||
return GLOB_ABORTED;
|
||||
return 0;
|
||||
}
|
||||
if (append(tail, buf, pos, (flags & GLOB_MARK) && type==DT_DIR))
|
||||
return GLOB_NOSPACE;
|
||||
return 0;
|
||||
}
|
||||
char *p2 = strchr(pat, '/'), saved_sep = '/';
|
||||
/* Check if the '/' was escaped and, if so, remove the escape char
|
||||
* so that it will not be unpaired when passed to fnmatch. */
|
||||
if (p2 && !(flags & GLOB_NOESCAPE)) {
|
||||
char *p;
|
||||
for (p=p2; p>pat && p[-1]=='\\'; p--);
|
||||
if ((p2-p)%2) {
|
||||
p2--;
|
||||
saved_sep = '\\';
|
||||
}
|
||||
}
|
||||
DIR *dir = opendir(pos ? buf : ".");
|
||||
if (!dir) {
|
||||
if (errfunc(buf, errno) || (flags & GLOB_ERR))
|
||||
return GLOB_ABORTED;
|
||||
return 0;
|
||||
}
|
||||
int old_errno = errno;
|
||||
struct dirent *de;
|
||||
while (errno=0, de=readdir(dir)) {
|
||||
/* Quickly skip non-directories when there's pattern left. */
|
||||
if (p2 && de->d_type && de->d_type!=DT_DIR && de->d_type!=DT_LNK)
|
||||
continue;
|
||||
|
||||
size_t l = strlen(de->d_name);
|
||||
if (l >= PATH_MAX-pos) continue;
|
||||
|
||||
if (p2) *p2 = 0;
|
||||
|
||||
int fnm_flags= ((flags & GLOB_NOESCAPE) ? FNM_NOESCAPE : 0)
|
||||
| ((!(flags & GLOB_PERIOD)) ? FNM_PERIOD : 0);
|
||||
|
||||
if (fnmatch(pat, de->d_name, fnm_flags))
|
||||
continue;
|
||||
|
||||
/* With GLOB_PERIOD, don't allow matching . or .. unless
|
||||
* fnmatch would match them with FNM_PERIOD rules in effect. */
|
||||
if (p2 && (flags & GLOB_PERIOD) && de->d_name[0]=='.'
|
||||
&& (!de->d_name[1] || de->d_name[1]=='.' && !de->d_name[2])
|
||||
&& fnmatch(pat, de->d_name, fnm_flags | FNM_PERIOD))
|
||||
continue;
|
||||
|
||||
memcpy(buf+pos, de->d_name, l+1);
|
||||
if (p2) *p2 = saved_sep;
|
||||
int r = do_glob(buf, pos+l, de->d_type, p2 ? p2 : "", flags, errfunc, tail);
|
||||
if (r) {
|
||||
closedir(dir);
|
||||
return r;
|
||||
}
|
||||
}
|
||||
int readerr = errno;
|
||||
if (p2) *p2 = saved_sep;
|
||||
closedir(dir);
|
||||
if (readerr && (errfunc(buf, errno) || (flags & GLOB_ERR)))
|
||||
return GLOB_ABORTED;
|
||||
errno = old_errno;
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ignore_err(const char *path, int err)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void freelist(struct match *head)
|
||||
{
|
||||
struct match *match, *next;
|
||||
for (match=head->next; match; match=next) {
|
||||
next = match->next;
|
||||
free(match);
|
||||
}
|
||||
}
|
||||
|
||||
static int sort(const void *a, const void *b)
|
||||
{
|
||||
return strcmp(*(const char **)a, *(const char **)b);
|
||||
}
|
||||
|
||||
static int expand_tilde(char **pat, char *buf, size_t *pos)
|
||||
{
|
||||
char *p = *pat + 1;
|
||||
size_t i = 0;
|
||||
|
||||
char delim, *name_end = strchrnul(p, '/');
|
||||
if ((delim = *name_end)) *name_end++ = 0;
|
||||
*pat = name_end;
|
||||
|
||||
char *home = *p ? NULL : getenv("HOME");
|
||||
if (!home) {
|
||||
struct passwd pw, *res;
|
||||
switch (*p ? getpwnam_r(p, &pw, buf, PATH_MAX, &res)
|
||||
: getpwuid_r(getuid(), &pw, buf, PATH_MAX, &res)) {
|
||||
case ENOMEM:
|
||||
return GLOB_NOSPACE;
|
||||
case 0:
|
||||
if (!res)
|
||||
default:
|
||||
return GLOB_NOMATCH;
|
||||
}
|
||||
home = pw.pw_dir;
|
||||
}
|
||||
while (i < PATH_MAX - 2 && *home)
|
||||
buf[i++] = *home++;
|
||||
if (*home)
|
||||
return GLOB_NOMATCH;
|
||||
if ((buf[i] = delim))
|
||||
buf[++i] = 0;
|
||||
*pos = i;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int glob(const char *restrict pat, int flags, int (*errfunc)(const char *path, int err), glob_t *restrict g)
|
||||
{
|
||||
struct match head = { .next = NULL }, *tail = &head;
|
||||
size_t cnt, i;
|
||||
size_t offs = (flags & GLOB_DOOFFS) ? g->gl_offs : 0;
|
||||
int error = 0;
|
||||
char buf[PATH_MAX];
|
||||
|
||||
if (!errfunc) errfunc = ignore_err;
|
||||
|
||||
if (!(flags & GLOB_APPEND)) {
|
||||
g->gl_offs = offs;
|
||||
g->gl_pathc = 0;
|
||||
g->gl_pathv = NULL;
|
||||
}
|
||||
|
||||
if (*pat) {
|
||||
char *p = strdup(pat);
|
||||
if (!p) return GLOB_NOSPACE;
|
||||
buf[0] = 0;
|
||||
size_t pos = 0;
|
||||
char *s = p;
|
||||
if ((flags & (GLOB_TILDE | GLOB_TILDE_CHECK)) && *p == '~')
|
||||
error = expand_tilde(&s, buf, &pos);
|
||||
if (!error)
|
||||
error = do_glob(buf, pos, 0, s, flags, errfunc, &tail);
|
||||
free(p);
|
||||
}
|
||||
|
||||
if (error == GLOB_NOSPACE) {
|
||||
freelist(&head);
|
||||
return error;
|
||||
}
|
||||
|
||||
for (cnt=0, tail=head.next; tail; tail=tail->next, cnt++);
|
||||
if (!cnt) {
|
||||
if (flags & GLOB_NOCHECK) {
|
||||
tail = &head;
|
||||
if (append(&tail, pat, strlen(pat), 0))
|
||||
return GLOB_NOSPACE;
|
||||
cnt++;
|
||||
} else
|
||||
return GLOB_NOMATCH;
|
||||
}
|
||||
|
||||
if (flags & GLOB_APPEND) {
|
||||
char **pathv = realloc(g->gl_pathv, (offs + g->gl_pathc + cnt + 1) * sizeof(char *));
|
||||
if (!pathv) {
|
||||
freelist(&head);
|
||||
return GLOB_NOSPACE;
|
||||
}
|
||||
g->gl_pathv = pathv;
|
||||
offs += g->gl_pathc;
|
||||
} else {
|
||||
g->gl_pathv = malloc((offs + cnt + 1) * sizeof(char *));
|
||||
if (!g->gl_pathv) {
|
||||
freelist(&head);
|
||||
return GLOB_NOSPACE;
|
||||
}
|
||||
for (i=0; i<offs; i++)
|
||||
g->gl_pathv[i] = NULL;
|
||||
}
|
||||
for (i=0, tail=head.next; i<cnt; tail=tail->next, i++)
|
||||
g->gl_pathv[offs + i] = tail->name;
|
||||
g->gl_pathv[offs + i] = NULL;
|
||||
g->gl_pathc += cnt;
|
||||
|
||||
if (!(flags & GLOB_NOSORT))
|
||||
qsort(g->gl_pathv+offs, cnt, sizeof(char *), sort);
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
void globfree(glob_t *g)
|
||||
{
|
||||
size_t i;
|
||||
for (i=0; i<g->gl_pathc; i++)
|
||||
free(g->gl_pathv[g->gl_offs + i] - offsetof(struct match, name));
|
||||
free(g->gl_pathv);
|
||||
g->gl_pathc = 0;
|
||||
g->gl_pathv = NULL;
|
||||
}
|
||||
|
||||
// weak_alias(glob, glob64);
|
||||
// weak_alias(globfree, globfree64);
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,37 @@
|
||||
#include <string.h>
|
||||
#include <regex.h>
|
||||
#include <stdio.h>
|
||||
// #include "locale_impl.h"
|
||||
|
||||
/* Error message strings for error codes listed in `regex.h'. This list
|
||||
needs to be in sync with the codes listed there, naturally. */
|
||||
|
||||
/* Converted to single string by Rich Felker to remove the need for
|
||||
* data relocations at runtime, 27 Feb 2006. */
|
||||
|
||||
static const char messages[] = {
|
||||
"No error\0"
|
||||
"No match\0"
|
||||
"Invalid regexp\0"
|
||||
"Unknown collating element\0"
|
||||
"Unknown character class name\0"
|
||||
"Trailing backslash\0"
|
||||
"Invalid back reference\0"
|
||||
"Missing ']'\0"
|
||||
"Missing ')'\0"
|
||||
"Missing '}'\0"
|
||||
"Invalid contents of {}\0"
|
||||
"Invalid character range\0"
|
||||
"Out of memory\0"
|
||||
"Repetition not preceded by valid expression\0"
|
||||
"\0Unknown error"
|
||||
};
|
||||
|
||||
size_t regerror(int e, const regex_t *restrict preg, char *restrict buf, size_t size)
|
||||
{
|
||||
const char *s;
|
||||
for (s=messages; e && *s; e--, s+=strlen(s)+1);
|
||||
if (!*s) s++;
|
||||
// s = LCTRANS_CUR(s);
|
||||
return 1+snprintf(buf, size, "%s", s);
|
||||
}
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,158 @@
|
||||
/*
|
||||
tre-mem.c - TRE memory allocator
|
||||
|
||||
Copyright (c) 2001-2009 Ville Laurikari <vl@iki.fi>
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS
|
||||
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
*/
|
||||
|
||||
/*
|
||||
This memory allocator is for allocating small memory blocks efficiently
|
||||
in terms of memory overhead and execution speed. The allocated blocks
|
||||
cannot be freed individually, only all at once. There can be multiple
|
||||
allocators, though.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "tre.h"
|
||||
|
||||
/*
|
||||
This memory allocator is for allocating small memory blocks efficiently
|
||||
in terms of memory overhead and execution speed. The allocated blocks
|
||||
cannot be freed individually, only all at once. There can be multiple
|
||||
allocators, though.
|
||||
*/
|
||||
|
||||
/* Returns a new memory allocator or NULL if out of memory. */
|
||||
tre_mem_t
|
||||
tre_mem_new_impl(int provided, void *provided_block)
|
||||
{
|
||||
tre_mem_t mem;
|
||||
if (provided)
|
||||
{
|
||||
mem = provided_block;
|
||||
memset(mem, 0, sizeof(*mem));
|
||||
}
|
||||
else
|
||||
mem = xcalloc(1, sizeof(*mem));
|
||||
if (mem == NULL)
|
||||
return NULL;
|
||||
return mem;
|
||||
}
|
||||
|
||||
|
||||
/* Frees the memory allocator and all memory allocated with it. */
|
||||
void
|
||||
tre_mem_destroy(tre_mem_t mem)
|
||||
{
|
||||
tre_list_t *tmp, *l = mem->blocks;
|
||||
|
||||
while (l != NULL)
|
||||
{
|
||||
xfree(l->data);
|
||||
tmp = l->next;
|
||||
xfree(l);
|
||||
l = tmp;
|
||||
}
|
||||
xfree(mem);
|
||||
}
|
||||
|
||||
|
||||
/* Allocates a block of `size' bytes from `mem'. Returns a pointer to the
|
||||
allocated block or NULL if an underlying malloc() failed. */
|
||||
void *
|
||||
tre_mem_alloc_impl(tre_mem_t mem, int provided, void *provided_block,
|
||||
int zero, size_t size)
|
||||
{
|
||||
void *ptr;
|
||||
|
||||
if (mem->failed)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (mem->n < size)
|
||||
{
|
||||
/* We need more memory than is available in the current block.
|
||||
Allocate a new block. */
|
||||
tre_list_t *l;
|
||||
if (provided)
|
||||
{
|
||||
if (provided_block == NULL)
|
||||
{
|
||||
mem->failed = 1;
|
||||
return NULL;
|
||||
}
|
||||
mem->ptr = provided_block;
|
||||
mem->n = TRE_MEM_BLOCK_SIZE;
|
||||
}
|
||||
else
|
||||
{
|
||||
int block_size;
|
||||
if (size * 8 > TRE_MEM_BLOCK_SIZE)
|
||||
block_size = size * 8;
|
||||
else
|
||||
block_size = TRE_MEM_BLOCK_SIZE;
|
||||
l = xmalloc(sizeof(*l));
|
||||
if (l == NULL)
|
||||
{
|
||||
mem->failed = 1;
|
||||
return NULL;
|
||||
}
|
||||
l->data = xmalloc(block_size);
|
||||
if (l->data == NULL)
|
||||
{
|
||||
xfree(l);
|
||||
mem->failed = 1;
|
||||
return NULL;
|
||||
}
|
||||
l->next = NULL;
|
||||
if (mem->current != NULL)
|
||||
mem->current->next = l;
|
||||
if (mem->blocks == NULL)
|
||||
mem->blocks = l;
|
||||
mem->current = l;
|
||||
mem->ptr = l->data;
|
||||
mem->n = block_size;
|
||||
}
|
||||
}
|
||||
|
||||
/* Make sure the next pointer will be aligned. */
|
||||
size += ALIGN(mem->ptr + size, long);
|
||||
|
||||
/* Allocate from current block. */
|
||||
ptr = mem->ptr;
|
||||
mem->ptr += size;
|
||||
mem->n -= size;
|
||||
|
||||
/* Set to zero if needed. */
|
||||
if (zero)
|
||||
memset(ptr, 0, size);
|
||||
|
||||
return ptr;
|
||||
}
|
||||
@@ -0,0 +1,241 @@
|
||||
/* Taken from musl tre.h */
|
||||
/*
|
||||
tre-internal.h - TRE internal definitions
|
||||
|
||||
Copyright (c) 2001-2009 Ville Laurikari <vl@iki.fi>
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without
|
||||
modification, are permitted provided that the following conditions
|
||||
are met:
|
||||
|
||||
1. Redistributions of source code must retain the above copyright
|
||||
notice, this list of conditions and the following disclaimer.
|
||||
|
||||
2. Redistributions in binary form must reproduce the above copyright
|
||||
notice, this list of conditions and the following disclaimer in the
|
||||
documentation and/or other materials provided with the distribution.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS
|
||||
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||||
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||||
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||||
HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
||||
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
||||
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
||||
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
||||
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
||||
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
|
||||
*/
|
||||
|
||||
#include <regex.h>
|
||||
#include <wchar.h>
|
||||
#include <wctype.h>
|
||||
|
||||
#define hidden __attribute__((__visibility__("hidden")))
|
||||
|
||||
/* TODO: These should probably go in limits.h */
|
||||
#define CHARCLASS_NAME_MAX 14
|
||||
#define RE_DUP_MAX 255
|
||||
|
||||
#undef TRE_MBSTATE
|
||||
|
||||
#define NDEBUG
|
||||
|
||||
#define TRE_REGEX_T_FIELD __opaque
|
||||
typedef int reg_errcode_t;
|
||||
|
||||
typedef wchar_t tre_char_t;
|
||||
|
||||
#define DPRINT(msg) do { } while(0)
|
||||
|
||||
#define elementsof(x) ( sizeof(x) / sizeof(x[0]) )
|
||||
|
||||
#define tre_mbrtowc(pwc, s, n, ps) (mbtowc((pwc), (s), (n)))
|
||||
|
||||
/* Wide characters. */
|
||||
typedef wint_t tre_cint_t;
|
||||
#define TRE_CHAR_MAX 0x10ffff
|
||||
|
||||
#define tre_isalnum iswalnum
|
||||
#define tre_isalpha iswalpha
|
||||
#define tre_isblank iswblank
|
||||
#define tre_iscntrl iswcntrl
|
||||
#define tre_isdigit iswdigit
|
||||
#define tre_isgraph iswgraph
|
||||
#define tre_islower iswlower
|
||||
#define tre_isprint iswprint
|
||||
#define tre_ispunct iswpunct
|
||||
#define tre_isspace iswspace
|
||||
#define tre_isupper iswupper
|
||||
#define tre_isxdigit iswxdigit
|
||||
|
||||
#define tre_tolower towlower
|
||||
#define tre_toupper towupper
|
||||
#define tre_strlen wcslen
|
||||
|
||||
/* Use system provided iswctype() and wctype(). */
|
||||
typedef wctype_t tre_ctype_t;
|
||||
#define tre_isctype iswctype
|
||||
#define tre_ctype wctype
|
||||
|
||||
/* Returns number of bytes to add to (char *)ptr to make it
|
||||
properly aligned for the type. */
|
||||
#define ALIGN(ptr, type) \
|
||||
((((long)ptr) % sizeof(type)) \
|
||||
? (sizeof(type) - (((long)ptr) % sizeof(type))) \
|
||||
: 0)
|
||||
|
||||
#undef MAX
|
||||
#undef MIN
|
||||
#define MAX(a, b) (((a) >= (b)) ? (a) : (b))
|
||||
#define MIN(a, b) (((a) <= (b)) ? (a) : (b))
|
||||
|
||||
/* TNFA transition type. A TNFA state is an array of transitions,
|
||||
the terminator is a transition with NULL `state'. */
|
||||
typedef struct tnfa_transition tre_tnfa_transition_t;
|
||||
|
||||
struct tnfa_transition {
|
||||
/* Range of accepted characters. */
|
||||
tre_cint_t code_min;
|
||||
tre_cint_t code_max;
|
||||
/* Pointer to the destination state. */
|
||||
tre_tnfa_transition_t *state;
|
||||
/* ID number of the destination state. */
|
||||
int state_id;
|
||||
/* -1 terminated array of tags (or NULL). */
|
||||
int *tags;
|
||||
/* Assertion bitmap. */
|
||||
int assertions;
|
||||
/* Assertion parameters. */
|
||||
union {
|
||||
/* Character class assertion. */
|
||||
tre_ctype_t class;
|
||||
/* Back reference assertion. */
|
||||
int backref;
|
||||
} u;
|
||||
/* Negative character class assertions. */
|
||||
tre_ctype_t *neg_classes;
|
||||
};
|
||||
|
||||
|
||||
/* Assertions. */
|
||||
#define ASSERT_AT_BOL 1 /* Beginning of line. */
|
||||
#define ASSERT_AT_EOL 2 /* End of line. */
|
||||
#define ASSERT_CHAR_CLASS 4 /* Character class in `class'. */
|
||||
#define ASSERT_CHAR_CLASS_NEG 8 /* Character classes in `neg_classes'. */
|
||||
#define ASSERT_AT_BOW 16 /* Beginning of word. */
|
||||
#define ASSERT_AT_EOW 32 /* End of word. */
|
||||
#define ASSERT_AT_WB 64 /* Word boundary. */
|
||||
#define ASSERT_AT_WB_NEG 128 /* Not a word boundary. */
|
||||
#define ASSERT_BACKREF 256 /* A back reference in `backref'. */
|
||||
#define ASSERT_LAST 256
|
||||
|
||||
/* Tag directions. */
|
||||
typedef enum {
|
||||
TRE_TAG_MINIMIZE = 0,
|
||||
TRE_TAG_MAXIMIZE = 1
|
||||
} tre_tag_direction_t;
|
||||
|
||||
/* Instructions to compute submatch register values from tag values
|
||||
after a successful match. */
|
||||
struct tre_submatch_data {
|
||||
/* Tag that gives the value for rm_so (submatch start offset). */
|
||||
int so_tag;
|
||||
/* Tag that gives the value for rm_eo (submatch end offset). */
|
||||
int eo_tag;
|
||||
/* List of submatches this submatch is contained in. */
|
||||
int *parents;
|
||||
};
|
||||
|
||||
typedef struct tre_submatch_data tre_submatch_data_t;
|
||||
|
||||
|
||||
/* TNFA definition. */
|
||||
typedef struct tnfa tre_tnfa_t;
|
||||
|
||||
struct tnfa {
|
||||
tre_tnfa_transition_t *transitions;
|
||||
unsigned int num_transitions;
|
||||
tre_tnfa_transition_t *initial;
|
||||
tre_tnfa_transition_t *final;
|
||||
tre_submatch_data_t *submatch_data;
|
||||
char *firstpos_chars;
|
||||
int first_char;
|
||||
unsigned int num_submatches;
|
||||
tre_tag_direction_t *tag_directions;
|
||||
int *minimal_tags;
|
||||
int num_tags;
|
||||
int num_minimals;
|
||||
int end_tag;
|
||||
int num_states;
|
||||
int cflags;
|
||||
int have_backrefs;
|
||||
int have_approx;
|
||||
};
|
||||
|
||||
/* from tre-mem.h: */
|
||||
|
||||
#define TRE_MEM_BLOCK_SIZE 1024
|
||||
|
||||
typedef struct tre_list {
|
||||
void *data;
|
||||
struct tre_list *next;
|
||||
} tre_list_t;
|
||||
|
||||
typedef struct tre_mem_struct {
|
||||
tre_list_t *blocks;
|
||||
tre_list_t *current;
|
||||
char *ptr;
|
||||
size_t n;
|
||||
int failed;
|
||||
void **provided;
|
||||
} *tre_mem_t;
|
||||
|
||||
#ifndef __MLIBC_ABI_ONLY
|
||||
|
||||
#define tre_mem_new_impl __tre_mem_new_impl
|
||||
#define tre_mem_alloc_impl __tre_mem_alloc_impl
|
||||
#define tre_mem_destroy __tre_mem_destroy
|
||||
|
||||
hidden tre_mem_t tre_mem_new_impl(int provided, void *provided_block);
|
||||
hidden void *tre_mem_alloc_impl(tre_mem_t mem, int provided, void *provided_block,
|
||||
int zero, size_t size);
|
||||
|
||||
/* Returns a new memory allocator or NULL if out of memory. */
|
||||
#define tre_mem_new() tre_mem_new_impl(0, NULL)
|
||||
|
||||
/* Allocates a block of `size' bytes from `mem'. Returns a pointer to the
|
||||
allocated block or NULL if an underlying malloc() failed. */
|
||||
#define tre_mem_alloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 0, size)
|
||||
|
||||
/* Allocates a block of `size' bytes from `mem'. Returns a pointer to the
|
||||
allocated block or NULL if an underlying malloc() failed. The memory
|
||||
is set to zero. */
|
||||
#define tre_mem_calloc(mem, size) tre_mem_alloc_impl(mem, 0, NULL, 1, size)
|
||||
|
||||
#ifdef TRE_USE_ALLOCA
|
||||
/* alloca() versions. Like above, but memory is allocated with alloca()
|
||||
instead of malloc(). */
|
||||
|
||||
#define tre_mem_newa() \
|
||||
tre_mem_new_impl(1, alloca(sizeof(struct tre_mem_struct)))
|
||||
|
||||
#define tre_mem_alloca(mem, size) \
|
||||
((mem)->n >= (size) \
|
||||
? tre_mem_alloc_impl((mem), 1, NULL, 0, (size)) \
|
||||
: tre_mem_alloc_impl((mem), 1, alloca(TRE_MEM_BLOCK_SIZE), 0, (size)))
|
||||
#endif /* TRE_USE_ALLOCA */
|
||||
|
||||
|
||||
/* Frees the memory allocator and all memory allocated with it. */
|
||||
hidden void tre_mem_destroy(tre_mem_t mem);
|
||||
|
||||
#define xmalloc malloc
|
||||
#define xcalloc calloc
|
||||
#define xfree free
|
||||
#define xrealloc realloc
|
||||
|
||||
#endif /* !__MLIBC_ABI_ONLY */
|
||||
Reference in New Issue
Block a user