X-Git-Url: http://git.refcnt.org/?p=colorize.git;a=blobdiff_plain;f=colorize.c;h=8a1cb5236adc3edd3e268afe70acef24eab4a658;hp=d527e5eff4f2f79f0b85b2bb259b69f4518779cd;hb=HEAD;hpb=ae049342a1a513093ba4f3f56af2194ef2707da0

diff --git a/colorize.c b/colorize.c
index d527e5e..a1e1398 100644
--- a/colorize.c
+++ b/colorize.c
@@ -81,12 +81,14 @@
 
 #define VALID_FILE_TYPE(mode) (S_ISREG (mode) || S_ISLNK (mode) || S_ISFIFO (mode))
 
-#define STACK_VAR(ptr) do {                                   \
-    stack_var (&vars_list, &stacked_vars, stacked_vars, ptr); \
+#define STACK_VAR(ptr) do {                                           \
+    stack (&vars_list, &stacked_vars, stacked_vars, ptr, IS_GENERIC); \
 } while (false)
-
-#define RELEASE_VAR(ptr) do {                             \
-    release_var (vars_list, stacked_vars, (void **)&ptr); \
+#define STACK_FILE(ptr) do {                                       \
+    stack (&vars_list, &stacked_vars, stacked_vars, ptr, IS_FILE); \
+} while (false)
+#define RELEASE(ptr) do {                             \
+    release (vars_list, stacked_vars, (void **)&ptr); \
 } while (false)
 
 #if !DEBUG
@@ -266,13 +268,23 @@ struct attr {
     enum attr_type type;
 };
 
+enum var_type {
+    IS_GENERIC,
+    IS_FILE,
+    IS_UNUSED
+};
+struct var_list {
+    void *ptr;
+    enum var_type type;
+};
+
 static FILE *stream;
 #if DEBUG
 static FILE *log;
 #endif
 
 static unsigned int stacked_vars;
-static void **vars_list;
+static struct var_list *vars_list;
 
 static bool clean;
 static bool clean_all;
@@ -344,10 +356,8 @@ static bool has_color_name (const char *, const char *);
 static FILE *open_file (const char *, const char *);
 static void vfprintf_diag (const char *, ...);
 static void vfprintf_fail (const char *, ...);
-static void stack_var (void ***, unsigned int *, unsigned int, void *);
-static void release_var (void **, unsigned int, void **);
-
-extern int optind;
+static void stack (struct var_list **, unsigned int *, unsigned int, void *, enum var_type);
+static void release (struct var_list *, unsigned int, void **);
 
 int
 main (int argc, char **argv)
@@ -372,6 +382,11 @@ main (int argc, char **argv)
 #if DEBUG
     log = open_file (DEBUG_FILE, "w");
     print_tstamp (log);
+    /* We're in debugging mode, hence we can't invoke STACK_FILE()
+       prior to print_tstamp(), because both cause text to be written
+       to the same logfile which is expected to have the timestamp
+       first.  */
+    STACK_FILE (log);
 #endif
 
     attr[0] = '\0';
@@ -382,7 +397,10 @@ main (int argc, char **argv)
     conf_file = to_str (CONF_FILE_TEST);
 #elif !defined(TEST)
     if (conf_file == NULL)
-      conf_file_path (&conf_file);
+      {
+        conf_file_path (&conf_file);
+        STACK_VAR (conf_file);
+      }
     else
       {
         char *s;
@@ -391,6 +409,7 @@ main (int argc, char **argv)
             free (conf_file);
             conf_file = s;
           }
+        STACK_VAR (conf_file);
         errno = 0;
         if (access (conf_file, F_OK) == -1)
           vfprintf_fail (formats[FMT_CONF_FILE], conf_file, strerror (errno));
@@ -401,7 +420,7 @@ main (int argc, char **argv)
       parse_conf (conf_file, &config);
 #endif
 #if !defined(CONF_FILE_TEST) && !defined(TEST)
-    free (conf_file);
+    RELEASE (conf_file);
 #endif
     init_conf_vars (&config);
 
@@ -434,7 +453,7 @@ main (int argc, char **argv)
       {
         if (arg_cnt == 0 || arg_cnt > 2)
           {
-            vfprintf_diag ("%u arguments provided, expected 1-2 arguments or clean option", arg_cnt);
+            vfprintf_diag ("%u arguments provided, expected 1-2 arguments or --clean[-all]", arg_cnt);
             print_hint ();
             exit (EXIT_FAILURE);
           }
@@ -448,7 +467,7 @@ main (int argc, char **argv)
 
     free_conf (&config);
 
-    RELEASE_VAR (exclude);
+    RELEASE (exclude);
 
     exit (EXIT_SUCCESS);
 }
@@ -492,8 +511,6 @@ print_tstamp (FILE *log)
     print_version ();        \
     exit (EXIT_SUCCESS);
 
-extern char *optarg;
-
 static void
 process_opts (int argc, char **argv, char **conf_file)
 {
@@ -508,6 +525,7 @@ process_opts (int argc, char **argv, char **conf_file)
                   case OPT_ATTR:
                     opts_set |= OPT_ATTR_SET;
                     opts_arg.attr = xstrdup (optarg);
+                    STACK_VAR (opts_arg.attr);
                     break;
                   case OPT_CLEAN:
                     clean = true;
@@ -520,6 +538,7 @@ process_opts (int argc, char **argv, char **conf_file)
                   case OPT_EXCLUDE_RANDOM:
                     opts_set |= OPT_EXCLUDE_RANDOM_SET;
                     opts_arg.exclude_random = xstrdup (optarg);
+                    STACK_VAR (opts_arg.exclude_random);
                     break;
                   case OPT_OMIT_COLOR_EMPTY:
                     opts_set |= OPT_OMIT_COLOR_EMPTY_SET;
@@ -565,6 +584,7 @@ conf_file_path (char **conf_file)
           perror ("getpwuid");
         exit (EXIT_FAILURE);
       }
+    /* getpwuid() leaks memory */
     size = strlen (passwd->pw_dir) + 1 + strlen (CONF_FILE) + 1;
     path = xmalloc (size);
     snprintf (path, size, "%s/%s", passwd->pw_dir, CONF_FILE);
@@ -590,10 +610,10 @@ process_opt_attr (const char *p, const bool is_opt)
     while (*p)
       {
         const char *s;
-        if (!isalnum (*p))
+        if (!isalnum ((unsigned char)*p))
           vfprintf_fail ("%s must be provided a string", desc_type[DESC_TYPE]);
         s = p;
-        while (isalnum (*p))
+        while (isalnum ((unsigned char)*p))
           p++;
         if (*p != '\0' && *p != ',')
           vfprintf_fail ("%s must have strings separated by ,", desc_type[DESC_TYPE]);
@@ -618,7 +638,7 @@ process_opt_attr (const char *p, const bool is_opt)
                 strncpy (attr_invalid, s, p - s);
                 attr_invalid[p - s] = '\0';
                 vfprintf_fail ("%s attribute '%s' is not valid", desc_type[DESC_TYPE], attr_invalid);
-                RELEASE_VAR (attr_invalid); /* never reached */
+                RELEASE (attr_invalid); /* never reached */
               }
           }
         if (*p)
@@ -645,7 +665,7 @@ process_opt_exclude_random (const char *s, const bool is_opt)
 {
     bool valid = false;
     unsigned int i;
-    RELEASE_VAR (exclude);
+    RELEASE (exclude);
     exclude = xstrdup (s);
     STACK_VAR (exclude);
     for (i = 1; i < tables[GENERIC].count - 1; i++) /* skip color none and default */
@@ -675,8 +695,8 @@ init_opts_vars (void)
     if (opts_set & OPT_OMIT_COLOR_EMPTY_SET)
       omit_color_empty = true;
 
-    free (opts_arg.attr);
-    free (opts_arg.exclude_random);
+    RELEASE (opts_arg.attr);
+    RELEASE (opts_arg.exclude_random);
 }
 
 #define IS_SPACE(c) ((c) == ' ' || (c) == '\t')
@@ -689,6 +709,7 @@ parse_conf (const char *conf_file, struct conf *config)
     FILE *conf;
 
     conf = open_file (conf_file, "r");
+    STACK_FILE (conf);
 
     while (fgets (line, sizeof (line), conf))
       {
@@ -727,7 +748,7 @@ parse_conf (const char *conf_file, struct conf *config)
 /* NAME PARSING (end) */
 /* NAME VALIDATION (start) */
         for (p = opt; *p; p++)
-          if (!isalnum (*p) && *p != '-')
+          if (!isalnum ((unsigned char)*p) && *p != '-')
             vfprintf_fail (formats[FMT_CONF], conf_file, opt, "cannot be made of non-option characters");
 /* NAME VALIDATION (end) */
 /* VALUE PARSING (start) */
@@ -751,18 +772,20 @@ parse_conf (const char *conf_file, struct conf *config)
 
         /* save option name */
         cfg = xstrdup (opt);
+        STACK_VAR (cfg);
         /* save option value (allow empty ones) */
         val = strlen (value) ? xstrdup (value) : NULL;
+        STACK_VAR (val);
 
         assign_conf (conf_file, config, cfg, val);
-        free (cfg);
+        RELEASE (cfg);
       }
 
-    fclose (conf);
+    RELEASE (conf);
 }
 
 #define ASSIGN_CONF(str,val) do { \
-    free (str);                   \
+    RELEASE (str);                \
     str = val;                    \
 } while (false)
 
@@ -832,7 +855,7 @@ print_help (void)
         const char *code = entry->code;
         if (code)
           printf ("\t\t{\033[%s#\033[0m} [%c%c]%s%*s%s\n",
-                   code, toupper (*name), *name, name + 1, 10 - (int)strlen (name), " ", name);
+                   code, toupper ((unsigned char)*name), *name, name + 1, 10 - (int)strlen (name), " ", name);
         else
           printf ("\t\t{-} %s%*s%s\n", name, 13 - (int)strlen (name), " ", name);
       }
@@ -926,17 +949,32 @@ static void
 cleanup (void)
 {
     if (stream && fileno (stream) != STDIN_FILENO)
-      fclose (stream);
+      RELEASE (stream);
 #if DEBUG
     if (log)
-      fclose (log);
+      RELEASE (log);
 #endif
 
     if (vars_list)
       {
         unsigned int i;
         for (i = 0; i < stacked_vars; i++)
-          free (vars_list[i]);
+          {
+            struct var_list *var = &vars_list[i];
+            switch (var->type)
+              {
+                case IS_GENERIC:
+                  free (var->ptr);
+                  break;
+                case IS_FILE:
+                  fclose (var->ptr);
+                  break;
+                case IS_UNUSED:
+                  break;
+                default: /* never reached */
+                  ABORT_TRACE ();
+              }
+          }
         free_null (vars_list);
       }
 }
@@ -947,19 +985,19 @@ free_color_names (struct color_name **color_names)
     unsigned int i;
     for (i = 0; color_names[i]; i++)
       {
-        RELEASE_VAR (color_names[i]->name);
-        RELEASE_VAR (color_names[i]->orig);
-        RELEASE_VAR (color_names[i]);
+        RELEASE (color_names[i]->name);
+        RELEASE (color_names[i]->orig);
+        RELEASE (color_names[i]);
       }
 }
 
 static void
 free_conf (struct conf *config)
 {
-    free (config->attr);
-    free (config->color);
-    free (config->exclude_random);
-    free (config->omit_color_empty);
+    RELEASE (config->attr);
+    RELEASE (config->color);
+    RELEASE (config->exclude_random);
+    RELEASE (config->omit_color_empty);
 }
 
 static void
@@ -1072,6 +1110,7 @@ process_file_arg (const char *file_string, const char **file, FILE **stream)
               vfprintf_fail (formats[FMT_TYPE], file, "unrecognized type", get_file_type (sb.st_mode));
 
             *stream = open_file (file, "r");
+            STACK_FILE (*stream);
           }
         *file = file_string;
       }
@@ -1164,17 +1203,17 @@ gather_color_names (const char *color_string, char *attr, struct color_name **co
         assert (p != NULL);
 
         for (ch = color; *ch; ch++)
-          if (!isalpha (*ch))
+          if (!isalpha ((unsigned char)*ch))
             vfprintf_fail (formats[FMT_COLOR], tables[index].desc, color, "cannot be made of non-alphabetic characters");
 
         for (ch = color + 1; *ch; ch++)
-          if (!islower (*ch))
+          if (!islower ((unsigned char)*ch))
             vfprintf_fail (formats[FMT_COLOR], tables[index].desc, color, "cannot be in mixed lower/upper case");
 
         if (streq (color, "None"))
           vfprintf_fail (formats[FMT_COLOR], tables[index].desc, color, "cannot be bold");
 
-        if (isupper (*color))
+        if (isupper ((unsigned char)*color))
           {
             switch (index)
               {
@@ -1196,13 +1235,13 @@ gather_color_names (const char *color_string, char *attr, struct color_name **co
         STACK_VAR (color_names[index]->orig);
 
         for (ch = color; *ch; ch++)
-          *ch = tolower (*ch);
+          *ch = tolower ((unsigned char)*ch);
 
         color_names[index]->name = xstrdup (color);
         STACK_VAR (color_names[index]->name);
       }
 
-    RELEASE_VAR (str);
+    RELEASE (str);
 }
 
 static void
@@ -1562,10 +1601,10 @@ gather_esc_offsets (const char *p, const char **start, const char **end)
             do {
               check_values = false;
               iter++;
-              if (!isdigit (*p))
+              if (!isdigit ((unsigned char)*p))
                 break;
               digit = p;
-              while (isdigit (*p))
+              while (isdigit ((unsigned char)*p))
                 p++;
               if (p - digit > 2)
                 break;
@@ -1598,7 +1637,7 @@ gather_esc_offsets (const char *p, const char **start, const char **end)
 static bool
 validate_esc_clean_all (const char **p)
 {
-    while (isdigit (**p) || **p == ';')
+    while (isdigit ((unsigned char)**p) || **p == ';')
       (*p)++;
     return (**p == 'm');
 }
@@ -1806,7 +1845,7 @@ has_color_name (const char *str, const char *name)
     assert (strlen (str) > 0);
     assert (strlen (name) > 0);
 
-    if (!(*str == *name || *str == toupper (*name)))
+    if (!(*str == *name || *str == toupper ((unsigned char)*name)))
       return false;
     else if (*(name + 1) != '\0'
      && !((p = strstr (str + 1, name + 1)) && p == str + 1))
@@ -1850,41 +1889,63 @@ vfprintf_fail (const char *fmt, ...)
 }
 
 static void
-stack_var (void ***list, unsigned int *stacked, unsigned int index, void *ptr)
+stack (struct var_list **list, unsigned int *stacked, unsigned int index, void *ptr, enum var_type type)
 {
+    struct var_list *var;
     /* nothing to stack */
     if (ptr == NULL)
       return;
     if (!*list)
-      *list = xmalloc (sizeof (void *));
+      *list = xmalloc (sizeof (struct var_list));
     else
       {
         unsigned int i;
         for (i = 0; i < *stacked; i++)
-          if (!(*list)[i])
-            {
-              (*list)[i] = ptr;
-              return; /* reused */
-            }
-        *list = xrealloc (*list, (*stacked + 1) * sizeof (void *));
+          {
+            var = &(*list)[i];
+            if (var->type == IS_UNUSED)
+              {
+                var->ptr  = ptr;
+                var->type = type;
+                return; /* reused */
+              }
+          }
+        *list = xrealloc (*list, (*stacked + 1) * sizeof (struct var_list));
       }
-    (*list)[index] = ptr;
+    var = &(*list)[index];
+    var->ptr  = ptr;
+    var->type = type;
     (*stacked)++;
 }
 
 static void
-release_var (void **list, unsigned int stacked, void **ptr)
+release (struct var_list *list, unsigned int stacked, void **ptr)
 {
     unsigned int i;
     /* nothing to release */
     if (*ptr == NULL)
       return;
     for (i = 0; i < stacked; i++)
-      if (list[i] == *ptr)
-        {
-          free (*ptr);
-          *ptr = NULL;
-          list[i] = NULL;
-          return;
+      {
+        struct var_list *var = &list[i];
+        if (var->type != IS_UNUSED
+         && var->ptr == *ptr)
+          {
+            switch (var->type)
+              {
+                case IS_GENERIC:
+                  free (*ptr);
+                  break;
+                case IS_FILE:
+                  fclose (*ptr);
+                  break;
+                default: /* never reached */
+                  ABORT_TRACE ();
+              }
+            *ptr = NULL;
+            var->ptr  = NULL;
+            var->type = IS_UNUSED;
+            return;
         }
+    }
 }