More refactoring.

diff --git a/report.c b/report.c
index f064eca7076a1ee8bf384fdacbd0383a8be188aa..963008d7aff21797bfd8f11b98248d81d98c8f26 100644 (file)
--- a/report.c
+++ b/report.c
@@ -81,7 +81,7 @@ static void report_time(char *legend, ...)
     mark_time = endtime;
 }
 
-void init_intern(const int count)
+static void init_intern(const int count)
 /* prepare an alllocation area of a given size */
 {
     np=obarray=(struct sorthash_t *)calloc(sizeof(struct sorthash_t),count);
@@ -91,145 +91,146 @@ void init_intern(const int count)
     }
 }
 
- void file_intern(const char *file)
- /* stash the name of a file */
- {
-     struct item *new;
+static void file_intern(const char *file)
+/* stash the name of a file */
+{
+    struct item *new;
 
-     new = (struct item *)malloc(sizeof(struct item));
-     new->file = strdup(file);
-     new->next = head;
-     head = new;
- }
+    new = (struct item *)malloc(sizeof(struct item));
+    new->file = strdup(file);
+    new->next = head;
+    head = new;
+}
 
- void hash_intern(const struct hash_t *chunk)
- {
+void hash_intern(const struct hash_t *chunk)
+/* enter a has into the in-core array */
+{
      np->file = head->file;
      np->hash = *chunk;
      np++;
- }
-
- static void merge_hashes(int argc, char *argv[])
- /* merge hashes from specified files into an in-code list */
- {
-     struct shif_t *sp;
-     struct stat sb;
-     long total;
-
-     /* set up metadata blocks for the hash files */
-     shiflist = (struct shif_t *)calloc(sizeof(struct shif_t), argc);
-     for (sp = shiflist; sp < shiflist + argc; sp++)
-     {
-        char   buf[BUFSIZ];
+}
 
-        sp->name = strdup(argv[sp - shiflist]);
-        sp->fp   = fopen(sp->name, "r");
-        fgets(buf, sizeof(buf), sp->fp);
-        if (strncmp(buf, "#SHIF-A ", 8))
-        {
-            fprintf(stderr, 
-                    "shredcompare: %s is not a SHIF-A file.", 
-                    sp->name);
-            exit(1);
-        }
-        while (fgets(buf, sizeof(buf), sp->fp) != NULL)
-        {
-            char       *value;
-
-            if (!strcmp(buf, "%%\n"))
-                break;
-            value = strchr(buf, ':');
-            *value++ = '\0';
-            while(*value == ' ')
-                value++;
-            strchr(value, '\n')[0] = '\0';
-
-            if (!strcmp(buf, "Normalization"))
-                sp->normalization = strdup(value);
-            else if (!strcmp(buf, "Shred-Size"))
-                sp->shred_size = atoi(value);
-            else if (!strcmp(buf, "Hash-Method"))
-                sp->hash_method = strdup(value);
-            else if (!strcmp(buf, "Generator-Program"))
-                sp->generator_program = strdup(value);
-        }
-     }
+static void merge_hashes(int argc, char *argv[])
+/* merge hashes from specified files into an in-code list */
+{
+    struct shif_t *sp;
+    struct stat sb;
+    long total;
 
-     /* consistency checks */
-     for (sp = shiflist; sp < shiflist + argc-1; sp++)
-     {
-        struct shif_t  *next = sp + 1;
+    /* set up metadata blocks for the hash files */
+    shiflist = (struct shif_t *)calloc(sizeof(struct shif_t), argc);
+    for (sp = shiflist; sp < shiflist + argc; sp++)
+    {
+       char    buf[BUFSIZ];
 
-        if (strcmp(sp->normalization, next->normalization))
-        {
-            fprintf(stderr, 
-                    "shredcompare: normalizations of %s and %s don't match\n",
-                    sp->name, next->name);
-            exit(1);
-        }
-        else if (sp->shred_size != next->shred_size)
-        {
-            fprintf(stderr, 
-                    "shredcompare: shred sizes of %s and %s don't match\n",
-                    sp->name, next->name);
-            exit(1);
+       sp->name = strdup(argv[sp - shiflist]);
+       sp->fp   = fopen(sp->name, "r");
+       fgets(buf, sizeof(buf), sp->fp);
+       if (strncmp(buf, "#SHIF-A ", 8))
+       {
+           fprintf(stderr, 
+                   "shredcompare: %s is not a SHIF-A file.", 
+                   sp->name);
+           exit(1);
+       }
+       while (fgets(buf, sizeof(buf), sp->fp) != NULL)
+       {
+           char        *value;
+
+           if (!strcmp(buf, "%%\n"))
+               break;
+           value = strchr(buf, ':');
+           *value++ = '\0';
+           while(*value == ' ')
+               value++;
+           strchr(value, '\n')[0] = '\0';
+
+           if (!strcmp(buf, "Normalization"))
+               sp->normalization = strdup(value);
+           else if (!strcmp(buf, "Shred-Size"))
+               sp->shred_size = atoi(value);
+           else if (!strcmp(buf, "Hash-Method"))
+               sp->hash_method = strdup(value);
+           else if (!strcmp(buf, "Generator-Program"))
+               sp->generator_program = strdup(value);
+       }
+    }
 
-        }
-        else if (strcmp(sp->hash_method, next->hash_method))
-        {
-            fprintf(stderr, 
-                    "shredcompare: hash methods of %s and %s don't match\n",
-                    sp->name, next->name);
-            exit(1);
-        }
-     }
+    /* consistency checks */
+    for (sp = shiflist; sp < shiflist + argc-1; sp++)
+    {
+       struct shif_t   *next = sp + 1;
 
-     /* compute total data to be read, we'll use this for the progress meter */
-     total = 0;
-     for (sp = shiflist; sp < shiflist + argc; sp++)
-     {
-        stat(sp->name, &sb);
-        total += sb.st_size - ftell(sp->fp);
-     }
-     init_intern(total/sizeof(struct hash_t)); /* real work done here */
+       if (strcmp(sp->normalization, next->normalization))
+       {
+           fprintf(stderr, 
+                   "shredcompare: normalizations of %s and %s don't match\n",
+                   sp->name, next->name);
+           exit(1);
+       }
+       else if (sp->shred_size != next->shred_size)
+       {
+           fprintf(stderr, 
+                   "shredcompare: shred sizes of %s and %s don't match\n",
+                   sp->name, next->name);
+           exit(1);
 
-     /* read in all hashes */
-     hashcount = 0;
-     for (sp = shiflist; sp < shiflist + argc; sp++)
-     {
-        u_int32_t      sectcount;
+       }
+       else if (strcmp(sp->hash_method, next->hash_method))
+       {
+           fprintf(stderr, 
+                   "shredcompare: hash methods of %s and %s don't match\n",
+                   sp->name, next->name);
+           exit(1);
+       }
+    }
 
-        fprintf(stderr, "Reading %s...   ", sp->name);
-        fread(&sectcount, sizeof(u_int32_t), 1, sp->fp);
-        sectcount = ntohl(sectcount);
-        while (sectcount--)
-        {
-            char       buf[BUFSIZ];
-            linenum_t  chunks;
+    /* compute total data to be read, we'll use this for the progress meter */
+    total = 0;
+    for (sp = shiflist; sp < shiflist + argc; sp++)
+    {
+       stat(sp->name, &sb);
+       total += sb.st_size - ftell(sp->fp);
+    }
+    init_intern(total/sizeof(struct hash_t));  /* real work done here */
 
-            fgets(buf, sizeof(buf), sp->fp);
-            *strchr(buf, '\n') = '\0';
-            file_intern(buf);                  /* real work done here */
-            fread(&chunks, sizeof(linenum_t), 1, sp->fp);
-            chunks = FROMNET(chunks);
+    /* read in all hashes */
+    hashcount = 0;
+    for (sp = shiflist; sp < shiflist + argc; sp++)
+    {
+       u_int32_t       sectcount;
 
-            while (chunks--)
-            {
-                struct hash_t  this;
-
-                fread(&this, sizeof(struct hash_t), 1, sp->fp);
-                this.start = FROMNET(this.start);
-                this.end = FROMNET(this.end);
-                hash_intern(&this);            /* real work done here */
-                hashcount++;
-                sp->hashcount++;
-                if (hashcount % 10000 == 0)
-                    fprintf(stderr, "\b\b\b%02.0f%%", (ftell(sp->fp) / (total * 0.01)));
-            }
-        }
-        fprintf(stderr, "\b\b\b100%%...done, %d entries\n", sp->hashcount);
-     }
- }
+       fprintf(stderr, "Reading %s...   ", sp->name);
+       fread(&sectcount, sizeof(u_int32_t), 1, sp->fp);
+       sectcount = ntohl(sectcount);
+       while (sectcount--)
+       {
+           char        buf[BUFSIZ];
+           linenum_t   chunks;
+
+           fgets(buf, sizeof(buf), sp->fp);
+           *strchr(buf, '\n') = '\0';
+           file_intern(buf);                   /* real work done here */
+           fread(&chunks, sizeof(linenum_t), 1, sp->fp);
+           chunks = FROMNET(chunks);
+
+           while (chunks--)
+           {
+               struct hash_t   this;
+
+               fread(&this, sizeof(struct hash_t), 1, sp->fp);
+               this.start = FROMNET(this.start);
+               this.end = FROMNET(this.end);
+               hash_intern(&this);             /* real work done here */
+               hashcount++;
+               sp->hashcount++;
+               if (hashcount % 10000 == 0)
+                   fprintf(stderr, "\b\b\b%02.0f%%", (ftell(sp->fp) / (total * 0.01)));
+           }
+       }
+       fprintf(stderr, "\b\b\b100%%...done, %d entries\n", sp->hashcount);
+    }
+}
 
 static int merge_ranges(struct range_t *p, struct range_t *q, int nmatches)
 /* merge t into s, if the ranges in the match are compatible */
@@ -438,7 +439,7 @@ struct match_t *reduce_matches(void)
      return reduced;
 }
 
-int sortchunk(void *a, void *b)
+static int sortchunk(void *a, void *b)
 /* sort by hash */
 {
     int cmp = HASHCMP((struct sorthash_t *)a, (struct sorthash_t *)b);
@@ -455,7 +456,7 @@ int sortchunk(void *a, void *b)
                      ((struct sorthash_t *)b)->file));
 }
 
-int sortmatch(void *a, void *b)
+static int sortmatch(void *a, void *b)
 /* sort by file and first line */
 {
     struct range_t *s = ((struct match_t *)a)->matches;

diff --git a/shred.h b/shred.h
index 36097838686ea2d3e4391c18dcdc5e9afaf4bfb8..2746a2f49235ec9ffa451630775d11a4198145ba 100644 (file)
--- a/shred.h
+++ b/shred.h
@@ -21,8 +21,4 @@ struct hash_t
     unsigned char      hash[HASHSIZE];
 };
 
-/* hashmap.c */
-void file_intern(const char *);
-void hash_intern(const struct hash_t *);
-
 /* shred.h ends here */