From: Paul Eggert Date: Wed, 4 Jun 2003 23:35:46 +0000 (+0000) Subject: import from gnulib X-Git-Url: https://git.dogcows.com/gitweb?a=commitdiff_plain;h=e547e855e945ff002b96f414a5536bea12be407a;p=chaz%2Ftar import from gnulib --- diff --git a/lib/exclude.c b/lib/exclude.c index ebb599c..75042cb 100644 --- a/lib/exclude.c +++ b/lib/exclude.c @@ -1,5 +1,7 @@ /* exclude.c -- exclude file names - Copyright 1992, 1993, 1994, 1997 Free Software Foundation, Inc. + + Copyright (C) 1992, 1993, 1994, 1997, 1999, 2000, 2001, 2002, 2003 Free + Software Foundation, Inc. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -22,72 +24,205 @@ # include #endif +#include + #include #ifndef errno extern int errno; #endif -#include -#include +#include #include -#include +#if HAVE_STDLIB_H +# include +#endif +#if HAVE_STRING_H +# include +#endif +#if HAVE_STRINGS_H +# include +#endif +#if HAVE_INTTYPES_H +# include +#else +# if HAVE_STDINT_H +# include +# endif +#endif -void *xmalloc PARAMS ((size_t)); -void *xrealloc PARAMS ((void *, size_t)); +#include "exclude.h" +#include "fnmatch.h" +#include "unlocked-io.h" +#include "xalloc.h" + +#ifndef SIZE_MAX +# define SIZE_MAX ((size_t) -1) +#endif + +/* Verify a requirement at compile-time (unlike assert, which is runtime). */ +#define verify(name, assertion) struct name { char a[(assertion) ? 1 : -1]; } + +/* Non-GNU systems lack these options, so we don't need to check them. */ +#ifndef FNM_CASEFOLD +# define FNM_CASEFOLD 0 +#endif +#ifndef FNM_LEADING_DIR +# define FNM_LEADING_DIR 0 +#endif -/* Keep track of excluded file name patterns. */ +verify (EXCLUDE_macros_do_not_collide_with_FNM_macros, + (((EXCLUDE_ANCHORED | EXCLUDE_INCLUDE | EXCLUDE_WILDCARDS) + & (FNM_PATHNAME | FNM_NOESCAPE | FNM_PERIOD | FNM_LEADING_DIR + | FNM_CASEFOLD)) + == 0)); + +/* An exclude pattern-options pair. The options are fnmatch options + ORed with EXCLUDE_* options. */ + +struct patopts + { + char const *pattern; + int options; + }; + +/* An exclude list, of pattern-options pairs. */ struct exclude { - char const **exclude; - int exclude_alloc; - int exclude_count; + struct patopts *exclude; + size_t exclude_alloc; + size_t exclude_count; }; +/* Return a newly allocated and empty exclude list. */ + struct exclude * new_exclude (void) { - struct exclude *ex = (struct exclude *) xmalloc (sizeof (struct exclude)); + struct exclude *ex = xmalloc (sizeof *ex); ex->exclude_count = 0; - ex->exclude_alloc = 64; - ex->exclude = (char const **) xmalloc (ex->exclude_alloc * sizeof (char *)); + ex->exclude_alloc = (1 << 6); /* This must be a power of 2. */ + ex->exclude = xmalloc (ex->exclude_alloc * sizeof ex->exclude[0]); return ex; } -int +/* Free the storage associated with an exclude list. */ + +void +free_exclude (struct exclude *ex) +{ + free (ex->exclude); + free (ex); +} + +/* Return zero if PATTERN matches F, obeying OPTIONS, except that + (unlike fnmatch) wildcards are disabled in PATTERN. */ + +static int +fnmatch_no_wildcards (char const *pattern, char const *f, int options) +{ + if (! (options & FNM_LEADING_DIR)) + return ((options & FNM_CASEFOLD) + ? strcasecmp (pattern, f) + : strcmp (pattern, f)); + else + { + size_t patlen = strlen (pattern); + int r = ((options & FNM_CASEFOLD) + ? strncasecmp (pattern, f, patlen) + : strncmp (pattern, f, patlen)); + if (! r) + { + r = f[patlen]; + if (r == '/') + r = 0; + } + return r; + } +} + +/* Return true if EX excludes F. */ + +bool excluded_filename (struct exclude const *ex, char const *f) { - char const * const *exclude = ex->exclude; - int exclude_count = ex->exclude_count; - int i; + size_t exclude_count = ex->exclude_count; + + /* If no options are given, the default is to include. */ + if (exclude_count == 0) + return false; + else + { + struct patopts const *exclude = ex->exclude; + size_t i; + + /* Otherwise, the default is the opposite of the first option. */ + bool excluded = !! (exclude[0].options & EXCLUDE_INCLUDE); + + /* Scan through the options, seeing whether they change F from + excluded to included or vice versa. */ + for (i = 0; i < exclude_count; i++) + { + char const *pattern = exclude[i].pattern; + int options = exclude[i].options; + if (excluded == !! (options & EXCLUDE_INCLUDE)) + { + int (*matcher) (char const *, char const *, int) = + (options & EXCLUDE_WILDCARDS + ? fnmatch + : fnmatch_no_wildcards); + bool matched = ((*matcher) (pattern, f, options) == 0); + char const *p; - for (i = 0; i < exclude_count; i++) - if (fnmatch (exclude[i], f, 0) == 0) - return 1; + if (! (options & EXCLUDE_ANCHORED)) + for (p = f; *p && ! matched; p++) + if (*p == '/' && p[1] != '/') + matched = ((*matcher) (pattern, p + 1, options) == 0); - return 0; + excluded ^= matched; + } + } + + return excluded; + } } +/* Append to EX the exclusion PATTERN with OPTIONS. */ + void -add_exclude (struct exclude *ex, char const *pattern) +add_exclude (struct exclude *ex, char const *pattern, int options) { + struct patopts *patopts; + if (ex->exclude_alloc <= ex->exclude_count) - ex->exclude = (char const **) xrealloc (ex->exclude, - ((ex->exclude_alloc *= 2) - * sizeof (char *))); + { + size_t s = 2 * ex->exclude_alloc; + if (! (0 < s && s <= SIZE_MAX / sizeof ex->exclude[0])) + xalloc_die (); + ex->exclude_alloc = s; + ex->exclude = xrealloc (ex->exclude, s * sizeof ex->exclude[0]); + } - ex->exclude[ex->exclude_count++] = pattern; + patopts = &ex->exclude[ex->exclude_count++]; + patopts->pattern = pattern; + patopts->options = options; } +/* Use ADD_FUNC to append to EX the patterns in FILENAME, each with + OPTIONS. LINE_END terminates each pattern in the file. Return -1 + on failure, 0 on success. */ + int -add_exclude_file (struct exclude *ex, char const *filename, char line_end) +add_exclude_file (void (*add_func) (struct exclude *, char const *, int), + struct exclude *ex, char const *filename, int options, + char line_end) { - int use_stdin = filename[0] == '-' && !filename[1]; + bool use_stdin = filename[0] == '-' && !filename[1]; FILE *in; char *buf; char *p; char const *pattern; char const *lim; - size_t buf_alloc = 1024; + size_t buf_alloc = (1 << 10); /* This must be a power of two. */ size_t buf_count = 0; int c; int e = 0; @@ -103,22 +238,27 @@ add_exclude_file (struct exclude *ex, char const *filename, char line_end) { buf[buf_count++] = c; if (buf_count == buf_alloc) - buf = xrealloc (buf, buf_alloc *= 2); + { + buf_alloc *= 2; + if (! buf_alloc) + xalloc_die (); + buf = xrealloc (buf, buf_alloc); + } } - buf = xrealloc (buf, buf_count + 1); - if (ferror (in)) e = errno; if (!use_stdin && fclose (in) != 0) e = errno; + buf = xrealloc (buf, buf_count + 1); + for (pattern = p = buf, lim = buf + buf_count; p <= lim; p++) if (p < lim ? *p == line_end : buf < p && p[-1]) { *p = '\0'; - add_exclude (ex, pattern); + (*add_func) (ex, pattern, options); pattern = p + 1; }