]> Savannah Git Hosting - gnulib.git/commitdiff
exclude: refactor for more-modern style
authorPaul Eggert <eggert@cs.ucla.edu>
Thu, 24 Aug 2023 15:50:00 +0000 (09:50 -0600)
committerPaul Eggert <eggert@cs.ucla.edu>
Thu, 24 Aug 2023 16:03:46 +0000 (10:03 -0600)
* lib/exclude.c: Sort include directives.
(fnmatch_pattern_has_wildcards, file_name_matches):
Prefer ‘true’ to ‘1’.
(string_hasher, string_compare, string_compare_ci):
Avoid unnecessary locals.
(string_free): Remove.  All callers changed to just use ‘free’.
(new_exclude_segment): Prefer xmalloc to xzalloc when it’s
clearer to initialize ourselves.
(new_exclude_segment, exclude_patopts, add_exclude_fp):
Prefer nullptr to NULL.
(free_exclude_segment, file_pattern_matches):
Avoid unnecessary nesting.
(free_exclude, fnmatch_no_wildcards, exclude_fnmatch)
(excluded_file_name, add_exclude, add_exclude_fp):
Assume C99 decl syntax.
(fnmatch_no_wildcards): Prefer idx_t to size_t.
(exclude_fnmatch, add_exclude_fp): Prefer ‘f (x)’ to ‘(*f) (x)’.
(add_exclude): Help compiler by refactoring search for
trailing slashes.  Avoid unnecessary cast to char *.
* modules/exclude (Depends-on): Add nullptr.

ChangeLog
lib/exclude.c
modules/exclude

index 0583de673071722f5c272fe55b61d69720826a24..06a00a691d6dc1d12d515146915d3c3c35cb189b 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,27 @@
+2023-08-24  Paul Eggert  <eggert@cs.ucla.edu>
+
+       exclude: refactor for more-modern style
+       * lib/exclude.c: Sort include directives.
+       (fnmatch_pattern_has_wildcards, file_name_matches):
+       Prefer ‘true’ to ‘1’.
+       (string_hasher, string_compare, string_compare_ci):
+       Avoid unnecessary locals.
+       (string_free): Remove.  All callers changed to just use ‘free’.
+       (new_exclude_segment): Prefer xmalloc to xzalloc when it’s
+       clearer to initialize ourselves.
+       (new_exclude_segment, exclude_patopts, add_exclude_fp):
+       Prefer nullptr to NULL.
+       (free_exclude_segment, file_pattern_matches):
+       Avoid unnecessary nesting.
+       (free_exclude, fnmatch_no_wildcards, exclude_fnmatch)
+       (excluded_file_name, add_exclude, add_exclude_fp):
+       Assume C99 decl syntax.
+       (fnmatch_no_wildcards): Prefer idx_t to size_t.
+       (exclude_fnmatch, add_exclude_fp): Prefer ‘f (x)’ to ‘(*f) (x)’.
+       (add_exclude): Help compiler by refactoring search for
+       trailing slashes.  Avoid unnecessary cast to char *.
+       * modules/exclude (Depends-on): Add nullptr.
+
 2023-08-21  Paul Eggert  <eggert@cs.ucla.edu>
 
        unlocked-io: fix getc_unlocked typo
index 15f238e09c2f1052576856517a0d861ca3d1f5bb..d1ecaedfc6b6978e7dc7b519ee9d8af14e12b83a 100644 (file)
 
 #include <ctype.h>
 #include <errno.h>
+#include <regex.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <uchar.h>
-#include <regex.h>
 
 #include "exclude.h"
+#include "filename.h"
+#include "fnmatch.h"
 #include "hash.h"
 #include "mbuiter.h"
-#include "fnmatch.h"
 #include "xalloc.h"
-#include "filename.h"
 
 #if GNULIB_EXCLUDE_SINGLE_THREAD
 # include "unlocked-io.h"
@@ -139,7 +139,7 @@ exclude_add_pattern_buffer (struct exclude *ex, char *buf)
 bool
 fnmatch_pattern_has_wildcards (const char *str, int options)
 {
-  while (1)
+  while (true)
     {
       switch (*str++)
         {
@@ -194,8 +194,7 @@ new_exclude (void)
 static size_t
 string_hasher (void const *data, size_t n_buckets)
 {
-  char const *p = data;
-  return hash_string (p, n_buckets);
+  return hash_string (data, n_buckets);
 }
 
 /* Ditto, for case-insensitive hashes */
@@ -203,9 +202,9 @@ static size_t
 string_hasher_ci (void const *data, size_t n_buckets)
 {
   char const *p = data;
-  mbui_iterator_t iter;
   size_t value = 0;
 
+  mbui_iterator_t iter;
   for (mbui_init (iter, p); mbui_avail (iter); mbui_advance (iter))
     {
       mbchar_t m = mbui_cur (iter);
@@ -226,24 +225,14 @@ string_hasher_ci (void const *data, size_t n_buckets)
 static bool
 string_compare (void const *data1, void const *data2)
 {
-  char const *p1 = data1;
-  char const *p2 = data2;
-  return strcmp (p1, p2) == 0;
+  return strcmp (data1, data2) == 0;
 }
 
 /* compare two strings for equality, case-insensitive */
 static bool
 string_compare_ci (void const *data1, void const *data2)
 {
-  char const *p1 = data1;
-  char const *p2 = data2;
-  return mbscasecmp (p1, p2) == 0;
-}
-
-static void
-string_free (void *data)
-{
-  free (data);
+  return mbscasecmp (data1, data2) == 0;
 }
 
 /* Create new exclude segment of given TYPE and OPTIONS, and attach it
@@ -251,23 +240,24 @@ string_free (void *data)
 static void
 new_exclude_segment (struct exclude *ex, enum exclude_type type, int options)
 {
-  struct exclude_segment *sp = xzalloc (sizeof (struct exclude_segment));
+  struct exclude_segment *sp = xmalloc (sizeof (struct exclude_segment));
   sp->type = type;
   sp->options = options;
   switch (type)
     {
     case exclude_pattern:
+      sp->v.pat = (struct exclude_pattern) {0};
       break;
 
     case exclude_hash:
-      sp->v.table = hash_initialize (0, NULL,
-                                     (options & FNM_CASEFOLD) ?
-                                       string_hasher_ci
-                                       : string_hasher,
-                                     (options & FNM_CASEFOLD) ?
-                                       string_compare_ci
-                                       : string_compare,
-                                     string_free);
+      sp->v.table = hash_initialize (0, nullptr,
+                                     (options & FNM_CASEFOLD
+                                      ? string_hasher_ci
+                                      : string_hasher),
+                                     (options & FNM_CASEFOLD
+                                      ? string_compare_ci
+                                      : string_compare),
+                                     free);
       break;
     }
   sp->next = ex->head;
@@ -282,10 +272,8 @@ free_exclude_segment (struct exclude_segment *seg)
     {
     case exclude_pattern:
       for (idx_t i = 0; i < seg->v.pat.exclude_count; i++)
-        {
-          if (seg->v.pat.exclude[i].options & EXCLUDE_REGEX)
-            regfree (&seg->v.pat.exclude[i].v.re);
-        }
+        if (seg->v.pat.exclude[i].options & EXCLUDE_REGEX)
+          regfree (&seg->v.pat.exclude[i].v.re);
       free (seg->v.pat.exclude);
       break;
 
@@ -300,17 +288,14 @@ free_exclude_segment (struct exclude_segment *seg)
 void
 free_exclude (struct exclude *ex)
 {
-  struct exclude_segment *seg;
-  struct pattern_buffer *pbuf;
-
-  for (seg = ex->head; seg; )
+  for (struct exclude_segment *seg = ex->head; seg; )
     {
       struct exclude_segment *next = seg->next;
       free_exclude_segment (seg);
       seg = next;
     }
 
-  for (pbuf = ex->patbuf; pbuf; )
+  for (struct pattern_buffer *pbuf = ex->patbuf; pbuf; )
     {
       struct pattern_buffer *next = pbuf->next;
       free (pbuf->base);
@@ -333,7 +318,7 @@ fnmatch_no_wildcards (char const *pattern, char const *f, int options)
             : strcmp (pattern, f));
   else if (! (options & FNM_CASEFOLD))
     {
-      size_t patlen = strlen (pattern);
+      idx_t patlen = strlen (pattern);
       int r = strncmp (pattern, f, patlen);
       if (! r)
         {
@@ -353,9 +338,8 @@ fnmatch_no_wildcards (char const *pattern, char const *f, int options)
          will probably involve a change to the mbs* API.  */
 
       char *fcopy = xstrdup (f);
-      char *p;
       int r;
-      for (p = fcopy; ; *p++ = '/')
+      for (char *p = fcopy; ; *p++ = '/')
         {
           p = strchr (p, '/');
           if (p)
@@ -376,13 +360,12 @@ exclude_fnmatch (char const *pattern, char const *f, int options)
     (options & EXCLUDE_WILDCARDS
      ? fnmatch
      : fnmatch_no_wildcards);
-  bool matched = ((*matcher) (pattern, f, options) == 0);
-  char const *p;
+  bool matched = matcher (pattern, f, options) == 0;
 
   if (! (options & EXCLUDE_ANCHORED))
-    for (p = f; *p && ! matched; p++)
+    for (char const *p = f; *p && ! matched; p++)
       if (*p == '/' && p[1] != '/')
-        matched = ((*matcher) (pattern, p + 1, options) == 0);
+        matched = matcher (pattern, p + 1, options) == 0;
 
   return matched;
 }
@@ -392,9 +375,9 @@ exclude_patopts (struct patopts const *opts, char const *f)
 {
   int options = opts->options;
 
-  return (options & EXCLUDE_REGEX)
-          ? regexec (&opts->v.re, f, 0, NULL, 0) == 0
-          : exclude_fnmatch (opts->v.pattern, f, options);
+  return (options & EXCLUDE_REGEX
+          ? regexec (&opts->v.re, f, 0, nullptr, 0) == 0
+          : exclude_fnmatch (opts->v.pattern, f, options));
 }
 
 /* Return true if the exclude_pattern segment SEG matches F.  */
@@ -406,10 +389,8 @@ file_pattern_matches (struct exclude_segment const *seg, char const *f)
   struct patopts const *exclude = seg->v.pat.exclude;
 
   for (idx_t i = 0; i < exclude_count; i++)
-    {
-      if (exclude_patopts (exclude + i, f))
-        return true;
-    }
+    if (exclude_patopts (exclude + i, f))
+      return true;
   return false;
 }
 
@@ -428,7 +409,7 @@ file_name_matches (struct exclude_segment const *seg, char const *f,
       /* initialize the pattern */
       strcpy (buffer, f);
 
-      while (1)
+      while (true)
         {
           if (hash_lookup (table, buffer))
             return true;
@@ -437,7 +418,7 @@ file_name_matches (struct exclude_segment const *seg, char const *f,
               char *p = strrchr (buffer, '/');
               if (p)
                 {
-                  *p = 0;
+                  *p = '\0';
                   continue;
                 }
             }
@@ -463,17 +444,17 @@ file_name_matches (struct exclude_segment const *seg, char const *f,
 bool
 excluded_file_name (struct exclude const *ex, char const *f)
 {
-  struct exclude_segment *seg;
-  bool invert = false;
-  char *filename = NULL;
-
   /* If no patterns are given, the default is to include.  */
   if (!ex->head)
     return false;
 
+  bool invert = false;
+  char *filename = nullptr;
+
   /* Scan through the segments, reporting the status of the first match.
      The segments are in reverse order, so this reports the status of
      the last match in the original option list.  */
+  struct exclude_segment *seg;
   for (seg = ex->head; ; seg = seg->next)
     {
       if (seg->type == exclude_hash)
@@ -511,10 +492,6 @@ excluded_file_name (struct exclude const *ex, char const *f)
 void
 add_exclude (struct exclude *ex, char const *pattern, int options)
 {
-  struct exclude_segment *seg;
-  struct exclude_pattern *pat;
-  struct patopts *patopts;
-
   if ((options & (EXCLUDE_REGEX|EXCLUDE_WILDCARDS))
       && fnmatch_pattern_has_wildcards (pattern, options))
     {
@@ -523,42 +500,40 @@ add_exclude (struct exclude *ex, char const *pattern, int options)
                  == (options & EXCLUDE_INCLUDE))))
         new_exclude_segment (ex, exclude_pattern, options);
 
-      seg = ex->head;
-
-      pat = &seg->v.pat;
+      struct exclude_pattern *pat = &ex->head->v.pat;
       if (pat->exclude_count == pat->exclude_alloc)
         pat->exclude = xpalloc (pat->exclude, &pat->exclude_alloc, 1, -1,
                                 sizeof *pat->exclude);
-      patopts = &pat->exclude[pat->exclude_count++];
+      struct patopts *patopts = &pat->exclude[pat->exclude_count++];
 
       patopts->options = options;
       if (options & EXCLUDE_REGEX)
         {
           int rc;
-          int cflags = REG_NOSUB|REG_EXTENDED|
-                       ((options & FNM_CASEFOLD) ? REG_ICASE : 0);
+          int cflags = (REG_NOSUB | REG_EXTENDED
+                        | (options & FNM_CASEFOLD ? REG_ICASE : 0));
 
-          if (options & FNM_LEADING_DIR)
-            {
-              char *tmp;
-              idx_t len = strlen (pattern);
-
-              while (len > 0 && ISSLASH (pattern[len-1]))
-                --len;
-
-              if (len == 0)
-                rc = 1;
-              else
-                {
-                  tmp = ximalloc (len + 7);
-                  memcpy (tmp, pattern, len);
-                  strcpy (tmp + len, "(/.*)?");
-                  rc = regcomp (&patopts->v.re, tmp, cflags);
-                  free (tmp);
-                }
-            }
-          else
+          if (! (options & FNM_LEADING_DIR))
             rc = regcomp (&patopts->v.re, pattern, cflags);
+          else
+            for (idx_t len = strlen (pattern); ; len--)
+              {
+                if (len == 0)
+                  {
+                    rc = 1;
+                    break;
+                  }
+                if (!ISSLASH (pattern[len - 1]))
+                  {
+                    static char const patsuffix[] = "(/.*)?";
+                    char *tmp = ximalloc (len + sizeof patsuffix);
+                    memcpy (tmp, pattern, len);
+                    strcpy (tmp + len, patsuffix);
+                    rc = regcomp (&patopts->v.re, tmp, cflags);
+                    free (tmp);
+                    break;
+                  }
+              }
 
           if (rc)
             {
@@ -570,28 +545,26 @@ add_exclude (struct exclude *ex, char const *pattern, int options)
         {
           if (options & EXCLUDE_ALLOC)
             {
-              pattern = xstrdup (pattern);
-              exclude_add_pattern_buffer (ex, (char*) pattern);
+              char *dup = xstrdup (pattern);
+              pattern = dup;
+              exclude_add_pattern_buffer (ex, dup);
             }
           patopts->v.pattern = pattern;
         }
     }
   else
     {
-      char *str, *p;
       int exclude_hash_flags = (EXCLUDE_INCLUDE | EXCLUDE_ANCHORED
                                 | FNM_LEADING_DIR | FNM_CASEFOLD);
       if (! (ex->head && ex->head->type == exclude_hash
              && ((ex->head->options & exclude_hash_flags)
                  == (options & exclude_hash_flags))))
         new_exclude_segment (ex, exclude_hash, options);
-      seg = ex->head;
 
-      str = xstrdup (pattern);
+      char *str = xstrdup (pattern);
       if ((options & (EXCLUDE_WILDCARDS | FNM_NOESCAPE)) == EXCLUDE_WILDCARDS)
         unescape_pattern (str);
-      p = hash_insert (seg->v.table, str);
-      if (p != str)
+      if (hash_insert (ex->head->v.table, str) != str)
         free (str);
     }
 }
@@ -604,43 +577,43 @@ add_exclude (struct exclude *ex, char const *pattern, int options)
 int
 add_exclude_fp (void (*add_func) (struct exclude *, char const *, int, void *),
                 struct exclude *ex, FILE *fp, int options,
-                char line_end,
-                void *data)
+                char line_end, void *data)
 {
-  char *buf = NULL;
-  char *p;
-  char *pattern;
-  char const *lim;
+  char *buf = nullptr;
   idx_t buf_alloc = 0;
   idx_t buf_count = 0;
-  int c;
-  int e = 0;
 
-  while ((c = getc (fp)) != EOF)
+  for (int c; (c = getc (fp)) != EOF; )
     {
       if (buf_count == buf_alloc)
         buf = xpalloc (buf, &buf_alloc, 1, -1, 1);
       buf[buf_count++] = c;
     }
 
-  if (ferror (fp))
-    e = errno;
+  int e = ferror (fp) ? errno : 0;
 
   buf = xirealloc (buf, buf_count + 1);
   buf[buf_count] = line_end;
-  lim = buf + buf_count + ! (buf_count == 0 || buf[buf_count - 1] == line_end);
+  char const *lim = (buf + buf_count
+                     + ! (buf_count == 0 || buf[buf_count - 1] == line_end));
 
   exclude_add_pattern_buffer (ex, buf);
 
-  pattern = buf;
+  char *pattern = buf;
 
-  for (p = buf; p < lim; p++)
+  for (char *p = buf; p < lim; p++)
     if (*p == line_end)
       {
         char *pattern_end = p;
 
         if (isspace ((unsigned char) line_end))
           {
+            /* Assume that no multi-byte character has a trailing byte
+               that satisfies isspace, and that nobody cares about
+               trailing white space containing non-single-byte characters.
+               If either assumption turns out to be false, presumably
+               the code should be changed to scan forward through the
+               entire pattern, one multi-byte character at a time.  */
             for (; ; pattern_end--)
               if (pattern_end == pattern)
                 goto next_pattern;
@@ -649,7 +622,7 @@ add_exclude_fp (void (*add_func) (struct exclude *, char const *, int, void *),
           }
 
         *pattern_end = '\0';
-        (*add_func) (ex, pattern, options, data);
+        add_func (ex, pattern, options, data);
 
       next_pattern:
         pattern = p + 1;
@@ -679,7 +652,7 @@ add_exclude_file (void (*add_func) (struct exclude *, char const *, int),
     return -1;
   int rc = add_exclude_fp (call_addfn, ex, in, options, line_end, &add_func);
   int e = errno;
-  if (fclose (in) != 0)
+  if (fclose (in) < 0)
     return -1;
   errno = e;
   return rc;
index bef926307f12d7cdcbf311f624a52dfdb3db5c5c..8adae5400f21d9414db4df2644d46fe4d930c3d3 100644 (file)
@@ -14,6 +14,7 @@ fopen-gnu
 hash
 mbscasecmp
 mbuiter
+nullptr
 regex
 stdbool
 unlocked-io-internal